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