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