apps/silcd/packet_receive.c

   1 /*
   2
   3   packet_receive.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2002 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /*
  21  * Server packet routines to handle received packets.
  22  */
  23 /* $Id$ */
  24
  25 #include "serverincludes.h"
  26 #include "server_internal.h"
  27
  28 /* Received notify packet. Server can receive notify packets from router.
  29    Server then relays the notify messages to clients if needed. */
  30
  31 void silc_server_notify(SilcServer server,
  32                         SilcSocketConnection sock,
  33                         SilcPacketContext *packet)
  34 {
  35   SilcNotifyPayload payload;
  36   SilcNotifyType type;
  37   SilcArgumentPayload args;
  38   SilcChannelID *channel_id = NULL, *channel_id2;
  39   SilcClientID *client_id, *client_id2;
  40   SilcServerID *server_id;
  41   SilcIdType id_type;
  42   SilcChannelEntry channel = NULL;
  43   SilcClientEntry client = NULL, client2 = NULL;
  44   SilcServerEntry server_entry = NULL;
  45   SilcChannelClientEntry chl;
  46   SilcIDCacheEntry cache = NULL;
  47   SilcHashTableList htl;
  48   SilcUInt32 mode;
  49   unsigned char *tmp;
  50   SilcUInt32 tmp_len;
  51   bool local;
  52
  53   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
  54       packet->src_id_type != SILC_ID_SERVER || !packet->dst_id) {
  55     SILC_LOG_DEBUG(("Bad notify packet received"));
  56     return;
  57   }
  58
  59   /* If the packet is destined directly to a client then relay the packet
  60      before processing it. */
  61   if (packet->dst_id_type == SILC_ID_CLIENT) {
  62     SilcIDListData idata;
  63     SilcSocketConnection dst_sock;
  64
  65     /* Get the route to the client */
  66     dst_sock = silc_server_get_client_route(server, packet->dst_id,
  67                                             packet->dst_id_len, NULL,
  68                                             &idata, NULL);
  69     if (dst_sock)
  70       /* Relay the packet */
  71       silc_server_relay_packet(server, dst_sock, idata->send_key,
  72                                idata->hmac_send, idata->psn_send++,
  73                                packet, TRUE);
  74   }
  75
  76   /* Parse the Notify Payload */
  77   payload = silc_notify_payload_parse(packet->buffer->data,
  78                                       packet->buffer->len);
  79   if (!payload)
  80     return;
  81
  82   /* If we are router and this packet is not already broadcast packet
  83      we will broadcast it. The sending socket really cannot be router or
  84      the router is buggy. If this packet is coming from router then it must
  85      have the broadcast flag set already and we won't do anything. */
  86   if (server->server_type == SILC_ROUTER &&
  87       sock->type == SILC_SOCKET_TYPE_SERVER &&
  88       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
  89     SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
  90     if (packet->dst_id_type == SILC_ID_CHANNEL) {
  91       /* Packet is destined to channel */
  92       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
  93                                   packet->dst_id_type);
  94       if (!channel_id)
  95         goto out;
  96
  97       silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
  98                                    packet->type, packet->flags |
  99                                    SILC_PACKET_FLAG_BROADCAST,
 100                                    channel_id, SILC_ID_CHANNEL,
 101                                    packet->buffer->data,
 102                                    packet->buffer->len, FALSE);
 103       silc_server_backup_send_dest(server, sock->user_data,
 104                                    packet->type, packet->flags,
 105                                    channel_id, SILC_ID_CHANNEL,
 106                                    packet->buffer->data, packet->buffer->len,
 107                                    FALSE, TRUE);
 108     } else {
 109       /* Packet is destined to client or server */
 110       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
 111                               packet->type,
 112                               packet->flags | SILC_PACKET_FLAG_BROADCAST,
 113                               packet->buffer->data, packet->buffer->len,
 114                               FALSE);
 115       silc_server_backup_send(server, sock->user_data,
 116                               packet->type, packet->flags,
 117                               packet->buffer->data, packet->buffer->len,
 118                               FALSE, TRUE);
 119     }
 120   }
 121
 122   type = silc_notify_get_type(payload);
 123   args = silc_notify_get_args(payload);
 124   if (!args)
 125     goto out;
 126
 127   switch(type) {
 128   case SILC_NOTIFY_TYPE_JOIN:
 129     /*
 130      * Distribute the notify to local clients on the channel
 131      */
 132     SILC_LOG_DEBUG(("JOIN notify"));
 133
 134     /* Get Channel ID */
 135     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 136     if (!tmp)
 137       goto out;
 138     channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
 139     if (!channel_id)
 140       goto out;
 141
 142     /* Get channel entry */
 143     channel = silc_idlist_find_channel_by_id(server->global_list,
 144                                              channel_id, NULL);
 145     if (!channel) {
 146       channel = silc_idlist_find_channel_by_id(server->local_list,
 147                                                channel_id, NULL);
 148       if (!channel) {
 149         SILC_LOG_DEBUG(("Notify for unknown channel"));
 150         silc_free(channel_id);
 151         goto out;
 152       }
 153     }
 154     silc_free(channel_id);
 155
 156     /* Get client ID */
 157     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 158     if (!tmp)
 159       goto out;
 160     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
 161     if (!client_id)
 162       goto out;
 163
 164     /* If the the client is not in local list we check global list (ie. the
 165        channel will be global channel) and if it does not exist then create
 166        entry for the client. */
 167     client = silc_idlist_find_client_by_id(server->global_list,
 168                                            client_id, server->server_type,
 169                                            &cache);
 170     if (!client) {
 171       client = silc_idlist_find_client_by_id(server->local_list,
 172                                              client_id, server->server_type,
 173                                              &cache);
 174       if (!client) {
 175         /* If router did not find the client the it is bogus */
 176         if (server->server_type != SILC_SERVER) {
 177           silc_free(client_id);
 178           goto out;
 179         }
 180
 181         client =
 182           silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
 183                                  silc_id_dup(client_id, SILC_ID_CLIENT),
 184                                  sock->user_data, NULL, 0);
 185         if (!client) {
 186           SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
 187           silc_free(client_id);
 188           goto out;
 189         }
 190
 191         client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
 192       }
 193     }
 194     silc_free(client_id);
 195
 196     /* Do not process the notify if the client is not registered */
 197     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
 198       break;
 199
 200     /* Do not add client to channel if it is there already */
 201     if (silc_server_client_on_channel(client, channel, NULL)) {
 202       SILC_LOG_DEBUG(("Client already on channel %s",
 203                       channel->channel_name));
 204       break;
 205     }
 206
 207     /* Send to channel */
 208     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 209                                        FALSE, packet->buffer->data,
 210                                        packet->buffer->len, FALSE);
 211
 212     if (server->server_type != SILC_ROUTER &&
 213         sock->type == SILC_SOCKET_TYPE_ROUTER)
 214       /* The channel is global now */
 215       channel->global_users = TRUE;
 216
 217     SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
 218
 219     /* JOIN the global client to the channel (local clients (if router
 220        created the channel) is joined in the pending JOIN command). */
 221     chl = silc_calloc(1, sizeof(*chl));
 222     chl->client = client;
 223     chl->channel = channel;
 224
 225     if (server->server_type != SILC_ROUTER ||
 226         sock->type == SILC_SOCKET_TYPE_ROUTER) {
 227       /* If this is the first one on the channel then it is the founder of
 228          the channel. This is done on normal server and on router if this
 229          notify is coming from router */
 230       if (!silc_hash_table_count(channel->user_list)) {
 231         SILC_LOG_DEBUG(("Client %s is founder on channel",
 232                         silc_id_render(chl->client->id, SILC_ID_CLIENT)));
 233         chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
 234       }
 235     }
 236
 237     silc_hash_table_add(channel->user_list, client, chl);
 238     silc_hash_table_add(client->channels, channel, chl);
 239     channel->user_count++;
 240     channel->disabled = FALSE;
 241
 242     /* Make sure we don't expire clients that are on channel */
 243     if (cache)
 244       cache->expire = 0;
 245
 246     /* Update statistics */
 247     if (server->server_type == SILC_ROUTER) {
 248       if (sock->type != SILC_SOCKET_TYPE_ROUTER)
 249         server->stat.cell_chanclients++;
 250       server->stat.chanclients++;
 251     }
 252
 253     break;
 254
 255   case SILC_NOTIFY_TYPE_LEAVE:
 256     /*
 257      * Distribute the notify to local clients on the channel
 258      */
 259     SILC_LOG_DEBUG(("LEAVE notify"));
 260
 261     if (!channel_id) {
 262       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 263                                   packet->dst_id_type);
 264       if (!channel_id)
 265         goto out;
 266     }
 267
 268     /* Get channel entry */
 269     channel = silc_idlist_find_channel_by_id(server->global_list,
 270                                              channel_id, NULL);
 271     if (!channel) {
 272       channel = silc_idlist_find_channel_by_id(server->local_list,
 273                                                channel_id, NULL);
 274       if (!channel) {
 275         SILC_LOG_DEBUG(("Notify for unknown channel"));
 276         silc_free(channel_id);
 277         goto out;
 278       }
 279     }
 280
 281     /* Get client ID */
 282     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 283     if (!tmp) {
 284       silc_free(channel_id);
 285       goto out;
 286     }
 287     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
 288     if (!client_id) {
 289       silc_free(channel_id);
 290       goto out;
 291     }
 292
 293     /* Get client entry */
 294     client = silc_idlist_find_client_by_id(server->global_list,
 295                                            client_id, TRUE, NULL);
 296     if (!client) {
 297       client = silc_idlist_find_client_by_id(server->local_list,
 298                                              client_id, TRUE, NULL);
 299       if (!client) {
 300         silc_free(client_id);
 301         silc_free(channel_id);
 302         goto out;
 303       }
 304     }
 305     silc_free(client_id);
 306
 307     /* Check if on channel */
 308     if (!silc_server_client_on_channel(client, channel, NULL))
 309       break;
 310
 311     /* Send the leave notify to channel */
 312     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 313                                        FALSE, packet->buffer->data,
 314                                        packet->buffer->len, FALSE);
 315
 316     /* Remove the user from channel */
 317     silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
 318     break;
 319
 320   case SILC_NOTIFY_TYPE_SIGNOFF:
 321     /*
 322      * Distribute the notify to local clients on the channel
 323      */
 324     SILC_LOG_DEBUG(("SIGNOFF notify"));
 325
 326     /* Get client ID */
 327     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 328     if (!tmp)
 329       goto out;
 330     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
 331     if (!client_id)
 332       goto out;
 333
 334     /* Get client entry */
 335     client = silc_idlist_find_client_by_id(server->global_list,
 336                                            client_id, TRUE, &cache);
 337     if (!client) {
 338       client = silc_idlist_find_client_by_id(server->local_list,
 339                                              client_id, TRUE, &cache);
 340       if (!client) {
 341         silc_free(client_id);
 342         goto out;
 343       }
 344     }
 345     silc_free(client_id);
 346
 347     /* Get signoff message */
 348     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 349     if (tmp_len > 128)
 350       tmp = NULL;
 351
 352     /* Update statistics */
 353     server->stat.clients--;
 354     if (server->stat.cell_clients)
 355       server->stat.cell_clients--;
 356     SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
 357     SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
 358     silc_schedule_task_del_by_context(server->schedule, client);
 359
 360     /* Remove the client from all channels. */
 361     silc_server_remove_from_channels(server, NULL, client, TRUE, tmp, FALSE);
 362
 363     /* Check if anyone is watching this nickname */
 364     if (server->server_type == SILC_ROUTER)
 365       silc_server_check_watcher_list(server, client, NULL,
 366                                      SILC_NOTIFY_TYPE_SIGNOFF);
 367
 368     /* Remove this client from watcher list if it is */
 369     silc_server_del_from_watcher_list(server, client);
 370
 371     client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
 372     cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
 373     break;
 374
 375   case SILC_NOTIFY_TYPE_TOPIC_SET:
 376     /*
 377      * Distribute the notify to local clients on the channel
 378      */
 379
 380     SILC_LOG_DEBUG(("TOPIC SET notify"));
 381
 382     /* Get client ID */
 383     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 384     if (!tmp)
 385       goto out;
 386     client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
 387     if (!client_id)
 388       goto out;
 389
 390     /* Get client entry */
 391     if (id_type == SILC_ID_CLIENT) {
 392       client = silc_idlist_find_client_by_id(server->global_list,
 393                                              client_id, TRUE, &cache);
 394       if (!client) {
 395         client = silc_idlist_find_client_by_id(server->local_list,
 396                                                client_id, TRUE, &cache);
 397         if (!client) {
 398           silc_free(client_id);
 399           goto out;
 400         }
 401       }
 402       silc_free(client_id);
 403     }
 404
 405     /* Get the topic */
 406     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 407     if (!tmp) {
 408       silc_free(channel_id);
 409       goto out;
 410     }
 411
 412     if (!channel_id) {
 413       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 414                                   packet->dst_id_type);
 415       if (!channel_id)
 416         goto out;
 417     }
 418
 419     /* Get channel entry */
 420     channel = silc_idlist_find_channel_by_id(server->global_list,
 421                                              channel_id, NULL);
 422     if (!channel) {
 423       channel = silc_idlist_find_channel_by_id(server->local_list,
 424                                                channel_id, NULL);
 425       if (!channel) {
 426         SILC_LOG_DEBUG(("Notify for unknown channel"));
 427         silc_free(channel_id);
 428         goto out;
 429       }
 430     }
 431     silc_free(channel_id);
 432
 433     if (channel->topic && !strcmp(channel->topic, tmp)) {
 434       SILC_LOG_DEBUG(("Topic is already set and same"));
 435       goto out;
 436     }
 437
 438     if (client) {
 439       /* Get user's channel entry and check that topic set is allowed. */
 440       if (!silc_server_client_on_channel(client, channel, &chl))
 441         goto out;
 442       if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
 443           !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
 444           !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
 445         SILC_LOG_DEBUG(("Topic change is not allowed"));
 446         goto out;
 447       }
 448     }
 449
 450     /* Change the topic */
 451     silc_free(channel->topic);
 452     channel->topic = strdup(tmp);
 453
 454     /* Send the same notify to the channel */
 455     silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
 456                                        FALSE, packet->buffer->data,
 457                                        packet->buffer->len, FALSE);
 458     break;
 459
 460   case SILC_NOTIFY_TYPE_NICK_CHANGE:
 461     {
 462       /*
 463        * Distribute the notify to local clients on the channel
 464        */
 465       unsigned char *id, *id2;
 466       char *nickname;
 467       SilcUInt32 nickname_len;
 468
 469       SILC_LOG_DEBUG(("NICK CHANGE notify"));
 470
 471       /* Get old client ID */
 472       id = silc_argument_get_arg_type(args, 1, &tmp_len);
 473       if (!id)
 474         goto out;
 475       client_id = silc_id_payload_parse_id(id, tmp_len, NULL);
 476       if (!client_id)
 477         goto out;
 478
 479       /* Get new client ID */
 480       id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
 481       if (!id2)
 482         goto out;
 483       client_id2 = silc_id_payload_parse_id(id2, tmp_len, NULL);
 484       if (!client_id2) {
 485         silc_free(client_id);
 486         goto out;
 487       }
 488
 489       SILC_LOG_DEBUG(("Old Client ID id(%s)",
 490                       silc_id_render(client_id, SILC_ID_CLIENT)));
 491       SILC_LOG_DEBUG(("New Client ID id(%s)",
 492                       silc_id_render(client_id2, SILC_ID_CLIENT)));
 493
 494       /* From protocol version 1.1 we also get the new nickname */
 495       nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
 496
 497       /* Replace the Client ID */
 498       client = silc_idlist_replace_client_id(server,
 499                                              server->global_list, client_id,
 500                                              client_id2, nickname);
 501       if (!client)
 502         client = silc_idlist_replace_client_id(server,
 503                                                server->local_list, client_id,
 504                                                client_id2, nickname);
 505
 506       if (client) {
 507         /* Send the NICK_CHANGE notify type to local clients on the channels
 508            this client is joined to. */
 509         silc_server_send_notify_on_channels(server, client, client,
 510                                             SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
 511                                             id, tmp_len, id2, tmp_len,
 512                                             nickname, nickname ?
 513                                             nickname_len : 0);
 514       }
 515
 516       silc_free(client_id);
 517       if (!client)
 518         silc_free(client_id2);
 519       break;
 520     }
 521
 522   case SILC_NOTIFY_TYPE_CMODE_CHANGE:
 523     /*
 524      * Distribute the notify to local clients on the channel
 525      */
 526
 527     SILC_LOG_DEBUG(("CMODE CHANGE notify"));
 528
 529     /* Get client ID */
 530     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 531     if (!tmp)
 532       goto out;
 533     client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
 534     if (!client_id)
 535       goto out;
 536
 537     /* Get client entry */
 538     if (id_type == SILC_ID_CLIENT) {
 539       client = silc_idlist_find_client_by_id(server->global_list,
 540                                              client_id, TRUE, &cache);
 541       if (!client) {
 542         client = silc_idlist_find_client_by_id(server->local_list,
 543                                                client_id, TRUE, &cache);
 544         if (!client) {
 545           silc_free(client_id);
 546           goto out;
 547         }
 548       }
 549       silc_free(client_id);
 550     }
 551
 552     if (!channel_id) {
 553       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 554                                   packet->dst_id_type);
 555       if (!channel_id)
 556         goto out;
 557     }
 558
 559     /* Get channel entry */
 560     channel = silc_idlist_find_channel_by_id(server->global_list,
 561                                              channel_id, NULL);
 562     if (!channel) {
 563       channel = silc_idlist_find_channel_by_id(server->local_list,
 564                                                channel_id, NULL);
 565       if (!channel) {
 566         SILC_LOG_DEBUG(("Notify for unknown channel"));
 567         silc_free(channel_id);
 568         goto out;
 569       }
 570     }
 571     silc_free(channel_id);
 572
 573     /* Get the mode */
 574     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 575     if (!tmp)
 576       goto out;
 577     SILC_GET32_MSB(mode, tmp);
 578
 579     /* Check if mode changed */
 580     if (channel->mode == mode) {
 581       SILC_LOG_DEBUG(("Mode is changed already"));
 582
 583       /* If this mode change has founder mode then we'll enforce the
 584          change so that the server gets the real founder public key */
 585       if (server->server_type != SILC_SERVER &&
 586           sock != SILC_PRIMARY_ROUTE(server) &&
 587           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
 588         SILC_LOG_DEBUG(("Sending founder public key to server"));
 589         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 590                                       channel->mode, server->id,
 591                                       SILC_ID_SERVER, channel->cipher,
 592                                       channel->hmac_name,
 593                                       channel->passphrase,
 594                                       channel->founder_key);
 595       }
 596
 597       /* If we received same mode from our primary check whether founder
 598          mode and key in the notify is set.  We update the founder key
 599          here since we may have wrong one */
 600       if (server->server_type == SILC_SERVER &&
 601           sock == SILC_PRIMARY_ROUTE(server) &&
 602           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 603         SILC_LOG_DEBUG(("Founder public key received from router"));
 604         tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
 605         if (!tmp)
 606           break;
 607
 608         if (channel->founder_key)
 609           silc_pkcs_public_key_free(channel->founder_key);
 610         channel->founder_key = NULL;
 611         silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
 612       }
 613
 614       break;
 615     }
 616
 617     /* Get user's channel entry and check that mode change is allowed */
 618     if (client) {
 619       if (!silc_server_client_on_channel(client, channel, &chl))
 620         goto out;
 621       if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
 622         SILC_LOG_DEBUG(("CMODE change is not allowed"));
 623         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 624                                       channel->mode, server->id,
 625                                       SILC_ID_SERVER, channel->cipher,
 626                                       channel->hmac_name,
 627                                       channel->passphrase,
 628                                       channel->founder_key);
 629         goto out;
 630       }
 631     } else {
 632       /* Assure that server is not removing founder mode from us */
 633       if (server->server_type == SILC_ROUTER &&
 634           sock != SILC_PRIMARY_ROUTE(server) &&
 635           channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
 636           !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
 637         SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 638         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 639                                       channel->mode, server->id,
 640                                       SILC_ID_SERVER, channel->cipher,
 641                                       channel->hmac_name,
 642                                       channel->passphrase,
 643                                       channel->founder_key);
 644         goto out;
 645       }
 646
 647       /* If server is adding founder mode, check whether there is founder
 648          on channel already and is not from this server */
 649       if (server->server_type == SILC_ROUTER &&
 650           sock != SILC_PRIMARY_ROUTE(server) &&
 651           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 652         silc_hash_table_list(channel->user_list, &htl);
 653         while (silc_hash_table_get(&htl, NULL, (void *)&chl))
 654           if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
 655               chl->client->router != sock->user_data) {
 656             SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 657             silc_server_send_notify_cmode(server, sock, FALSE, channel,
 658                                           channel->mode, server->id,
 659                                           SILC_ID_SERVER, channel->cipher,
 660                                           channel->hmac_name,
 661                                           channel->passphrase,
 662                                           channel->founder_key);
 663             silc_hash_table_list_reset(&htl);
 664             goto out;
 665           }
 666         silc_hash_table_list_reset(&htl);
 667       }
 668     }
 669
 670     /* If the channel had private keys set and the mode was removed then
 671        we must re-generate and re-distribute a new channel key */
 672     if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
 673         !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
 674       /* Re-generate channel key */
 675       if (!silc_server_create_channel_key(server, channel, 0))
 676         goto out;
 677
 678       /* Send the channel key. This sends it to our local clients and if
 679          we are normal server to our router as well. */
 680       silc_server_send_channel_key(server, NULL, channel,
 681                                    server->server_type == SILC_ROUTER ?
 682                                    FALSE : !server->standalone);
 683     }
 684
 685     /* Get the hmac */
 686     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 687     if (tmp) {
 688       unsigned char hash[32];
 689
 690       if (channel->hmac)
 691         silc_hmac_free(channel->hmac);
 692       if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
 693         goto out;
 694
 695       /* Set the HMAC key out of current channel key. The client must do
 696          this locally. */
 697       silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
 698                      channel->key_len / 8, hash);
 699       silc_hmac_set_key(channel->hmac, hash,
 700                         silc_hash_len(silc_hmac_get_hash(channel->hmac)));
 701       memset(hash, 0, sizeof(hash));
 702     }
 703
 704     /* Get the passphrase */
 705     tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
 706     if (tmp) {
 707       silc_free(channel->passphrase);
 708       channel->passphrase = silc_memdup(tmp, tmp_len);
 709     }
 710
 711     /* Get founder public key */
 712     tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
 713     if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 714       if (channel->founder_key)
 715         silc_pkcs_public_key_free(channel->founder_key);
 716       channel->founder_key = NULL;
 717       silc_pkcs_public_key_decode(tmp, tmp_len, &channel->founder_key);
 718
 719       if (!channel->founder_key ||
 720           (client && client->data.public_key &&
 721            server->server_type == SILC_ROUTER &&
 722            !silc_pkcs_public_key_compare(channel->founder_key,
 723                                          client->data.public_key))) {
 724         /* A really buggy server isn't checking public keys correctly.
 725            It's not possible that the mode setter and founder wouldn't
 726            have same public key. */
 727         SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 728
 729         mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
 730         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 731                                       mode, server->id, SILC_ID_SERVER,
 732                                       channel->cipher,
 733                                       channel->hmac_name,
 734                                       channel->passphrase, NULL);
 735         if (channel->founder_key)
 736           silc_pkcs_public_key_free(channel->founder_key);
 737         channel->founder_key = NULL;
 738       } else if (client && !client->data.public_key) {
 739         client->data.public_key =
 740           silc_pkcs_public_key_copy(channel->founder_key);
 741       }
 742     }
 743
 744     if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
 745         server->server_type == SILC_ROUTER) {
 746       SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 747       mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
 748       silc_server_send_notify_cmode(server, sock, FALSE, channel,
 749                                     mode, server->id, SILC_ID_SERVER,
 750                                     channel->cipher,
 751                                     channel->hmac_name,
 752                                     channel->passphrase, NULL);
 753     }
 754
 755     /* Send the same notify to the channel */
 756     silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
 757                                        FALSE, packet->buffer->data,
 758                                        packet->buffer->len, FALSE);
 759
 760     /* Change mode */
 761     channel->mode = mode;
 762
 763     if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
 764         channel->founder_key) {
 765       silc_pkcs_public_key_free(channel->founder_key);
 766       channel->founder_key = NULL;
 767     }
 768
 769     break;
 770
 771   case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
 772     {
 773       /*
 774        * Distribute the notify to local clients on the channel
 775        */
 776       SilcChannelClientEntry chl2 = NULL;
 777       bool notify_sent = FALSE;
 778
 779       SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
 780
 781       /* Get client ID */
 782       tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 783       if (!tmp)
 784         goto out;
 785       client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
 786       if (!client_id)
 787         goto out;
 788
 789       /* Get client entry */
 790       if (id_type == SILC_ID_CLIENT) {
 791         client = silc_idlist_find_client_by_id(server->global_list,
 792                                                client_id, TRUE, &cache);
 793         if (!client) {
 794           client = silc_idlist_find_client_by_id(server->local_list,
 795                                                  client_id, TRUE, &cache);
 796           if (!client) {
 797             silc_free(client_id);
 798             goto out;
 799           }
 800         }
 801         silc_free(client_id);
 802       }
 803
 804       if (!channel_id) {
 805         channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 806                                     packet->dst_id_type);
 807         if (!channel_id)
 808           goto out;
 809       }
 810
 811       /* Get channel entry */
 812       channel = silc_idlist_find_channel_by_id(server->global_list,
 813                                                channel_id, NULL);
 814       if (!channel) {
 815         channel = silc_idlist_find_channel_by_id(server->local_list,
 816                                                  channel_id, NULL);
 817         if (!channel) {
 818           SILC_LOG_DEBUG(("Notify for unknown channel"));
 819           silc_free(channel_id);
 820           goto out;
 821         }
 822       }
 823
 824       /* Get the mode */
 825       tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 826       if (!tmp) {
 827         silc_free(channel_id);
 828         goto out;
 829       }
 830
 831       SILC_GET32_MSB(mode, tmp);
 832
 833       /* Get target client */
 834       tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
 835       if (!tmp)
 836         goto out;
 837       client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
 838       if (!client_id)
 839         goto out;
 840
 841       /* Get client entry */
 842       client2 = silc_idlist_find_client_by_id(server->global_list,
 843                                               client_id, TRUE, NULL);
 844       if (!client2) {
 845         client2 = silc_idlist_find_client_by_id(server->local_list,
 846                                                 client_id, TRUE, NULL);
 847         if (!client2) {
 848           silc_free(client_id);
 849           goto out;
 850         }
 851       }
 852       silc_free(client_id);
 853
 854       if (client) {
 855         /* Check that sender is on channel */
 856         if (!silc_server_client_on_channel(client, channel, &chl))
 857           goto out;
 858
 859         if (client != client2 && server->server_type == SILC_ROUTER) {
 860           /* Sender must be operator */
 861           if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
 862               !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
 863             SILC_LOG_DEBUG(("CUMODE change is not allowed"));
 864             goto out;
 865           }
 866
 867           if (!silc_server_client_on_channel(client2, channel, &chl))
 868             goto out;
 869
 870           /* If target is founder mode change is not allowed. */
 871           if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
 872             SILC_LOG_DEBUG(("CUMODE change is not allowed"));
 873             goto out;
 874           }
 875         }
 876       }
 877
 878       /* Get target channel user entry */
 879       if (!silc_server_client_on_channel(client2, channel, &chl))
 880         goto out;
 881
 882       if (server->server_type == SILC_SERVER && chl->mode == mode) {
 883         SILC_LOG_DEBUG(("Mode is changed already"));
 884         break;
 885       }
 886
 887       if (mode & SILC_CHANNEL_UMODE_CHANFO &&
 888           !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
 889           server->server_type == SILC_ROUTER &&
 890           sock != SILC_PRIMARY_ROUTE(server)) {
 891         SilcPublicKey founder_key = NULL;
 892
 893         /* If channel doesn't have founder auth mode then it's impossible
 894            that someone would be getting founder rights with CUMODE command.
 895            In that case there already either is founder or there isn't
 896            founder at all on the channel. */
 897         if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
 898           /* Force the mode to not have founder mode */
 899           chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 900           silc_server_force_cumode_change(server, sock, channel, chl, mode);
 901           notify_sent = TRUE;
 902           break;
 903         }
 904
 905         /* Get the founder of the channel and if found then this client
 906            cannot be the founder since there already is one. */
 907         silc_hash_table_list(channel->user_list, &htl);
 908         while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
 909           if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
 910             /* If the founder on the channel is not the one whom has set
 911                the founder mode, then it's possible that this CUMODE_CHANGE
 912                is correct.  Due to netsplits it's possible that this
 913                situation happens. */
 914             if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) ||
 915                 (channel->founder_key && chl2->client->data.public_key &&
 916                  silc_pkcs_public_key_compare(
 917                                         channel->founder_key,
 918                                         chl2->client->data.public_key))) {
 919               chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 920               silc_server_force_cumode_change(server, sock, channel,
 921                                               chl, mode);
 922               notify_sent = TRUE;
 923             }
 924             break;
 925           }
 926         silc_hash_table_list_reset(&htl);
 927         if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
 928           break;
 929
 930         /* Founder not found of the channel.  Since the founder auth mode
 931            is set on the channel now check whether this is the client that
 932            originally set the mode. */
 933
 934         if (channel->founder_key) {
 935           /* Get public key that must be present in notify */
 936           tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 937           if (!tmp || !silc_pkcs_public_key_decode(tmp, tmp_len,
 938                                                    &founder_key)) {
 939             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 940             silc_server_force_cumode_change(server, sock, channel, chl, mode);
 941             notify_sent = TRUE;
 942             break;
 943           }
 944
 945           /* Now match the public key we have cached and public key sent.
 946              They must match. */
 947           if (client && client->data.public_key &&
 948               !silc_pkcs_public_key_compare(channel->founder_key,
 949                                             client->data.public_key)) {
 950             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 951             silc_server_force_cumode_change(server, sock, channel, chl, mode);
 952             notify_sent = TRUE;
 953             break;
 954           }
 955           if (!silc_pkcs_public_key_compare(channel->founder_key,
 956                                             founder_key)) {
 957             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 958             silc_server_force_cumode_change(server, sock, channel, chl, mode);
 959             notify_sent = TRUE;
 960             break;
 961           }
 962         }
 963
 964         /* There cannot be anyone else as founder on the channel now.  This
 965            client is definitely the founder due to this authentication */
 966         silc_hash_table_list(channel->user_list, &htl);
 967         while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
 968           if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
 969             chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 970             silc_server_force_cumode_change(server, NULL, channel, chl2,
 971                                             chl2->mode);
 972             break;
 973           }
 974         silc_hash_table_list_reset(&htl);
 975
 976         if (founder_key)
 977           silc_pkcs_public_key_free(founder_key);
 978       }
 979
 980       if (server->server_type != SILC_SERVER && chl->mode == mode) {
 981         SILC_LOG_DEBUG(("Mode is changed already"));
 982         break;
 983       }
 984
 985       SILC_LOG_DEBUG(("Changing %s channel user mode",
 986                       chl->client->nickname ? chl->client->nickname :
 987                       (unsigned char *)""));
 988
 989       /* Change the mode */
 990       chl->mode = mode;
 991
 992       /* Send the same notify to the channel */
 993       if (!notify_sent)
 994         silc_server_packet_send_to_channel(server, NULL, channel,
 995                                            packet->type,
 996                                            FALSE, packet->buffer->data,
 997                                            packet->buffer->len, FALSE);
 998
 999       silc_free(channel_id);
1000       break;
1001     }
1002
1003   case SILC_NOTIFY_TYPE_INVITE:
1004
1005     if (packet->dst_id_type == SILC_ID_CLIENT)
1006       goto out;
1007
1008     SILC_LOG_DEBUG(("INVITE notify"));
1009
1010     /* Get Channel ID */
1011     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1012     if (!tmp)
1013       goto out;
1014     channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1015     if (!channel_id)
1016       goto out;
1017
1018     /* Get channel entry */
1019     channel = silc_idlist_find_channel_by_id(server->global_list,
1020                                              channel_id, NULL);
1021     if (!channel) {
1022       channel = silc_idlist_find_channel_by_id(server->local_list,
1023                                                channel_id, NULL);
1024       if (!channel) {
1025         SILC_LOG_DEBUG(("Notify for unknown channel"));
1026         silc_free(channel_id);
1027         goto out;
1028       }
1029     }
1030     silc_free(channel_id);
1031
1032     /* Get client ID */
1033     tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1034     if (!tmp)
1035       goto out;
1036     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1037     if (!client_id)
1038       goto out;
1039
1040     /* Get client entry */
1041     client = silc_idlist_find_client_by_id(server->global_list,
1042                                            client_id, TRUE, &cache);
1043     if (!client) {
1044       client = silc_idlist_find_client_by_id(server->local_list,
1045                                              client_id, TRUE, &cache);
1046       if (!client) {
1047         silc_free(client_id);
1048         goto out;
1049       }
1050     }
1051     silc_free(client_id);
1052
1053     /* Get user's channel entry and check that inviting is allowed. */
1054     if (!silc_server_client_on_channel(client, channel, &chl))
1055       goto out;
1056     if (channel->mode & SILC_CHANNEL_MODE_INVITE &&
1057         !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1058         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1059       SILC_LOG_DEBUG(("Inviting is not allowed"));
1060       goto out;
1061     }
1062
1063     /* Get the added invite */
1064     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1065     if (tmp) {
1066       if (!channel->invite_list)
1067         channel->invite_list = silc_calloc(tmp_len + 2,
1068                                            sizeof(*channel->invite_list));
1069       else
1070         channel->invite_list = silc_realloc(channel->invite_list,
1071                                             sizeof(*channel->invite_list) *
1072                                             (tmp_len +
1073                                              strlen(channel->invite_list) +
1074                                              2));
1075       if (tmp[tmp_len - 1] == ',')
1076         tmp[tmp_len - 1] = '\0';
1077
1078       strncat(channel->invite_list, tmp, tmp_len);
1079       strncat(channel->invite_list, ",", 1);
1080     }
1081
1082     /* Get the deleted invite */
1083     tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1084     if (tmp && channel->invite_list) {
1085       char *start, *end, *n;
1086
1087       if (!strncmp(channel->invite_list, tmp,
1088                    strlen(channel->invite_list) - 1)) {
1089         silc_free(channel->invite_list);
1090         channel->invite_list = NULL;
1091       } else {
1092         start = strstr(channel->invite_list, tmp);
1093         if (start && strlen(start) >= tmp_len) {
1094           end = start + tmp_len;
1095           n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
1096           strncat(n, channel->invite_list, start - channel->invite_list);
1097           strncat(n, end + 1, ((channel->invite_list +
1098                                 strlen(channel->invite_list)) - end) - 1);
1099           silc_free(channel->invite_list);
1100           channel->invite_list = n;
1101         }
1102       }
1103     }
1104
1105     break;
1106
1107   case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1108     /*
1109      * Distribute to the local clients on the channel and change the
1110      * channel ID.
1111      */
1112
1113     SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1114
1115     if (sock->type != SILC_SOCKET_TYPE_ROUTER)
1116       break;
1117
1118     /* Get the old Channel ID */
1119     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1120     if (!tmp)
1121       goto out;
1122     channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1123     if (!channel_id)
1124       goto out;
1125
1126     /* Get the channel entry */
1127     channel = silc_idlist_find_channel_by_id(server->local_list,
1128                                              channel_id, NULL);
1129     if (!channel) {
1130       channel = silc_idlist_find_channel_by_id(server->global_list,
1131                                                channel_id, NULL);
1132       if (!channel) {
1133         SILC_LOG_DEBUG(("Notify for unknown channel"));
1134         silc_free(channel_id);
1135         goto out;
1136       }
1137     }
1138
1139     /* Send the notify to the channel */
1140     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1141                                        FALSE, packet->buffer->data,
1142                                        packet->buffer->len, FALSE);
1143
1144     /* Get the new Channel ID */
1145     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1146     if (!tmp)
1147       goto out;
1148     channel_id2 = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1149     if (!channel_id2)
1150       goto out;
1151
1152     SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1153                     silc_id_render(channel_id, SILC_ID_CHANNEL)));
1154     SILC_LOG_DEBUG(("New Channel ID id(%s)",
1155                     silc_id_render(channel_id2, SILC_ID_CHANNEL)));
1156
1157     /* Replace the Channel ID */
1158     if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
1159                                         channel_id2))
1160       if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
1161                                           channel_id2)) {
1162         silc_free(channel_id2);
1163         channel_id2 = NULL;
1164       }
1165
1166     if (channel_id2) {
1167       SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1168
1169       /* Re-announce this channel which ID was changed. */
1170       silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1171                                    channel->id,
1172                                    silc_id_get_len(channel->id,
1173                                                    SILC_ID_CHANNEL),
1174                                    channel->mode);
1175
1176       /* Re-announce our clients on the channel as the ID has changed now */
1177       silc_server_announce_get_channel_users(server, channel, &modes, &users,
1178                                              &users_modes);
1179       if (users) {
1180         silc_buffer_push(users, users->data - users->head);
1181         silc_server_packet_send(server, sock,
1182                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1183                                 users->data, users->len, FALSE);
1184         silc_buffer_free(users);
1185       }
1186       if (modes) {
1187         silc_buffer_push(modes, modes->data - modes->head);
1188         silc_server_packet_send_dest(server, sock,
1189                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1190                                      channel->id, SILC_ID_CHANNEL,
1191                                      modes->data, modes->len, FALSE);
1192         silc_buffer_free(modes);
1193       }
1194       if (users_modes) {
1195         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1196         silc_server_packet_send_dest(server, sock,
1197                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1198                                      channel->id, SILC_ID_CHANNEL,
1199                                      users_modes->data,
1200                                      users_modes->len, FALSE);
1201         silc_buffer_free(users_modes);
1202       }
1203
1204       /* Re-announce channel's topic */
1205       if (channel->topic) {
1206         silc_server_send_notify_topic_set(server, sock,
1207                                           server->server_type == SILC_ROUTER ?
1208                                           TRUE : FALSE, channel,
1209                                           server->id, SILC_ID_SERVER,
1210                                           channel->topic);
1211       }
1212     }
1213
1214     silc_free(channel_id);
1215
1216     break;
1217
1218   case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1219     /*
1220      * Remove the server entry and all clients that this server owns.
1221      */
1222
1223     SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1224
1225     /* Get Server ID */
1226     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1227     if (!tmp)
1228       goto out;
1229     server_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1230     if (!server_id)
1231       goto out;
1232
1233     /* If the ID is mine, this notify is not allowed. */
1234     if (SILC_ID_SERVER_COMPARE(server_id, server->id)) {
1235       SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1236       break;
1237     }
1238
1239     /* Get server entry */
1240     server_entry = silc_idlist_find_server_by_id(server->global_list,
1241                                                  server_id, TRUE, NULL);
1242     local = FALSE;
1243     if (!server_entry) {
1244       server_entry = silc_idlist_find_server_by_id(server->local_list,
1245                                                    server_id, TRUE, NULL);
1246       local = TRUE;
1247       if (!server_entry) {
1248         /* If we are normal server then we might not have the server. Check
1249            whether router was kind enough to send the list of all clients
1250            that actually was to be removed. Remove them if the list is
1251            available. */
1252         if (server->server_type != SILC_ROUTER &&
1253             silc_argument_get_arg_num(args) > 1) {
1254           int i;
1255
1256           for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1257             /* Get Client ID */
1258             tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
1259             if (!tmp)
1260               continue;
1261             client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1262             if (!client_id)
1263               continue;
1264
1265             /* Get client entry */
1266             client = silc_idlist_find_client_by_id(server->global_list,
1267                                                    client_id, TRUE, &cache);
1268             local = TRUE;
1269             if (!client) {
1270               client = silc_idlist_find_client_by_id(server->local_list,
1271                                                      client_id, TRUE, &cache);
1272               local = FALSE;
1273               if (!client) {
1274                 silc_free(client_id);
1275                 continue;
1276               }
1277             }
1278             silc_free(client_id);
1279
1280             /* Update statistics */
1281             server->stat.clients--;
1282             if (server->stat.cell_clients)
1283               server->stat.cell_clients--;
1284             SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1285             SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1286
1287             /* Remove the client from all channels. */
1288             silc_server_remove_from_channels(server, NULL, client,
1289                                              TRUE, NULL, FALSE);
1290
1291             /* Check if anyone is watching this nickname */
1292             if (server->server_type == SILC_ROUTER)
1293               silc_server_check_watcher_list(server, client, NULL,
1294                                              SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1295
1296             /* Remove this client from watcher list if it is */
1297             if (local)
1298               silc_server_del_from_watcher_list(server, client);
1299
1300             /* Remove the client */
1301             silc_idlist_del_data(client);
1302             silc_idlist_del_client(local ? server->local_list :
1303                                    server->global_list, client);
1304           }
1305         }
1306
1307         silc_free(server_id);
1308         goto out;
1309       }
1310     }
1311     silc_free(server_id);
1312
1313     /* Sending SERVER_SIGNOFF is not right way to signoff local connection */
1314     if (SILC_IS_LOCAL(server_entry))
1315       break;
1316
1317     /* Remove all servers that are originated from this server, and
1318        remove the clients of those servers too. */
1319     silc_server_remove_servers_by_server(server, server_entry, TRUE);
1320
1321     /* Remove the clients that this server owns as they will become
1322        invalid now too. */
1323     silc_server_remove_clients_by_server(server, server_entry->router,
1324                                          server_entry, TRUE);
1325     silc_server_backup_del(server, server_entry);
1326
1327     /* Remove the server entry */
1328     silc_idlist_del_server(local ? server->local_list :
1329                            server->global_list, server_entry);
1330
1331     /* Update statistics */
1332     if (server->server_type == SILC_ROUTER)
1333       server->stat.servers--;
1334
1335     break;
1336
1337   case SILC_NOTIFY_TYPE_KICKED:
1338     /*
1339      * Distribute the notify to local clients on the channel
1340      */
1341
1342     SILC_LOG_DEBUG(("KICKED notify"));
1343
1344     if (!channel_id) {
1345       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
1346                                   packet->dst_id_type);
1347       if (!channel_id)
1348         goto out;
1349     }
1350
1351     /* Get channel entry */
1352     channel = silc_idlist_find_channel_by_id(server->global_list,
1353                                              channel_id, NULL);
1354     if (!channel) {
1355       channel = silc_idlist_find_channel_by_id(server->local_list,
1356                                                channel_id, NULL);
1357       if (!channel) {
1358         SILC_LOG_DEBUG(("Notify for unknown channel"));
1359         silc_free(channel_id);
1360         goto out;
1361       }
1362     }
1363     silc_free(channel_id);
1364
1365     /* Get client ID */
1366     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1367     if (!tmp)
1368       goto out;
1369     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1370     if (!client_id)
1371       goto out;
1372
1373     /* If the the client is not in local list we check global list */
1374     client = silc_idlist_find_client_by_id(server->global_list,
1375                                            client_id, TRUE, NULL);
1376     if (!client) {
1377       client = silc_idlist_find_client_by_id(server->local_list,
1378                                              client_id, TRUE, NULL);
1379       if (!client) {
1380         silc_free(client_id);
1381         goto out;
1382       }
1383     }
1384     silc_free(client_id);
1385
1386     /* If target is founder they cannot be kicked */
1387     if (!silc_server_client_on_channel(client, channel, &chl))
1388       goto out;
1389     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1390       goto out;
1391
1392     /* From protocol version 1.1 we get the kicker's ID as well. */
1393     tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1394     if (tmp) {
1395       client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1396       if (!client_id)
1397         goto out;
1398
1399       /* If the the client is not in local list we check global list */
1400       client2 = silc_idlist_find_client_by_id(server->global_list,
1401                                               client_id, TRUE, NULL);
1402       if (!client2) {
1403         client2 = silc_idlist_find_client_by_id(server->local_list,
1404                                                 client_id, TRUE, NULL);
1405         if (!client2) {
1406           silc_free(client_id);
1407           goto out;
1408         }
1409       }
1410       silc_free(client_id);
1411
1412       /* Kicker must be operator on channel */
1413       if (!silc_server_client_on_channel(client2, channel, &chl))
1414         goto out;
1415       if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1416           !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1417         SILC_LOG_DEBUG(("Kicking is not allowed"));
1418         goto out;
1419       }
1420     }
1421
1422     /* Send to channel */
1423     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1424                                        FALSE, packet->buffer->data,
1425                                        packet->buffer->len, FALSE);
1426
1427     /* Remove the client from channel */
1428     silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1429
1430     break;
1431
1432   case SILC_NOTIFY_TYPE_KILLED:
1433     {
1434       /*
1435        * Distribute the notify to local clients on channels
1436        */
1437       unsigned char *id, *comment;
1438       SilcUInt32 id_len, comment_len;
1439
1440       SILC_LOG_DEBUG(("KILLED notify"));
1441
1442       /* Get client ID */
1443       id = silc_argument_get_arg_type(args, 1, &id_len);
1444       if (!id)
1445         goto out;
1446       client_id = silc_id_payload_parse_id(id, id_len, NULL);
1447       if (!client_id)
1448         goto out;
1449
1450       /* If the the client is not in local list we check global list */
1451       client = silc_idlist_find_client_by_id(server->global_list,
1452                                              client_id, TRUE, &cache);
1453       if (!client) {
1454         client = silc_idlist_find_client_by_id(server->local_list,
1455                                                client_id, TRUE, &cache);
1456         if (!client) {
1457           silc_free(client_id);
1458           goto out;
1459         }
1460       }
1461       silc_free(client_id);
1462
1463       /* If the client is one of ours, then close the connection to the
1464          client now. This removes the client from all channels as well. */
1465       if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1466         sock = client->connection;
1467         silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1468         silc_server_close_connection(server, sock);
1469         break;
1470       }
1471
1472       /* Get comment */
1473       comment = silc_argument_get_arg_type(args, 2, &comment_len);
1474       if (comment_len > 128)
1475         comment_len = 127;
1476
1477       /* From protocol version 1.1 we get the killer's ID as well. */
1478       tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1479       if (tmp) {
1480         client_id = silc_id_payload_parse_id(tmp, tmp_len, &id_type);
1481         if (!client_id)
1482           goto out;
1483
1484         if (id_type == SILC_ID_CLIENT) {
1485           /* If the the client is not in local list we check global list */
1486           client2 = silc_idlist_find_client_by_id(server->global_list,
1487                                                   client_id, TRUE, NULL);
1488           if (!client2) {
1489             client2 = silc_idlist_find_client_by_id(server->local_list,
1490                                                     client_id, TRUE, NULL);
1491             if (!client2) {
1492               silc_free(client_id);
1493               goto out;
1494             }
1495           }
1496           silc_free(client_id);
1497
1498           /* Killer must be router operator */
1499           if (server->server_type != SILC_SERVER &&
1500               !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1501             SILC_LOG_DEBUG(("Killing is not allowed"));
1502             goto out;
1503           }
1504         }
1505       }
1506
1507       /* Send the notify to local clients on the channels except to the
1508          client who is killed. */
1509       silc_server_send_notify_on_channels(server, client, client,
1510                                           SILC_NOTIFY_TYPE_KILLED, 3,
1511                                           id, id_len, comment, comment_len,
1512                                           tmp, tmp_len);
1513
1514       /* Remove the client from all channels */
1515       silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1516                                        FALSE);
1517
1518       /* Check if anyone is watching this nickname */
1519       silc_server_check_watcher_list(server, client, NULL,
1520                                      SILC_NOTIFY_TYPE_KILLED);
1521
1522       /* Update statistics */
1523       server->stat.clients--;
1524       if (server->stat.cell_clients)
1525         server->stat.cell_clients--;
1526       SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1527       SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1528
1529       if (SILC_IS_LOCAL(client)) {
1530         server->stat.my_clients--;
1531         silc_schedule_task_del_by_context(server->schedule, client);
1532         silc_idlist_del_data(client);
1533         client->mode = 0;
1534       }
1535
1536       client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1537       cache->expire = SILC_ID_CACHE_EXPIRE_DEF;
1538       break;
1539     }
1540
1541   case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1542     /*
1543      * Save the mode of the client.
1544      */
1545
1546     SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1547
1548     /* Get client ID */
1549     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1550     if (!tmp)
1551       goto out;
1552     client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1553     if (!client_id)
1554       goto out;
1555
1556     /* Get client entry */
1557     client = silc_idlist_find_client_by_id(server->global_list,
1558                                            client_id, TRUE, NULL);
1559     if (!client) {
1560       client = silc_idlist_find_client_by_id(server->local_list,
1561                                              client_id, TRUE, NULL);
1562       if (!client) {
1563         silc_free(client_id);
1564         goto out;
1565       }
1566     }
1567     silc_free(client_id);
1568
1569     /* Get the mode */
1570     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1571     if (!tmp)
1572       goto out;
1573     SILC_GET32_MSB(mode, tmp);
1574
1575     /* Remove internal resumed flag if client is marked detached now */
1576     if (mode & SILC_UMODE_DETACHED)
1577       client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1578
1579     /* Update statistics */
1580     if (server->server_type == SILC_ROUTER) {
1581       if (mode & SILC_UMODE_GONE) {
1582         if (!(client->mode & SILC_UMODE_GONE))
1583           server->stat.aways++;
1584       } else {
1585         if (client->mode & SILC_UMODE_GONE)
1586           server->stat.aways--;
1587       }
1588       if (mode & SILC_UMODE_DETACHED) {
1589         if (!(client->mode & SILC_UMODE_DETACHED))
1590           server->stat.detached++;
1591       } else {
1592         if (client->mode & SILC_UMODE_DETACHED)
1593           server->stat.detached--;
1594       }
1595     }
1596     SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1597     SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1598
1599     /* Change the mode */
1600     client->mode = mode;
1601
1602     /* Check if anyone is watching this nickname */
1603     if (server->server_type == SILC_ROUTER)
1604       silc_server_check_watcher_list(server, client, NULL,
1605                                      SILC_NOTIFY_TYPE_UMODE_CHANGE);
1606
1607     break;
1608
1609   case SILC_NOTIFY_TYPE_BAN:
1610     /*
1611      * Save the ban
1612      */
1613
1614     SILC_LOG_DEBUG(("BAN notify"));
1615
1616     /* Get Channel ID */
1617     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1618     if (!tmp)
1619       goto out;
1620     channel_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1621     if (!channel_id)
1622       goto out;
1623
1624     /* Get channel entry */
1625     channel = silc_idlist_find_channel_by_id(server->global_list,
1626                                              channel_id, NULL);
1627     if (!channel) {
1628       channel = silc_idlist_find_channel_by_id(server->local_list,
1629                                                channel_id, NULL);
1630       if (!channel) {
1631         SILC_LOG_DEBUG(("Notify for unknown channel"));
1632         silc_free(channel_id);
1633         goto out;
1634       }
1635     }
1636     silc_free(channel_id);
1637
1638     /* Get the new ban and add it to the ban list */
1639     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1640     if (tmp) {
1641       if (!channel->ban_list)
1642         channel->ban_list = silc_calloc(tmp_len + 2,
1643                                         sizeof(*channel->ban_list));
1644       else
1645         channel->ban_list = silc_realloc(channel->ban_list,
1646                                          sizeof(*channel->ban_list) *
1647                                          (tmp_len +
1648                                           strlen(channel->ban_list) + 2));
1649       strncat(channel->ban_list, tmp, tmp_len);
1650       strncat(channel->ban_list, ",", 1);
1651     }
1652
1653     /* Get the ban to be removed and remove it from the list */
1654     tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1655     if (tmp && channel->ban_list) {
1656       char *start, *end, *n;
1657
1658       if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
1659         silc_free(channel->ban_list);
1660         channel->ban_list = NULL;
1661       } else {
1662         start = strstr(channel->ban_list, tmp);
1663         if (start && strlen(start) >= tmp_len) {
1664           end = start + tmp_len;
1665           n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1666           strncat(n, channel->ban_list, start - channel->ban_list);
1667           strncat(n, end + 1, ((channel->ban_list +
1668                                 strlen(channel->ban_list)) - end) - 1);
1669           silc_free(channel->ban_list);
1670           channel->ban_list = n;
1671         }
1672       }
1673     }
1674     break;
1675
1676   case SILC_NOTIFY_TYPE_ERROR:
1677     {
1678       /*
1679        * Error notify
1680        */
1681       SilcStatus error;
1682
1683       tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1684       if (!tmp && tmp_len != 1)
1685         goto out;
1686       error = (SilcStatus)tmp[0];
1687
1688       SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1689
1690       if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1691           sock->type == SILC_SOCKET_TYPE_ROUTER) {
1692         tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1693         if (tmp) {
1694           SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1695                           "the entry from cache"));
1696           client_id = silc_id_payload_parse_id(tmp, tmp_len, NULL);
1697           if (!client_id)
1698             goto out;
1699           client = silc_idlist_find_client_by_id(server->global_list,
1700                                                  client_id, FALSE, NULL);
1701           if (client) {
1702             silc_server_remove_from_channels(server, NULL, client, TRUE,
1703                                              NULL, TRUE);
1704             silc_idlist_del_data(client);
1705             silc_idlist_del_client(server->global_list, client);
1706           }
1707           silc_free(client_id);
1708         }
1709       }
1710     }
1711     break;
1712
1713     /* Ignore rest of the notify types for now */
1714   case SILC_NOTIFY_TYPE_NONE:
1715   case SILC_NOTIFY_TYPE_MOTD:
1716     break;
1717   default:
1718     break;
1719   }
1720
1721  out:
1722   silc_notify_payload_free(payload);
1723 }
1724
1725 void silc_server_notify_list(SilcServer server,
1726                              SilcSocketConnection sock,
1727                              SilcPacketContext *packet)
1728 {
1729   SilcPacketContext *new;
1730   SilcBuffer buffer;
1731   SilcUInt16 len;
1732
1733   SILC_LOG_DEBUG(("Processing Notify List"));
1734
1735   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1736       packet->src_id_type != SILC_ID_SERVER)
1737     return;
1738
1739   /* Make copy of the original packet context, except for the actual
1740      data buffer, which we will here now fetch from the original buffer. */
1741   new = silc_packet_context_alloc();
1742   new->type = SILC_PACKET_NOTIFY;
1743   new->flags = packet->flags;
1744   new->src_id = packet->src_id;
1745   new->src_id_len = packet->src_id_len;
1746   new->src_id_type = packet->src_id_type;
1747   new->dst_id = packet->dst_id;
1748   new->dst_id_len = packet->dst_id_len;
1749   new->dst_id_type = packet->dst_id_type;
1750
1751   buffer = silc_buffer_alloc(1024);
1752   new->buffer = buffer;
1753
1754   while (packet->buffer->len) {
1755     SILC_GET16_MSB(len, packet->buffer->data + 2);
1756     if (len > packet->buffer->len)
1757       break;
1758
1759     if (len > buffer->truelen) {
1760       silc_buffer_free(buffer);
1761       buffer = silc_buffer_alloc(1024 + len);
1762     }
1763
1764     silc_buffer_pull_tail(buffer, len);
1765     silc_buffer_put(buffer, packet->buffer->data, len);
1766
1767     /* Process the Notify */
1768     silc_server_notify(server, sock, new);
1769
1770     silc_buffer_push_tail(buffer, len);
1771     silc_buffer_pull(packet->buffer, len);
1772   }
1773
1774   silc_buffer_free(buffer);
1775   silc_free(new);
1776 }
1777
1778 /* Received private message. This resolves the destination of the message
1779    and sends the packet. This is used by both server and router.  If the
1780    destination is our locally connected client this sends the packet to
1781    the client. This may also send the message for further routing if
1782    the destination is not in our server (or router). */
1783
1784 void silc_server_private_message(SilcServer server,
1785                                  SilcSocketConnection sock,
1786                                  SilcPacketContext *packet)
1787 {
1788   SilcSocketConnection dst_sock;
1789   SilcIDListData idata;
1790   SilcClientEntry client;
1791
1792   SILC_LOG_DEBUG(("Start"));
1793
1794   if (packet->src_id_type != SILC_ID_CLIENT ||
1795       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1796     return;
1797
1798   /* Get the route to the client */
1799   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1800                                           packet->dst_id_len, NULL,
1801                                           &idata, &client);
1802   if (!dst_sock) {
1803     SilcBuffer idp;
1804     unsigned char error;
1805
1806     if (client && client->mode & SILC_UMODE_DETACHED) {
1807       SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1808       return;
1809     }
1810
1811     /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1812        does not exist or is invalid. */
1813     idp = silc_id_payload_encode_data(packet->dst_id,
1814                                       packet->dst_id_len,
1815                                       packet->dst_id_type);
1816     if (!idp)
1817       return;
1818
1819     error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1820     if (packet->src_id_type == SILC_ID_CLIENT) {
1821       SilcClientID *client_id = silc_id_str2id(packet->src_id,
1822                                                packet->src_id_len,
1823                                                packet->src_id_type);
1824       silc_server_send_notify_dest(server, sock, FALSE,
1825                                    client_id, SILC_ID_CLIENT,
1826                                    SILC_NOTIFY_TYPE_ERROR, 2,
1827                                    &error, 1,
1828                                    idp->data, idp->len);
1829       silc_free(client_id);
1830     } else {
1831       silc_server_send_notify(server, sock, FALSE,
1832                               SILC_NOTIFY_TYPE_ERROR, 2,
1833                               &error, 1,
1834                               idp->data, idp->len);
1835     }
1836
1837     silc_buffer_free(idp);
1838     return;
1839   }
1840
1841   /* Check whether destination client wishes to receive private messages */
1842   if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1843       client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1844     SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1845     return;
1846   }
1847
1848   /* Send the private message */
1849   silc_server_send_private_message(server, dst_sock, idata->send_key,
1850                                    idata->hmac_send, idata->psn_send++,
1851                                    packet);
1852 }
1853
1854 /* Received private message key packet.. This packet is never for us. It is to
1855    the client in the packet's destination ID. Sending of this sort of packet
1856    equals sending private message, ie. it is sent point to point from
1857    one client to another. */
1858
1859 void silc_server_private_message_key(SilcServer server,
1860                                      SilcSocketConnection sock,
1861                                      SilcPacketContext *packet)
1862 {
1863   SilcSocketConnection dst_sock;
1864   SilcIDListData idata;
1865
1866   SILC_LOG_DEBUG(("Start"));
1867
1868   if (packet->src_id_type != SILC_ID_CLIENT ||
1869       packet->dst_id_type != SILC_ID_CLIENT)
1870     return;
1871
1872   if (!packet->dst_id)
1873     return;
1874
1875   /* Get the route to the client */
1876   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1877                                           packet->dst_id_len, NULL,
1878                                           &idata, NULL);
1879   if (!dst_sock)
1880     return;
1881
1882   /* Relay the packet */
1883   silc_server_relay_packet(server, dst_sock, idata->send_key,
1884                            idata->hmac_send, idata->psn_send++, packet, FALSE);
1885 }
1886
1887 /* Processes incoming command reply packet. The command reply packet may
1888    be destined to one of our clients or it may directly for us. We will
1889    call the command reply routine after processing the packet. */
1890
1891 void silc_server_command_reply(SilcServer server,
1892                                SilcSocketConnection sock,
1893                                SilcPacketContext *packet)
1894 {
1895   SilcBuffer buffer = packet->buffer;
1896   SilcClientEntry client = NULL;
1897   SilcSocketConnection dst_sock;
1898   SilcIDListData idata;
1899   SilcClientID *id = NULL;
1900
1901   SILC_LOG_DEBUG(("Start"));
1902
1903   if (packet->dst_id_type == SILC_ID_CHANNEL)
1904     return;
1905
1906   if (packet->dst_id_type == SILC_ID_CLIENT) {
1907     /* Destination must be one of ours */
1908     id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1909     if (!id)
1910       return;
1911     client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1912     if (!client) {
1913       SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1914       silc_free(id);
1915       return;
1916     }
1917   }
1918
1919   if (packet->dst_id_type == SILC_ID_SERVER) {
1920     /* For now this must be for us */
1921     if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1922       SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1923       return;
1924     }
1925   }
1926
1927   /* Execute command reply locally for the command */
1928   silc_server_command_reply_process(server, sock, buffer);
1929
1930   if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1931     /* Relay the packet to the client */
1932     const SilcBufferStruct p;
1933
1934     dst_sock = (SilcSocketConnection)client->connection;
1935     idata = (SilcIDListData)client;
1936
1937     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1938                      + packet->dst_id_len + packet->padlen);
1939     if (!silc_packet_send_prepare(dst_sock, 0, 0, buffer->len,
1940                                   idata->hmac_send, (const SilcBuffer)&p)) {
1941       SILC_LOG_ERROR(("Cannot send packet"));
1942       return;
1943     }
1944     silc_buffer_put((SilcBuffer)&p, buffer->data, buffer->len);
1945
1946     /* Encrypt packet */
1947     silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1948                         (SilcBuffer)&p, buffer->len);
1949
1950     /* Send the packet */
1951     silc_server_packet_send_real(server, dst_sock, TRUE);
1952
1953     silc_free(id);
1954   }
1955 }
1956
1957 /* Process received channel message. The message can be originated from
1958    client or server. */
1959
1960 void silc_server_channel_message(SilcServer server,
1961                                  SilcSocketConnection sock,
1962                                  SilcPacketContext *packet)
1963 {
1964   SilcChannelEntry channel = NULL;
1965   SilcChannelID *id = NULL;
1966   void *sender_id = NULL;
1967   SilcClientEntry sender_entry = NULL;
1968   SilcChannelClientEntry chl;
1969   bool local = TRUE;
1970
1971   SILC_LOG_DEBUG(("Processing channel message"));
1972
1973   /* Sanity checks */
1974   if (packet->dst_id_type != SILC_ID_CHANNEL) {
1975     SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1976     goto out;
1977   }
1978
1979   /* Find channel entry */
1980   id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1981   if (!id)
1982     goto out;
1983   channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1984   if (!channel) {
1985     channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1986     if (!channel) {
1987       SilcBuffer idp;
1988       unsigned char error;
1989
1990       /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1991          does not exist or is invalid. */
1992       idp = silc_id_payload_encode_data(packet->dst_id,
1993                                         packet->dst_id_len,
1994                                         packet->dst_id_type);
1995       if (!idp)
1996         goto out;
1997
1998       error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1999       if (packet->src_id_type == SILC_ID_CLIENT) {
2000         SilcClientID *client_id = silc_id_str2id(packet->src_id,
2001                                                  packet->src_id_len,
2002                                                  packet->src_id_type);
2003         silc_server_send_notify_dest(server, sock, FALSE,
2004                                      client_id, SILC_ID_CLIENT,
2005                                      SILC_NOTIFY_TYPE_ERROR, 2,
2006                                      &error, 1, idp->data, idp->len);
2007         silc_free(client_id);
2008       } else {
2009         silc_server_send_notify(server, sock, FALSE,
2010                                 SILC_NOTIFY_TYPE_ERROR, 2,
2011                                 &error, 1, idp->data, idp->len);
2012       }
2013
2014       silc_buffer_free(idp);
2015       goto out;
2016     }
2017   }
2018
2019   /* See that this client is on the channel. If the original sender is
2020      not client (as it can be server as well) we don't do the check. */
2021   sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2022                              packet->src_id_type);
2023   if (!sender_id)
2024     goto out;
2025   if (packet->src_id_type == SILC_ID_CLIENT) {
2026     sender_entry = silc_idlist_find_client_by_id(server->local_list,
2027                                                  sender_id, TRUE, NULL);
2028     if (!sender_entry) {
2029       local = FALSE;
2030       sender_entry = silc_idlist_find_client_by_id(server->global_list,
2031                                                    sender_id, TRUE, NULL);
2032     }
2033     if (!sender_entry || !silc_server_client_on_channel(sender_entry,
2034                                                         channel, &chl)) {
2035       SILC_LOG_DEBUG(("Client not on channel"));
2036       goto out;
2037     }
2038
2039     /* If channel is moderated check that client is allowed to send
2040        messages. */
2041     if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
2042         !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2043         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2044       SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2045       goto out;
2046     }
2047     if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2048         chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2049         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2050       SILC_LOG_DEBUG(("Channel is silenced from operators"));
2051       goto out;
2052     }
2053     if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2054       SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2055       goto out;
2056     }
2057
2058     /* If the packet is coming from router, but the client entry is local
2059        entry to us then some router is rerouting this to us and it is not
2060        allowed. When the client is local to us it means that we've routed
2061        this packet to network, and now someone is routing it back to us. */
2062     if (server->server_type == SILC_ROUTER &&
2063         sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
2064       SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2065       goto out;
2066     }
2067   }
2068
2069   /* Distribute the packet to our local clients. This will send the
2070      packet for further routing as well, if needed. */
2071   silc_server_packet_relay_to_channel(server, sock, channel, sender_id,
2072                                       packet->src_id_type, sender_entry,
2073                                       packet->buffer->data,
2074                                       packet->buffer->len, FALSE);
2075
2076  out:
2077   silc_free(sender_id);
2078   silc_free(id);
2079 }
2080
2081 /* Received channel key packet. We distribute the key to all of our locally
2082    connected clients on the channel. */
2083
2084 void silc_server_channel_key(SilcServer server,
2085                              SilcSocketConnection sock,
2086                              SilcPacketContext *packet)
2087 {
2088   SilcBuffer buffer = packet->buffer;
2089   SilcChannelEntry channel;
2090
2091   if (packet->src_id_type != SILC_ID_SERVER ||
2092       (server->server_type == SILC_ROUTER &&
2093        sock->type == SILC_SOCKET_TYPE_ROUTER))
2094     return;
2095
2096   /* Save the channel key */
2097   channel = silc_server_save_channel_key(server, buffer, NULL);
2098   if (!channel)
2099     return;
2100
2101   /* Distribute the key to everybody who is on the channel. If we are router
2102      we will also send it to locally connected servers. */
2103   silc_server_send_channel_key(server, sock, channel, FALSE);
2104
2105   if (server->server_type != SILC_BACKUP_ROUTER) {
2106     /* Distribute to local cell backup routers. */
2107     silc_server_backup_send(server, sock->user_data,
2108                             SILC_PACKET_CHANNEL_KEY, 0,
2109                             buffer->data, buffer->len, FALSE, TRUE);
2110   }
2111 }
2112
2113 /* Received New Client packet and processes it.  Creates Client ID for the
2114    client. Client becomes registered after calling this functions. */
2115
2116 SilcClientEntry silc_server_new_client(SilcServer server,
2117                                        SilcSocketConnection sock,
2118                                        SilcPacketContext *packet)
2119 {
2120   SilcBuffer buffer = packet->buffer;
2121   SilcClientEntry client;
2122   SilcClientID *client_id;
2123   SilcIDListData idata;
2124   char *username = NULL, *realname = NULL;
2125   SilcUInt16 username_len;
2126   SilcUInt32 id_len;
2127   int ret;
2128   char *hostname, *nickname;
2129   int nickfail = 0;
2130
2131   SILC_LOG_DEBUG(("Creating new client"));
2132
2133   if (sock->type != SILC_SOCKET_TYPE_CLIENT)
2134     return NULL;
2135
2136   /* Take client entry */
2137   client = (SilcClientEntry)sock->user_data;
2138   idata = (SilcIDListData)client;
2139
2140   /* Remove the old cache entry. */
2141   if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
2142     SILC_LOG_INFO(("Unauthenticated client attempted to register to network"));
2143     silc_server_disconnect_remote(server, sock,
2144                                   SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2145     if (sock->user_data)
2146       silc_server_free_sock_user_data(server, sock, NULL);
2147     return NULL;
2148   }
2149
2150   /* Parse incoming packet */
2151   ret = silc_buffer_unformat(buffer,
2152                              SILC_STR_UI16_NSTRING_ALLOC(&username,
2153                                                          &username_len),
2154                              SILC_STR_UI16_STRING_ALLOC(&realname),
2155                              SILC_STR_END);
2156   if (ret == -1) {
2157     silc_free(username);
2158     silc_free(realname);
2159     SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2160                     "connection", sock->hostname, sock->ip));
2161     silc_server_disconnect_remote(server, sock,
2162                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2163                                   NULL);
2164     if (sock->user_data)
2165       silc_server_free_sock_user_data(server, sock, NULL);
2166     return NULL;
2167   }
2168
2169   if (!username) {
2170     silc_free(username);
2171     silc_free(realname);
2172     SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2173                     "connection", sock->hostname, sock->ip));
2174     silc_server_disconnect_remote(server, sock,
2175                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2176                                   NULL);
2177     if (sock->user_data)
2178       silc_server_free_sock_user_data(server, sock, NULL);
2179     return NULL;
2180   }
2181
2182   if (username_len > 128)
2183     username[128] = '\0';
2184
2185   /* Check for bad characters for nickname, and modify the nickname if
2186      it includes those. */
2187   if (silc_server_name_bad_chars(username, username_len)) {
2188     nickname = silc_server_name_modify_bad(username, username_len);
2189   } else {
2190     nickname = strdup(username);
2191   }
2192
2193   /* Make sanity checks for the hostname of the client. If the hostname
2194      is provided in the `username' check that it is the same than the
2195      resolved hostname, or if not resolved the hostname that appears in
2196      the client's public key. If the hostname is not present then put
2197      it from the resolved name or from the public key. */
2198   if (strchr(username, '@')) {
2199     SilcPublicKeyIdentifier pident;
2200     int tlen = strcspn(username, "@");
2201     char *phostname = NULL;
2202
2203     hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2204
2205     if (strcmp(sock->hostname, sock->ip) &&
2206         strcmp(sock->hostname, hostname)) {
2207       silc_free(username);
2208       silc_free(hostname);
2209       silc_free(realname);
2210       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2211                       "connection", sock->hostname, sock->ip));
2212       silc_server_disconnect_remote(server, sock,
2213                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2214                                     NULL);
2215       if (sock->user_data)
2216         silc_server_free_sock_user_data(server, sock, NULL);
2217       return NULL;
2218     }
2219
2220     pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
2221     if (pident) {
2222       phostname = strdup(pident->host);
2223       silc_pkcs_free_identifier(pident);
2224     }
2225
2226     if (!strcmp(sock->hostname, sock->ip) &&
2227         phostname && strcmp(phostname, hostname)) {
2228       silc_free(username);
2229       silc_free(hostname);
2230       silc_free(phostname);
2231       silc_free(realname);
2232       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2233                       "connection", sock->hostname, sock->ip));
2234       silc_server_disconnect_remote(server, sock,
2235                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2236                                     NULL);
2237       if (sock->user_data)
2238         silc_server_free_sock_user_data(server, sock, NULL);
2239       return NULL;
2240     }
2241
2242     silc_free(phostname);
2243   } else {
2244     /* The hostname is not present, add it. */
2245     char *newusername;
2246     /* XXX For now we cannot take the host name from the public key since
2247        they are not trusted or we cannot verify them as trusted. Just take
2248        what the resolved name or address is. */
2249 #if 0
2250     if (strcmp(sock->hostname, sock->ip)) {
2251 #endif
2252       newusername = silc_calloc(strlen(username) +
2253                                 strlen(sock->hostname) + 2,
2254                                 sizeof(*newusername));
2255       strncat(newusername, username, strlen(username));
2256       strncat(newusername, "@", 1);
2257       strncat(newusername, sock->hostname, strlen(sock->hostname));
2258       silc_free(username);
2259       username = newusername;
2260 #if 0
2261     } else {
2262       SilcPublicKeyIdentifier pident =
2263         silc_pkcs_decode_identifier(client->data.public_key->identifier);
2264
2265       if (pident) {
2266         newusername = silc_calloc(strlen(username) +
2267                                   strlen(pident->host) + 2,
2268                                   sizeof(*newusername));
2269         strncat(newusername, username, strlen(username));
2270         strncat(newusername, "@", 1);
2271         strncat(newusername, pident->host, strlen(pident->host));
2272         silc_free(username);
2273         username = newusername;
2274         silc_pkcs_free_identifier(pident);
2275       }
2276     }
2277 #endif
2278   }
2279
2280   /* Create Client ID */
2281   while (!silc_id_create_client_id(server, server->id, server->rng,
2282                                    server->md5hash, nickname, &client_id)) {
2283     nickfail++;
2284     if (nickfail > 9) {
2285       silc_server_disconnect_remote(server, sock,
2286                                     SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2287       if (sock->user_data)
2288         silc_server_free_sock_user_data(server, sock, NULL);
2289       return NULL;
2290     }
2291     snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
2292   }
2293
2294   /* If client marked as anonymous, scramble the username and hostname */
2295   if (client->mode & SILC_UMODE_ANONYMOUS) {
2296     char *scramble;
2297
2298     if (strlen(username) >= 2) {
2299       username[0] = silc_rng_get_byte_fast(server->rng);
2300       username[1] = silc_rng_get_byte_fast(server->rng);
2301     }
2302
2303     scramble = silc_hash_babbleprint(server->sha1hash, username,
2304                                      strlen(username));
2305     scramble[5] = '@';
2306     scramble[11] = '.';
2307     memcpy(&scramble[16], ".silc", 5);
2308     scramble[21] = '\0';
2309     silc_free(username);
2310     username = scramble;
2311   }
2312
2313   /* Update client entry */
2314   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2315   client->nickname = nickname;
2316   client->username = username;
2317   client->userinfo = realname ? realname : strdup(" ");
2318   client->id = client_id;
2319   id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2320
2321   /* Add the client again to the ID cache */
2322   silc_idcache_add(server->local_list->clients, client->nickname,
2323                    client_id, client, 0, NULL);
2324
2325   /* Notify our router about new client on the SILC network */
2326   silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2327                           SILC_BROADCAST(server), client->id,
2328                           SILC_ID_CLIENT, id_len);
2329
2330   /* Distribute to backup routers */
2331   if (server->server_type == SILC_ROUTER) {
2332     SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2333     silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2334                             idp->data, idp->len, FALSE, TRUE);
2335     silc_buffer_free(idp);
2336   }
2337
2338   /* Send the new client ID to the client. */
2339   silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2340                           silc_id_get_len(client->id, SILC_ID_CLIENT));
2341
2342   /* Send some nice info to the client */
2343   silc_server_send_connect_notifys(server, sock, client);
2344
2345   /* Check if anyone is watching this nickname */
2346   if (server->server_type == SILC_ROUTER)
2347     silc_server_check_watcher_list(server, client, NULL, 0);
2348
2349   return client;
2350 }
2351
2352 /* Create new server. This processes received New Server packet and
2353    saves the received Server ID. The server is our locally connected
2354    server thus we save all the information and save it to local list.
2355    This funtion can be used by both normal server and router server.
2356    If normal server uses this it means that its router has connected
2357    to the server. If router uses this it means that one of the cell's
2358    servers is connected to the router. */
2359
2360 SilcServerEntry silc_server_new_server(SilcServer server,
2361                                        SilcSocketConnection sock,
2362                                        SilcPacketContext *packet)
2363 {
2364   SilcBuffer buffer = packet->buffer;
2365   SilcServerEntry new_server, server_entry;
2366   SilcServerID *server_id;
2367   SilcIDListData idata;
2368   unsigned char *server_name, *id_string;
2369   SilcUInt16 id_len, name_len;
2370   int ret;
2371   bool local = TRUE;
2372
2373   SILC_LOG_DEBUG(("Creating new server"));
2374
2375   if (sock->type != SILC_SOCKET_TYPE_SERVER &&
2376       sock->type != SILC_SOCKET_TYPE_ROUTER)
2377     return NULL;
2378
2379   /* Take server entry */
2380   new_server = (SilcServerEntry)sock->user_data;
2381   idata = (SilcIDListData)new_server;
2382
2383   /* Remove the old cache entry */
2384   if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
2385     if (!silc_idcache_del_by_context(server->global_list->servers,
2386                                      new_server)) {
2387       SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2388                      "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
2389                                  "server" : "router")));
2390       silc_server_disconnect_remote(server, sock,
2391                                     SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2392       if (sock->user_data)
2393         silc_server_free_sock_user_data(server, sock, NULL);
2394       return NULL;
2395     }
2396     local = FALSE;
2397   }
2398
2399   /* Parse the incoming packet */
2400   ret = silc_buffer_unformat(buffer,
2401                              SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2402                              SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2403                                                          &name_len),
2404                              SILC_STR_END);
2405   if (ret == -1) {
2406     silc_free(id_string);
2407     silc_free(server_name);
2408     silc_server_disconnect_remote(server, sock,
2409                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2410                                   NULL);
2411     if (sock->user_data)
2412       silc_server_free_sock_user_data(server, sock, NULL);
2413     return NULL;
2414   }
2415
2416   if (id_len > buffer->len) {
2417     silc_free(id_string);
2418     silc_free(server_name);
2419     silc_server_disconnect_remote(server, sock,
2420                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2421                                   NULL);
2422     if (sock->user_data)
2423       silc_server_free_sock_user_data(server, sock, NULL);
2424     return NULL;
2425   }
2426
2427   if (name_len > 256)
2428     server_name[255] = '\0';
2429
2430   /* Get Server ID */
2431   server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
2432   if (!server_id) {
2433     silc_free(id_string);
2434     silc_free(server_name);
2435     silc_server_disconnect_remote(server, sock,
2436                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2437                                   NULL);
2438     if (sock->user_data)
2439       silc_server_free_sock_user_data(server, sock, NULL);
2440     return NULL;
2441   }
2442   silc_free(id_string);
2443
2444   /* Check for valid server ID */
2445   if (!silc_id_is_valid_server_id(server, server_id, sock)) {
2446     SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2447                    sock->ip, sock->hostname));
2448     silc_server_disconnect_remote(server, sock,
2449                                   SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2450     if (sock->user_data)
2451       silc_server_free_sock_user_data(server, sock, NULL);
2452     silc_free(server_name);
2453     return NULL;
2454   }
2455
2456   /* Check that we do not have this ID already */
2457   server_entry = silc_idlist_find_server_by_id(server->local_list,
2458                                                server_id, TRUE, NULL);
2459   if (server_entry) {
2460     silc_idcache_del_by_context(server->local_list->servers, server_entry);
2461   } else {
2462     server_entry = silc_idlist_find_server_by_id(server->global_list,
2463                                                  server_id, TRUE, NULL);
2464     if (server_entry)
2465       silc_idcache_del_by_context(server->global_list->servers, server_entry);
2466   }
2467
2468   /* Update server entry */
2469   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2470   new_server->server_name = server_name;
2471   new_server->id = server_id;
2472
2473   SILC_LOG_DEBUG(("New server id(%s)",
2474                   silc_id_render(server_id, SILC_ID_SERVER)));
2475
2476   /* Add again the entry to the ID cache. */
2477   silc_idcache_add(local ? server->local_list->servers :
2478                    server->global_list->servers, server_name, server_id,
2479                    new_server, 0, NULL);
2480
2481   /* Distribute the information about new server in the SILC network
2482      to our router. If we are normal server we won't send anything
2483      since this connection must be our router connection. */
2484   if (server->server_type == SILC_ROUTER && !server->standalone &&
2485       SILC_PRIMARY_ROUTE(server) != sock)
2486     silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2487                             TRUE, new_server->id, SILC_ID_SERVER,
2488                             silc_id_get_len(server_id, SILC_ID_SERVER));
2489
2490   if (server->server_type == SILC_ROUTER) {
2491     /* Distribute to backup routers */
2492     SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2493     silc_server_backup_send(server, sock->user_data, SILC_PACKET_NEW_ID, 0,
2494                             idp->data, idp->len, FALSE, TRUE);
2495     silc_buffer_free(idp);
2496
2497     /* Statistics */
2498     server->stat.cell_servers++;
2499   }
2500
2501   /* Check whether this router connection has been replaced by an
2502      backup router. If it has been then we'll disable the server and will
2503      ignore everything it will send until the backup router resuming
2504      protocol has been completed. */
2505   if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2506       silc_server_backup_replaced_get(server, server_id, NULL)) {
2507     /* Send packet to the server indicating that it cannot use this
2508        connection as it has been replaced by backup router. */
2509     SilcBuffer packet = silc_buffer_alloc(2);
2510     silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
2511     silc_buffer_format(packet,
2512                        SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
2513                        SILC_STR_UI_CHAR(0),
2514                        SILC_STR_END);
2515     silc_server_packet_send(server, sock,
2516                             SILC_PACKET_RESUME_ROUTER, 0,
2517                             packet->data, packet->len, TRUE);
2518     silc_buffer_free(packet);
2519
2520     /* Mark the router disabled. The data sent earlier will go but nothing
2521        after this does not go to this connection. */
2522     idata->status |= SILC_IDLIST_STATUS_DISABLED;
2523   } else {
2524     /* If it is router announce our stuff to it. */
2525     if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
2526         server->server_type == SILC_ROUTER) {
2527       silc_server_announce_servers(server, FALSE, 0, sock);
2528       silc_server_announce_clients(server, 0, sock);
2529       silc_server_announce_channels(server, 0, sock);
2530     }
2531
2532     /* Announce our information to backup router */
2533     if (new_server->server_type == SILC_BACKUP_ROUTER &&
2534         sock->type == SILC_SOCKET_TYPE_SERVER &&
2535         server->server_type == SILC_ROUTER) {
2536       silc_server_announce_servers(server, TRUE, 0, sock);
2537       silc_server_announce_clients(server, 0, sock);
2538       silc_server_announce_channels(server, 0, sock);
2539     }
2540
2541     /* If backup router, mark it as one of ours.  This server is considered
2542        to be backup router after this setting. */
2543     if (new_server->server_type == SILC_BACKUP_ROUTER) {
2544       SilcServerConfigRouter *backup;
2545       backup = silc_server_config_find_backup_conn(server, sock->ip);
2546       if (!backup)
2547         backup = silc_server_config_find_backup_conn(server, sock->hostname);
2548       if (backup) {
2549         /* Add as our backup router */
2550         silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2551                                backup->backup_replace_port,
2552                                backup->backup_local);
2553       }
2554     }
2555
2556     /* By default the servers connected to backup router are disabled
2557        until backup router has become the primary */
2558     if (server->server_type == SILC_BACKUP_ROUTER &&
2559         sock->type == SILC_SOCKET_TYPE_SERVER)
2560       idata->status |= SILC_IDLIST_STATUS_DISABLED;
2561   }
2562
2563   return new_server;
2564 }
2565
2566 /* Processes incoming New ID packet. New ID Payload is used to distribute
2567    information about newly registered clients and servers. */
2568
2569 static void silc_server_new_id_real(SilcServer server,
2570                                     SilcSocketConnection sock,
2571                                     SilcPacketContext *packet,
2572                                     int broadcast)
2573 {
2574   SilcBuffer buffer = packet->buffer;
2575   SilcIDList id_list;
2576   SilcServerEntry router, server_entry;
2577   SilcSocketConnection router_sock;
2578   SilcIDPayload idp;
2579   SilcIdType id_type;
2580   void *id;
2581
2582   SILC_LOG_DEBUG(("Processing new ID"));
2583
2584   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2585       server->server_type == SILC_SERVER ||
2586       packet->src_id_type != SILC_ID_SERVER)
2587     return;
2588
2589   idp = silc_id_payload_parse(buffer->data, buffer->len);
2590   if (!idp)
2591     return;
2592
2593   id_type = silc_id_payload_get_type(idp);
2594
2595   /* Normal server cannot have other normal server connections */
2596   server_entry = (SilcServerEntry)sock->user_data;
2597   if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
2598       server_entry->server_type == SILC_SERVER)
2599     goto out;
2600
2601   id = silc_id_payload_get_id(idp);
2602   if (!id)
2603     goto out;
2604
2605   /* If the packet is coming from server then use the sender as the
2606      origin of the the packet. If it came from router then check the real
2607      sender of the packet and use that as the origin. */
2608   if (sock->type == SILC_SOCKET_TYPE_SERVER) {
2609     id_list = server->local_list;
2610     router_sock = sock;
2611     router = sock->user_data;
2612
2613     /* If the sender is backup router and ID is server (and we are not
2614        backup router) then switch the entry to global list. */
2615     if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2616         id_type == SILC_ID_SERVER &&
2617         server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2618       id_list = server->global_list;
2619       router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2620     }
2621   } else {
2622     void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2623                                      packet->src_id_type);
2624     router = silc_idlist_find_server_by_id(server->global_list,
2625                                            sender_id, TRUE, NULL);
2626     if (!router)
2627       router = silc_idlist_find_server_by_id(server->local_list,
2628                                              sender_id, TRUE, NULL);
2629     silc_free(sender_id);
2630     router_sock = sock;
2631     id_list = server->global_list;
2632   }
2633
2634   if (!router)
2635     goto out;
2636
2637   switch(id_type) {
2638   case SILC_ID_CLIENT:
2639     {
2640       SilcClientEntry entry;
2641
2642       /* Check that we do not have this client already */
2643       entry = silc_idlist_find_client_by_id(server->global_list,
2644                                             id, server->server_type,
2645                                             NULL);
2646       if (!entry)
2647         entry = silc_idlist_find_client_by_id(server->local_list,
2648                                               id, server->server_type,
2649                                               NULL);
2650       if (entry) {
2651         SILC_LOG_DEBUG(("Ignoring client that we already have"));
2652         goto out;
2653       }
2654
2655       SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2656                       silc_id_render(id, SILC_ID_CLIENT),
2657                       sock->type == SILC_SOCKET_TYPE_SERVER ?
2658                       "Server" : "Router", sock->hostname));
2659
2660       /* As a router we keep information of all global information in our
2661          global list. Cell wide information however is kept in the local
2662          list. */
2663       entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2664                                      id, router, NULL, 0);
2665       if (!entry) {
2666         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2667
2668         /* Inform the sender that the ID is not usable */
2669         silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2670         goto out;
2671       }
2672       entry->nickname = NULL;
2673       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2674
2675       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2676         server->stat.cell_clients++;
2677       server->stat.clients++;
2678
2679       /* Check if anyone is watching this nickname */
2680       if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2681         silc_server_check_watcher_list(server, entry, NULL, 0);
2682     }
2683     break;
2684
2685   case SILC_ID_SERVER:
2686     {
2687       SilcServerEntry entry;
2688
2689       /* If the ID is mine, ignore it. */
2690       if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2691         SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2692         break;
2693       }
2694
2695       /* If the ID is the sender's ID, ignore it (we have it already) */
2696       if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2697         SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2698         break;
2699       }
2700
2701       /* Check that we do not have this server already */
2702       entry = silc_idlist_find_server_by_id(server->global_list,
2703                                             id, server->server_type,
2704                                             NULL);
2705       if (!entry)
2706         entry = silc_idlist_find_server_by_id(server->local_list,
2707                                               id, server->server_type,
2708                                               NULL);
2709       if (entry) {
2710         SILC_LOG_DEBUG(("Ignoring server that we already have"));
2711         goto out;
2712       }
2713
2714       SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2715                       silc_id_render(id, SILC_ID_SERVER),
2716                       sock->type == SILC_SOCKET_TYPE_SERVER ?
2717                       "Server" : "Router", sock->hostname));
2718
2719       /* As a router we keep information of all global information in our
2720          global list. Cell wide information however is kept in the local
2721          list. */
2722       entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2723                                      router_sock);
2724       if (!entry) {
2725         SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2726         goto out;
2727       }
2728       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2729
2730       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2731         server->stat.cell_servers++;
2732       server->stat.servers++;
2733     }
2734     break;
2735
2736   case SILC_ID_CHANNEL:
2737     SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2738     goto out;
2739     break;
2740
2741   default:
2742     goto out;
2743     break;
2744   }
2745
2746   /* If the sender of this packet is server and we are router we need to
2747      broadcast this packet to other routers in the network. */
2748   if (broadcast && server->server_type == SILC_ROUTER &&
2749       sock->type == SILC_SOCKET_TYPE_SERVER &&
2750       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2751     SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2752     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2753                             packet->type,
2754                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2755                             buffer->data, buffer->len, FALSE);
2756     silc_server_backup_send(server, sock->user_data,
2757                             packet->type, packet->flags,
2758                             packet->buffer->data, packet->buffer->len,
2759                             FALSE, TRUE);
2760   }
2761
2762  out:
2763   silc_id_payload_free(idp);
2764 }
2765
2766
2767 /* Processes incoming New ID packet. New ID Payload is used to distribute
2768    information about newly registered clients and servers. */
2769
2770 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2771                         SilcPacketContext *packet)
2772 {
2773   silc_server_new_id_real(server, sock, packet, TRUE);
2774 }
2775
2776 /* Receoved New Id List packet, list of New ID payloads inside one
2777    packet. Process the New ID payloads one by one. */
2778
2779 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2780                              SilcPacketContext *packet)
2781 {
2782   SilcPacketContext *new_id;
2783   SilcBuffer idp;
2784   SilcUInt16 id_len;
2785
2786   SILC_LOG_DEBUG(("Processing New ID List"));
2787
2788   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2789       packet->src_id_type != SILC_ID_SERVER)
2790     return;
2791
2792   /* If the sender of this packet is server and we are router we need to
2793      broadcast this packet to other routers in the network. Broadcast
2794      this list packet instead of multiple New ID packets. */
2795   if (server->server_type == SILC_ROUTER &&
2796       sock->type == SILC_SOCKET_TYPE_SERVER &&
2797       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2798     SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2799     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2800                             packet->type,
2801                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2802                             packet->buffer->data,
2803                             packet->buffer->len, FALSE);
2804     silc_server_backup_send(server, sock->user_data,
2805                             packet->type, packet->flags,
2806                             packet->buffer->data, packet->buffer->len,
2807                             FALSE, TRUE);
2808   }
2809
2810   /* Make copy of the original packet context, except for the actual
2811      data buffer, which we will here now fetch from the original buffer. */
2812   new_id = silc_packet_context_alloc();
2813   new_id->type = SILC_PACKET_NEW_ID;
2814   new_id->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
2815   new_id->src_id = packet->src_id;
2816   new_id->src_id_len = packet->src_id_len;
2817   new_id->src_id_type = packet->src_id_type;
2818   new_id->dst_id = packet->dst_id;
2819   new_id->dst_id_len = packet->dst_id_len;
2820   new_id->dst_id_type = packet->dst_id_type;
2821
2822   idp = silc_buffer_alloc(256);
2823   new_id->buffer = idp;
2824
2825   while (packet->buffer->len) {
2826     SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2827     if ((id_len > packet->buffer->len) ||
2828         (id_len > idp->truelen))
2829       break;
2830
2831     silc_buffer_pull_tail(idp, 4 + id_len);
2832     silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2833
2834     /* Process the New ID */
2835     silc_server_new_id_real(server, sock, new_id, FALSE);
2836
2837     silc_buffer_push_tail(idp, 4 + id_len);
2838     silc_buffer_pull(packet->buffer, 4 + id_len);
2839   }
2840
2841   silc_buffer_free(idp);
2842   silc_free(new_id);
2843 }
2844
2845 /* Received New Channel packet. Information about new channels in the
2846    network are distributed using this packet. Save the information about
2847    the new channel. This usually comes from router but also normal server
2848    can send this to notify channels it has when it connects to us. */
2849
2850 void silc_server_new_channel(SilcServer server,
2851                              SilcSocketConnection sock,
2852                              SilcPacketContext *packet)
2853 {
2854   SilcChannelPayload payload;
2855   SilcChannelID *channel_id;
2856   char *channel_name;
2857   SilcUInt32 name_len;
2858   unsigned char *id;
2859   SilcUInt32 id_len;
2860   SilcServerEntry server_entry;
2861   SilcChannelEntry channel;
2862
2863   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2864       packet->src_id_type != SILC_ID_SERVER ||
2865       server->server_type == SILC_SERVER)
2866     return;
2867
2868   /* Parse the channel payload */
2869   payload = silc_channel_payload_parse(packet->buffer->data,
2870                                        packet->buffer->len);
2871   if (!payload)
2872     return;
2873
2874   /* Get the channel ID */
2875   channel_id = silc_channel_get_id_parse(payload);
2876   if (!channel_id) {
2877     silc_channel_payload_free(payload);
2878     return;
2879   }
2880
2881   channel_name = silc_channel_get_name(payload, &name_len);
2882   if (name_len > 256)
2883     channel_name[255] = '\0';
2884
2885   id = silc_channel_get_id(payload, &id_len);
2886
2887   server_entry = (SilcServerEntry)sock->user_data;
2888
2889   if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2890     /* Add the channel to global list as it is coming from router. It
2891        cannot be our own channel as it is coming from router. */
2892
2893     /* Check that we don't already have this channel */
2894     channel = silc_idlist_find_channel_by_name(server->local_list,
2895                                                channel_name, NULL);
2896     if (!channel)
2897       channel = silc_idlist_find_channel_by_name(server->global_list,
2898                                                  channel_name, NULL);
2899     if (!channel) {
2900       SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2901                       silc_id_render(channel_id, SILC_ID_CHANNEL),
2902                       sock->hostname));
2903
2904       channel =
2905         silc_idlist_add_channel(server->global_list, strdup(channel_name),
2906                                 0, channel_id, sock->user_data, NULL, NULL, 0);
2907       if (!channel)
2908         return;
2909       channel->disabled = TRUE;    /* Disabled until someone JOINs */
2910
2911       server->stat.channels++;
2912       if (server->server_type == SILC_ROUTER)
2913         channel->users_resolved = TRUE;
2914     }
2915   } else {
2916     /* The channel is coming from our server, thus it is in our cell
2917        we will add it to our local list. */
2918     SilcBuffer chk;
2919
2920     SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2921                     silc_id_render(channel_id, SILC_ID_CHANNEL),
2922                     sock->hostname));
2923
2924     /* Check that we don't already have this channel */
2925     channel = silc_idlist_find_channel_by_name(server->local_list,
2926                                                channel_name, NULL);
2927     if (!channel)
2928       channel = silc_idlist_find_channel_by_name(server->global_list,
2929                                                  channel_name, NULL);
2930
2931     /* If the channel does not exist, then create it. This creates a new
2932        key to the channel as well that we will send to the server. */
2933     if (!channel) {
2934       SILC_LOG_DEBUG(("Channel is new to us"));
2935
2936       /* The protocol says that the Channel ID's IP address must be based
2937          on the router's IP address.  Check whether the ID is based in our
2938          IP and if it is not then create a new ID and enforce the server
2939          to switch the ID. */
2940       if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2941           !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2942         SilcChannelID *tmp;
2943         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2944         if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2945           silc_server_send_notify_channel_change(server, sock, FALSE,
2946                                                  channel_id, tmp);
2947           silc_free(channel_id);
2948           silc_free(tmp);
2949         }
2950
2951         /* Wait that server re-announces this channel */
2952         return;
2953       }
2954
2955       /* Create the channel with the provided Channel ID */
2956       channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2957                                                        channel_name,
2958                                                        channel_id, FALSE);
2959       if (!channel) {
2960         silc_channel_payload_free(payload);
2961         silc_free(channel_id);
2962         return;
2963       }
2964       channel->disabled = TRUE;    /* Disabled until someone JOINs */
2965
2966 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
2967
2968       /* XXX Dunno if this is supposed to be set in any server type.  If set
2969          here the CMODE_CHANGE that may follow sets mode that we already
2970          have, and we may loose data from the CMODE_CHANGE notify. */
2971       if (server_entry->server_type != SILC_BACKUP_ROUTER)
2972         channel->mode = silc_channel_get_mode(payload);
2973 #endif
2974
2975       /* Send the new channel key to the server */
2976       id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2977       id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2978       chk = silc_channel_key_payload_encode(id_len, id,
2979                                             strlen(channel->channel_key->
2980                                                    cipher->name),
2981                                             channel->channel_key->cipher->name,
2982                                             channel->key_len / 8,
2983                                             channel->key);
2984       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2985                               chk->data, chk->len, FALSE);
2986       silc_buffer_free(chk);
2987     } else {
2988       /* The channel exist by that name, check whether the ID's match.
2989          If they don't then we'll force the server to use the ID we have.
2990          We also create a new key for the channel. */
2991       SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
2992
2993       SILC_LOG_DEBUG(("Channel already exists"));
2994
2995       if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2996         /* They don't match, send CHANNEL_CHANGE notify to the server to
2997            force the ID change. */
2998         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2999         silc_server_send_notify_channel_change(server, sock, FALSE,
3000                                                channel_id, channel->id);
3001
3002         /* Wait that server re-announces this channel */
3003         return;
3004       }
3005
3006 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3007          to check it (implicit enforce). */
3008
3009       /* If the mode is different from what we have then enforce the
3010          mode change. */
3011       mode = silc_channel_get_mode(payload);
3012       if (channel->mode != mode) {
3013         SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3014         silc_server_send_notify_cmode(server, sock, FALSE, channel,
3015                                       channel->mode, server->id,
3016                                       SILC_ID_SERVER, channel->cipher,
3017                                       channel->hmac_name,
3018                                       channel->passphrase,
3019                                       channel->founder_key);
3020       }
3021 #endif
3022
3023       /* Create new key for the channel and send it to the server and
3024          everybody else possibly on the channel. */
3025       if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3026
3027         if (silc_hash_table_count(channel->user_list)) {
3028           if (!silc_server_create_channel_key(server, channel, 0))
3029             return;
3030
3031           /* Send to the channel */
3032           silc_server_send_channel_key(server, sock, channel, FALSE);
3033         }
3034
3035         /* Send to the server */
3036         id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3037         id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
3038         chk = silc_channel_key_payload_encode(id_len, id,
3039                                               strlen(channel->channel_key->
3040                                                      cipher->name),
3041                                               channel->channel_key->
3042                                               cipher->name,
3043                                               channel->key_len / 8,
3044                                               channel->key);
3045         silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3046                                 chk->data, chk->len, FALSE);
3047         silc_buffer_free(chk);
3048         silc_free(id);
3049       }
3050
3051       silc_free(channel_id);
3052
3053       /* Update statistics */
3054       server->stat.channels++;
3055       server->stat.cell_channels++;
3056
3057       /* Since the channel is coming from server and we also know about it
3058          then send the JOIN notify to the server so that it see's our
3059          users on the channel "joining" the channel. */
3060       silc_server_announce_get_channel_users(server, channel, &modes, &users,
3061                                              &users_modes);
3062       if (users) {
3063         silc_buffer_push(users, users->data - users->head);
3064         silc_server_packet_send(server, sock,
3065                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3066                                 users->data, users->len, FALSE);
3067         silc_buffer_free(users);
3068       }
3069       if (modes) {
3070         silc_buffer_push(modes, modes->data - modes->head);
3071         silc_server_packet_send_dest(server, sock,
3072                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3073                                      channel->id, SILC_ID_CHANNEL,
3074                                      modes->data, modes->len, FALSE);
3075         silc_buffer_free(modes);
3076       }
3077       if (users_modes) {
3078         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3079         silc_server_packet_send_dest(server, sock,
3080                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3081                                      channel->id, SILC_ID_CHANNEL,
3082                                      users_modes->data,
3083                                      users_modes->len, FALSE);
3084         silc_buffer_free(users_modes);
3085       }
3086       if (channel->topic) {
3087         silc_server_send_notify_topic_set(server, sock,
3088                                           server->server_type == SILC_ROUTER ?
3089                                           TRUE : FALSE, channel,
3090                                           server->id, SILC_ID_SERVER,
3091                                           channel->topic);
3092       }
3093     }
3094   }
3095
3096   /* If the sender of this packet is server and we are router we need to
3097      broadcast this packet to other routers in the network. Broadcast
3098      this list packet instead of multiple New Channel packets. */
3099   if (server->server_type == SILC_ROUTER &&
3100       sock->type == SILC_SOCKET_TYPE_SERVER &&
3101       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3102     SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3103     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3104                             packet->type,
3105                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
3106                             packet->buffer->data,
3107                             packet->buffer->len, FALSE);
3108     silc_server_backup_send(server, sock->user_data,
3109                             packet->type, packet->flags,
3110                             packet->buffer->data, packet->buffer->len,
3111                             FALSE, TRUE);
3112   }
3113
3114   silc_channel_payload_free(payload);
3115 }
3116
3117 /* Received New Channel List packet, list of New Channel List payloads inside
3118    one packet. Process the New Channel payloads one by one. */
3119
3120 void silc_server_new_channel_list(SilcServer server,
3121                                   SilcSocketConnection sock,
3122                                   SilcPacketContext *packet)
3123 {
3124   SilcPacketContext *new;
3125   SilcBuffer buffer;
3126   SilcUInt16 len1, len2;
3127
3128   SILC_LOG_DEBUG(("Processing New Channel List"));
3129
3130   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
3131       packet->src_id_type != SILC_ID_SERVER ||
3132       server->server_type == SILC_SERVER)
3133     return;
3134
3135   /* Make copy of the original packet context, except for the actual
3136      data buffer, which we will here now fetch from the original buffer. */
3137   new = silc_packet_context_alloc();
3138   new->type = SILC_PACKET_NEW_CHANNEL;
3139   new->flags = packet->flags & (~SILC_PACKET_FLAG_LIST);
3140   new->src_id = packet->src_id;
3141   new->src_id_len = packet->src_id_len;
3142   new->src_id_type = packet->src_id_type;
3143   new->dst_id = packet->dst_id;
3144   new->dst_id_len = packet->dst_id_len;
3145   new->dst_id_type = packet->dst_id_type;
3146
3147   buffer = silc_buffer_alloc(512);
3148   new->buffer = buffer;
3149
3150   while (packet->buffer->len) {
3151     SILC_GET16_MSB(len1, packet->buffer->data);
3152     if ((len1 > packet->buffer->len) ||
3153         (len1 > buffer->truelen))
3154       break;
3155
3156     SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
3157     if ((len2 > packet->buffer->len) ||
3158         (len2 > buffer->truelen))
3159       break;
3160
3161     silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3162     silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
3163
3164     /* Process the New Channel */
3165     silc_server_new_channel(server, sock, new);
3166
3167     silc_buffer_push_tail(buffer, 8 + len1 + len2);
3168     silc_buffer_pull(packet->buffer, 8 + len1 + len2);
3169   }
3170
3171   silc_buffer_free(buffer);
3172   silc_free(new);
3173 }
3174
3175 /* Received key agreement packet. This packet is never for us. It is to
3176    the client in the packet's destination ID. Sending of this sort of packet
3177    equals sending private message, ie. it is sent point to point from
3178    one client to another. */
3179
3180 void silc_server_key_agreement(SilcServer server,
3181                                SilcSocketConnection sock,
3182                                SilcPacketContext *packet)
3183 {
3184   SilcSocketConnection dst_sock;
3185   SilcIDListData idata;
3186
3187   SILC_LOG_DEBUG(("Start"));
3188
3189   if (packet->src_id_type != SILC_ID_CLIENT ||
3190       packet->dst_id_type != SILC_ID_CLIENT)
3191     return;
3192
3193   if (!packet->dst_id)
3194     return;
3195
3196   /* Get the route to the client */
3197   dst_sock = silc_server_get_client_route(server, packet->dst_id,
3198                                           packet->dst_id_len, NULL,
3199                                           &idata, NULL);
3200   if (!dst_sock)
3201     return;
3202
3203   /* Relay the packet */
3204   silc_server_relay_packet(server, dst_sock, idata->send_key,
3205                            idata->hmac_send, idata->psn_send++,
3206                            packet, FALSE);
3207 }
3208
3209 /* Received connection auth request packet that is used during connection
3210    phase to resolve the mandatory authentication method.  This packet can
3211    actually be received at anytime but usually it is used only during
3212    the connection authentication phase. Now, protocol says that this packet
3213    can come from client or server, however, we support only this coming
3214    from client and expect that server always knows what authentication
3215    method to use. */
3216
3217 void silc_server_connection_auth_request(SilcServer server,
3218                                          SilcSocketConnection sock,
3219                                          SilcPacketContext *packet)
3220 {
3221   SilcServerConfigClient *client = NULL;
3222   SilcUInt16 conn_type;
3223   int ret;
3224   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3225
3226   if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3227     SILC_LOG_DEBUG(("Request not from client"));
3228     return;
3229   }
3230
3231   /* Parse the payload */
3232   ret = silc_buffer_unformat(packet->buffer,
3233                              SILC_STR_UI_SHORT(&conn_type),
3234                              SILC_STR_UI_SHORT(NULL),
3235                              SILC_STR_END);
3236   if (ret == -1)
3237     return;
3238
3239   if (conn_type != SILC_SOCKET_TYPE_CLIENT)
3240     return;
3241
3242   /* Get the authentication method for the client */
3243   auth_meth = SILC_AUTH_NONE;
3244   client = silc_server_config_find_client(server, sock->ip);
3245   if (!client)
3246     client = silc_server_config_find_client(server, sock->hostname);
3247   if (client) {
3248     if (client->passphrase) {
3249       if (client->publickeys && !server->config->prefer_passphrase_auth)
3250         auth_meth = SILC_AUTH_PUBLIC_KEY;
3251       else
3252         auth_meth = SILC_AUTH_PASSWORD;
3253     } else if (client->publickeys)
3254       auth_meth = SILC_AUTH_PUBLIC_KEY;
3255   }
3256
3257   SILC_LOG_DEBUG(("Authentication method is [%s]",
3258                   (auth_meth == SILC_AUTH_NONE ? "None" :
3259                    auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3260                    "Digital signatures")));
3261
3262   /* Send it back to the client */
3263   silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3264 }
3265
3266 /* Received REKEY packet. The sender of the packet wants to regenerate
3267    its session keys. This starts the REKEY protocol. */
3268
3269 void silc_server_rekey(SilcServer server,
3270                        SilcSocketConnection sock,
3271                        SilcPacketContext *packet)
3272 {
3273   SilcProtocol protocol;
3274   SilcServerRekeyInternalContext *proto_ctx;
3275   SilcIDListData idata = (SilcIDListData)sock->user_data;
3276
3277   SILC_LOG_DEBUG(("Start"));
3278
3279   /* Allocate internal protocol context. This is sent as context
3280      to the protocol. */
3281   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
3282   proto_ctx->server = (void *)server;
3283   proto_ctx->sock = sock;
3284   proto_ctx->responder = TRUE;
3285   proto_ctx->pfs = idata->rekey->pfs;
3286
3287   /* Perform rekey protocol. Will call the final callback after the
3288      protocol is over. */
3289   silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
3290                       &protocol, proto_ctx, silc_server_rekey_final);
3291   sock->protocol = protocol;
3292
3293   if (proto_ctx->pfs == FALSE)
3294     /* Run the protocol */
3295     silc_protocol_execute(protocol, server->schedule, 0, 0);
3296 }
3297
3298 /* Received file transger packet. This packet is never for us. It is to
3299    the client in the packet's destination ID. Sending of this sort of packet
3300    equals sending private message, ie. it is sent point to point from
3301    one client to another. */
3302
3303 void silc_server_ftp(SilcServer server,
3304                      SilcSocketConnection sock,
3305                      SilcPacketContext *packet)
3306 {
3307   SilcSocketConnection dst_sock;
3308   SilcIDListData idata;
3309
3310   SILC_LOG_DEBUG(("Start"));
3311
3312   if (packet->src_id_type != SILC_ID_CLIENT ||
3313       packet->dst_id_type != SILC_ID_CLIENT)
3314     return;
3315
3316   if (!packet->dst_id)
3317     return;
3318
3319   /* Get the route to the client */
3320   dst_sock = silc_server_get_client_route(server, packet->dst_id,
3321                                           packet->dst_id_len, NULL,
3322                                           &idata, NULL);
3323   if (!dst_sock)
3324     return;
3325
3326   /* Relay the packet */
3327   silc_server_relay_packet(server, dst_sock, idata->send_key,
3328                            idata->hmac_send, idata->psn_send++,
3329                            packet, FALSE);
3330 }
3331
3332 typedef struct {
3333   SilcServer server;
3334   SilcSocketConnection sock;
3335   SilcPacketContext *packet;
3336   void *data;
3337 } *SilcServerResumeResolve;
3338
3339 SILC_SERVER_CMD_FUNC(resume_resolve)
3340 {
3341   SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3342   SilcServer server = r->server;
3343   SilcSocketConnection sock = r->sock;
3344   SilcServerCommandReplyContext reply = context2;
3345   SilcClientEntry client;
3346
3347   SILC_LOG_DEBUG(("Start"));
3348
3349   if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3350     SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3351                     "closing connection", sock->hostname, sock->ip));
3352     silc_server_disconnect_remote(server, sock,
3353                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3354                                   "Resuming not possible");
3355     if (sock->user_data)
3356       silc_server_free_sock_user_data(server, sock, NULL);
3357     goto out;
3358   }
3359
3360   if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3361     /* Get entry to the client, and resolve it if we don't have it. */
3362     client = silc_idlist_find_client_by_id(server->local_list,
3363                                            r->data, TRUE, NULL);
3364     if (!client) {
3365       client = silc_idlist_find_client_by_id(server->global_list,
3366                                              r->data, TRUE, NULL);
3367       if (!client) {
3368         SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3369                         "closing connection", sock->hostname, sock->ip));
3370         silc_server_disconnect_remote(server, sock,
3371                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3372                                       "Resuming not possible");
3373         if (sock->user_data)
3374           silc_server_free_sock_user_data(server, sock, NULL);
3375         goto out;
3376       }
3377     }
3378
3379     if (!(client->mode & SILC_UMODE_DETACHED)) {
3380       SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3381                       "closing connection", sock->hostname, sock->ip));
3382       silc_server_disconnect_remote(server, sock,
3383                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3384                                     "Resuming not possible");
3385       if (sock->user_data)
3386         silc_server_free_sock_user_data(server, sock, NULL);
3387       goto out;
3388     }
3389
3390     client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3391   }
3392
3393   /* Reprocess the packet */
3394   silc_server_resume_client(server, sock, r->packet);
3395
3396  out:
3397   silc_socket_free(r->sock);
3398   silc_packet_context_free(r->packet);
3399   silc_free(r->data);
3400   silc_free(r);
3401 }
3402
3403 /* Received client resuming packet.  This is used to resume detached
3404    client session.  It can be sent by the client who wishes to resume
3405    but this is also sent by servers and routers to notify other routers
3406    that the client is not detached anymore. */
3407
3408 void silc_server_resume_client(SilcServer server,
3409                                SilcSocketConnection sock,
3410                                SilcPacketContext *packet)
3411 {
3412   SilcBuffer buffer = packet->buffer, buf;
3413   SilcIDListData idata;
3414   SilcIDCacheEntry id_cache = NULL;
3415   SilcClientEntry detached_client;
3416   SilcClientID *client_id = NULL;
3417   unsigned char *id_string, *auth = NULL;
3418   SilcUInt16 id_len, auth_len = 0;
3419   int ret, nickfail = 0;
3420   bool resolved, local, nick_change = FALSE, resolve = FALSE;
3421   SilcChannelEntry channel;
3422   SilcHashTableList htl;
3423   SilcChannelClientEntry chl;
3424   SilcServerResumeResolve r;
3425
3426   ret = silc_buffer_unformat(buffer,
3427                              SILC_STR_UI16_NSTRING(&id_string, &id_len),
3428                              SILC_STR_END);
3429   if (ret != -1)
3430     client_id = silc_id_str2id(id_string, id_len, SILC_ID_CLIENT);
3431
3432   if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
3433     /* Client send this and is attempting to resume to old client session */
3434     SilcClientEntry client;
3435     SilcBuffer keyp;
3436
3437     if (ret != -1) {
3438       silc_buffer_pull(buffer, 2 + id_len);
3439       auth = buffer->data;
3440       auth_len = buffer->len;
3441       silc_buffer_push(buffer, 2 + id_len);
3442     }
3443
3444     if (!client_id || auth_len < 128) {
3445       SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3446                       "closing connection", sock->hostname, sock->ip));
3447       silc_server_disconnect_remote(server, sock,
3448                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3449                                     "Resuming not possible");
3450       if (sock->user_data)
3451         silc_server_free_sock_user_data(server, sock, NULL);
3452       silc_free(client_id);
3453       return;
3454     }
3455
3456     /* Take client entry of this connection */
3457     client = (SilcClientEntry)sock->user_data;
3458     idata = (SilcIDListData)client;
3459
3460     /* Get entry to the client, and resolve it if we don't have it. */
3461     detached_client = silc_server_query_client(server, client_id, FALSE,
3462                                                &resolved);
3463     if (!detached_client) {
3464       if (resolved) {
3465         /* The client info is being resolved. Reprocess this packet after
3466            receiving the reply to the query. */
3467         SILC_LOG_DEBUG(("Resolving client"));
3468         r = silc_calloc(1, sizeof(*r));
3469         if (!r)
3470           return;
3471         r->server = server;
3472         r->sock = silc_socket_dup(sock);
3473         r->packet = silc_packet_context_dup(packet);
3474         r->data = client_id;
3475         silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3476                                     server->cmd_ident,
3477                                     silc_server_command_resume_resolve, r);
3478       } else {
3479         SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3480                         "closing connection", sock->hostname, sock->ip));
3481         silc_server_disconnect_remote(server, sock,
3482                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3483                                       "Resuming not possible");
3484         if (sock->user_data)
3485           silc_server_free_sock_user_data(server, sock, NULL);
3486         silc_free(client_id);
3487       }
3488       return;
3489     }
3490
3491     if (!(detached_client->mode & SILC_UMODE_DETACHED))
3492       resolve = TRUE;
3493     if (!silc_hash_table_count(detached_client->channels) &&
3494         detached_client->router)
3495       resolve = TRUE;
3496     if (!detached_client->nickname)
3497       resolve = TRUE;
3498     if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3499       resolve = FALSE;
3500
3501     if (resolve) {
3502       if (server->server_type == SILC_SERVER && !server->standalone) {
3503         /* The client info is being resolved. Reprocess this packet after
3504            receiving the reply to the query. */
3505         SILC_LOG_DEBUG(("Resolving client info"));
3506         silc_server_query_client(server, client_id, TRUE, NULL);
3507         r = silc_calloc(1, sizeof(*r));
3508         if (!r)
3509           return;
3510         r->server = server;
3511         r->sock = silc_socket_dup(sock);
3512         r->packet = silc_packet_context_dup(packet);
3513         r->data = client_id;
3514         silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3515                                     server->cmd_ident,
3516                                     silc_server_command_resume_resolve, r);
3517         return;
3518       }
3519       if (server->server_type == SILC_SERVER) {
3520         SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3521                         "closing connection", sock->hostname, sock->ip));
3522         silc_server_disconnect_remote(server, sock,
3523                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3524                                       "Resuming not possible");
3525         if (sock->user_data)
3526           silc_server_free_sock_user_data(server, sock, NULL);
3527         silc_free(client_id);
3528         return;
3529       }
3530     }
3531
3532     /* Check that we have the public key of the client, if not then we must
3533        resolve it first. */
3534     if (!detached_client->data.public_key) {
3535       if (server->server_type == SILC_SERVER && server->standalone) {
3536         SILC_LOG_ERROR(("Detached client's public key not present, "
3537                         "closing connection"));
3538         silc_server_disconnect_remote(server, sock,
3539                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3540                                       "Resuming not possible");
3541         if (sock->user_data)
3542           silc_server_free_sock_user_data(server, sock, NULL);
3543         silc_free(client_id);
3544       } else {
3545         /* We must retrieve the detached client's public key by sending
3546            GETKEY command. Reprocess this packet after receiving the key */
3547         SilcBuffer idp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3548         SilcSocketConnection dest_sock =
3549           silc_server_get_client_route(server, NULL, 0, client_id, NULL, NULL);
3550
3551         SILC_LOG_DEBUG(("Resolving client public key"));
3552
3553         silc_server_send_command(server, dest_sock ? dest_sock :
3554                                  SILC_PRIMARY_ROUTE(server),
3555                                  SILC_COMMAND_GETKEY, ++server->cmd_ident,
3556                                  1, 1, idp->data, idp->len);
3557
3558         r = silc_calloc(1, sizeof(*r));
3559         if (!r) {
3560           silc_free(client_id);
3561           return;
3562         }
3563
3564         r->server = server;
3565         r->sock = silc_socket_dup(sock);
3566         r->packet = silc_packet_context_dup(packet);
3567         silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3568                                     server->cmd_ident,
3569                                     silc_server_command_resume_resolve, r);
3570
3571         silc_buffer_free(idp);
3572       }
3573       silc_free(client_id);
3574       return;
3575     } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3576                                              idata->public_key)) {
3577       /* We require that the connection and resuming authentication data
3578          must be using same key pair. */
3579       SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3580                       "closing connection"));
3581       silc_server_disconnect_remote(server, sock,
3582                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3583                                     "Resuming not possible");
3584       if (sock->user_data)
3585         silc_server_free_sock_user_data(server, sock, NULL);
3586       silc_free(client_id);
3587       return;
3588     }
3589
3590     /* Verify the authentication payload.  This has to be successful in
3591        order to allow the resuming */
3592     if (!idata->hash ||
3593         !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3594                                detached_client->data.public_key, 0,
3595                                idata->hash, detached_client->id,
3596                                SILC_ID_CLIENT)) {
3597       SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3598                       "closing connection", sock->hostname, sock->ip));
3599       silc_server_disconnect_remote(server, sock,
3600                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3601                                     "Resuming not possible");
3602       if (sock->user_data)
3603         silc_server_free_sock_user_data(server, sock, NULL);
3604       silc_free(client_id);
3605       return;
3606     }
3607
3608     /* Now resume the client to the network */
3609
3610     silc_schedule_task_del_by_context(server->schedule, detached_client);
3611     sock->user_data = detached_client;
3612     detached_client->connection = sock;
3613
3614     /* Take new keys and stuff into use in the old entry */
3615     silc_idlist_del_data(detached_client);
3616     silc_idlist_add_data(detached_client, idata);
3617     detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3618     detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3619     detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3620     detached_client->mode &= ~SILC_UMODE_DETACHED;
3621     server->stat.my_detached--;
3622
3623     /* Send the RESUME_CLIENT packet to our primary router so that others
3624        know this client isn't detached anymore. */
3625     buf = silc_buffer_alloc_size(2 + id_len);
3626     silc_buffer_format(buf,
3627                        SILC_STR_UI_SHORT(id_len),
3628                        SILC_STR_UI_XNSTRING(id_string, id_len),
3629                        SILC_STR_END);
3630
3631     /* Send to primary router */
3632     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3633                             SILC_PACKET_RESUME_CLIENT, 0,
3634                             buf->data, buf->len, TRUE);
3635
3636     /* As router we must deliver this packet directly to the original
3637        server whom this client was earlier. */
3638     if (server->server_type == SILC_ROUTER && detached_client->router &&
3639         detached_client->router->server_type != SILC_ROUTER)
3640       silc_server_packet_send(server, detached_client->router->connection,
3641                               SILC_PACKET_RESUME_CLIENT, 0,
3642                               buf->data, buf->len, TRUE);
3643     silc_buffer_free(buf);
3644
3645     detached_client->router = NULL;
3646
3647     /* Delete this client entry since we're resuming to old one. */
3648     server->stat.my_clients--;
3649     server->stat.clients--;
3650     if (server->stat.cell_clients)
3651       server->stat.cell_clients--;
3652     silc_server_remove_from_channels(server, NULL, client, FALSE, NULL, FALSE);
3653     silc_server_del_from_watcher_list(server, client);
3654     if (!silc_idlist_del_client(server->local_list, client))
3655       silc_idlist_del_client(server->global_list, client);
3656     client = detached_client;
3657
3658     /* If the ID is not based in our ID then change it */
3659     if (!SILC_ID_COMPARE(client->id, server->id, server->id->ip.data_len)) {
3660       silc_free(client_id);
3661       while (!silc_id_create_client_id(server, server->id, server->rng,
3662                                        server->md5hash, client->nickname,
3663                                        &client_id)) {
3664         nickfail++;
3665         if (nickfail > 9) {
3666           silc_server_disconnect_remote(server, sock,
3667                                         SILC_STATUS_ERR_BAD_NICKNAME, NULL);
3668           if (sock->user_data)
3669             silc_server_free_sock_user_data(server, sock, NULL);
3670           return;
3671         }
3672         snprintf(&client->nickname[strlen(client->nickname) - 1], 1,
3673                  "%d", nickfail);
3674       }
3675       nick_change = TRUE;
3676     }
3677
3678     if (nick_change) {
3679       /* Notify about Client ID change, nickname doesn't actually change. */
3680       silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3681                                           SILC_BROADCAST(server),
3682                                           client->id, client_id,
3683                                           client->nickname);
3684     }
3685
3686     /* Resolve users on those channels that client has joined but we
3687        haven't resolved user list yet. */
3688     if (server->server_type == SILC_SERVER && !server->standalone) {
3689       silc_hash_table_list(client->channels, &htl);
3690       while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3691         channel = chl->channel;
3692         SILC_LOG_DEBUG(("Resolving users for %s channel",
3693                         channel->channel_name));
3694         if (channel->disabled || !channel->users_resolved) {
3695           silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3696                                    SILC_COMMAND_USERS, ++server->cmd_ident,
3697                                    1, 2, channel->channel_name,
3698                                    strlen(channel->channel_name));
3699         }
3700       }
3701       silc_hash_table_list_reset(&htl);
3702     }
3703
3704     /* Send the new client ID to the client. After this client may start
3705        receiving other packets, and may start sending packets too. */
3706     silc_server_send_new_id(server, sock, FALSE, client_id, SILC_ID_CLIENT,
3707                             silc_id_get_len(client_id, SILC_ID_CLIENT));
3708
3709     if (nick_change) {
3710       /* Send NICK change notify to channels as well. */
3711       SilcBuffer oidp, nidp;
3712       oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3713       nidp = silc_id_payload_encode(client_id, SILC_ID_CLIENT);
3714       silc_server_send_notify_on_channels(server, NULL, client,
3715                                           SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3716                                           oidp->data, oidp->len,
3717                                           nidp->data, nidp->len,
3718                                           client->nickname,
3719                                           strlen(client->nickname));
3720       silc_buffer_free(oidp);
3721       silc_buffer_free(nidp);
3722     }
3723
3724     /* Add the client again to the ID cache to get it to correct list */
3725     if (!silc_idcache_del_by_context(server->local_list->clients, client))
3726       silc_idcache_del_by_context(server->global_list->clients, client);
3727     silc_free(client->id);
3728     client->id = client_id;
3729     client_id = NULL;
3730     silc_idcache_add(server->local_list->clients, client->nickname,
3731                      client->id, client, 0, NULL);
3732
3733     /* Send some nice info to the client */
3734     silc_server_send_connect_notifys(server, sock, client);
3735
3736     /* Send all channel keys of channels the client has joined */
3737     silc_hash_table_list(client->channels, &htl);
3738     while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
3739       bool created = FALSE;
3740       channel = chl->channel;
3741
3742       if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3743         continue;
3744
3745       /* If we don't have channel key, then create one */
3746       if (!channel->channel_key) {
3747         if (!silc_server_create_channel_key(server, channel, 0))
3748           continue;
3749         created = TRUE;
3750       }
3751
3752       id_string = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
3753       keyp =
3754         silc_channel_key_payload_encode(silc_id_get_len(channel->id,
3755                                                         SILC_ID_CHANNEL),
3756                                         id_string,
3757                                         strlen(channel->channel_key->
3758                                                cipher->name),
3759                                         channel->channel_key->cipher->name,
3760                                         channel->key_len / 8, channel->key);
3761       silc_free(id_string);
3762
3763       /* Send the key packet to client */
3764       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3765                               keyp->data, keyp->len, FALSE);
3766
3767       if (created && server->server_type == SILC_SERVER)
3768         silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3769                                 SILC_PACKET_CHANNEL_KEY, 0,
3770                                 keyp->data, keyp->len, FALSE);
3771
3772       silc_buffer_free(keyp);
3773     }
3774     silc_hash_table_list_reset(&htl);
3775
3776   } else if (sock->type != SILC_SOCKET_TYPE_CLIENT) {
3777     /* Server or router sent this to us to notify that that a client has
3778        been resumed. */
3779     SilcServerEntry server_entry;
3780     SilcServerID *server_id;
3781
3782     if (!client_id) {
3783       SILC_LOG_DEBUG(("Malformed resuming packet"));
3784       return;
3785     }
3786
3787     /* Get entry to the client, and resolve it if we don't have it. */
3788     detached_client = silc_idlist_find_client_by_id(server->local_list,
3789                                                     client_id, TRUE,
3790                                                     &id_cache);
3791     if (!detached_client) {
3792       detached_client = silc_idlist_find_client_by_id(server->global_list,
3793                                                       client_id, TRUE,
3794                                                       &id_cache);
3795       if (!detached_client) {
3796         SILC_LOG_DEBUG(("Resuming client is unknown"));
3797         silc_free(client_id);
3798         return;
3799       }
3800     }
3801
3802     /* Check that the client has not been resumed already because it is
3803        protocol error to attempt to resume more than once.  The client
3804        will be killed if this protocol error occurs. */
3805     if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3806         !(detached_client->mode & SILC_UMODE_DETACHED)) {
3807       /* The client is clearly attempting to resume more than once and
3808          perhaps playing around by resuming from several different places
3809          at the same time. */
3810       SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3811       silc_server_kill_client(server, detached_client, NULL,
3812                               server->id, SILC_ID_SERVER);
3813       silc_free(client_id);
3814       return;
3815     }
3816
3817     /* Check whether client is detached at all */
3818     if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3819       SILC_LOG_DEBUG(("Client is not detached"));
3820       silc_free(client_id);
3821       return;
3822     }
3823
3824     SILC_LOG_DEBUG(("Resuming detached client"));
3825
3826     /* If the sender of this packet is server and we are router we need to
3827        broadcast this packet to other routers in the network. */
3828     if (server->server_type == SILC_ROUTER &&
3829         sock->type == SILC_SOCKET_TYPE_SERVER &&
3830         !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3831       SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3832       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3833                               packet->type,
3834                               packet->flags | SILC_PACKET_FLAG_BROADCAST,
3835                               buffer->data, buffer->len, FALSE);
3836       silc_server_backup_send(server, sock->user_data,
3837                               packet->type, packet->flags,
3838                               packet->buffer->data, packet->buffer->len,
3839                               FALSE, TRUE);
3840     }
3841
3842     /* Client is detached, and now it is resumed.  Remove the detached
3843        mode and mark that it is resumed. */
3844     detached_client->mode &= ~SILC_UMODE_DETACHED;
3845     detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3846     detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3847     id_cache->expire = 0;
3848
3849     /* Update channel information regarding global clients on channel. */
3850     if (server->server_type == SILC_SERVER) {
3851       silc_hash_table_list(detached_client->channels, &htl);
3852       while (silc_hash_table_get(&htl, NULL, (void **)&chl))
3853         chl->channel->global_users =
3854           silc_server_channel_has_global(chl->channel);
3855       silc_hash_table_list_reset(&htl);
3856     }
3857
3858     silc_schedule_task_del_by_context(server->schedule, detached_client);
3859
3860     /* Get the new owner of the resumed client */
3861     server_id = silc_id_str2id(packet->src_id, packet->src_id_len,
3862                                packet->src_id_type);
3863     if (!server_id) {
3864       silc_free(client_id);
3865       return;
3866     }
3867
3868     /* Get server entry */
3869     server_entry = silc_idlist_find_server_by_id(server->global_list,
3870                                                  server_id, TRUE, NULL);
3871     local = FALSE;
3872     if (!server_entry) {
3873       server_entry = silc_idlist_find_server_by_id(server->local_list,
3874                                                    server_id, TRUE, NULL);
3875       local = TRUE;
3876       if (!server_entry) {
3877         silc_free(server_id);
3878         silc_free(client_id);
3879         return;
3880       }
3881     }
3882
3883     if (server->server_type == SILC_ROUTER &&
3884         sock->type == SILC_SOCKET_TYPE_ROUTER &&
3885         server_entry->server_type == SILC_ROUTER)
3886       local = FALSE;
3887
3888     /* Change the client to correct list. */
3889     if (!silc_idcache_del_by_context(server->local_list->clients,
3890                                      detached_client))
3891       silc_idcache_del_by_context(server->global_list->clients,
3892                                   detached_client);
3893     silc_idcache_add(local && server->server_type == SILC_ROUTER ?
3894                      server->local_list->clients :
3895                      server->global_list->clients,
3896                      detached_client->nickname,
3897                      detached_client->id, detached_client, FALSE, NULL);
3898
3899     /* Change the owner of the client */
3900     detached_client->router = server_entry;
3901
3902     silc_free(server_id);
3903   }
3904
3905   silc_free(client_id);
3906 }