apps/silcd/packet_receive.c

   1 /*
   2
   3   packet_receive.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 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 extern char *server_version;
  29
  30 /* Received notify packet. Server can receive notify packets from router.
  31    Server then relays the notify messages to clients if needed. */
  32
  33 void silc_server_notify(SilcServer server,
  34                         SilcSocketConnection sock,
  35                         SilcPacketContext *packet)
  36 {
  37   SilcNotifyPayload payload;
  38   SilcNotifyType type;
  39   SilcArgumentPayload args;
  40   SilcChannelID *channel_id = NULL, *channel_id2;
  41   SilcClientID *client_id, *client_id2;
  42   SilcServerID *server_id;
  43   SilcChannelEntry channel;
  44   SilcClientEntry client;
  45   SilcServerEntry server_entry;
  46   SilcChannelClientEntry chl;
  47   SilcIDCacheEntry cache;
  48   SilcHashTableList htl;
  49   SilcUInt32 mode;
  50   unsigned char *tmp;
  51   SilcUInt32 tmp_len;
  52   bool local;
  53
  54   SILC_LOG_DEBUG(("Start"));
  55
  56   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
  57       packet->src_id_type != SILC_ID_SERVER)
  58     return;
  59
  60   if (!packet->dst_id)
  61     return;
  62
  63   /* If the packet is destined directly to a client then relay the packet
  64      before processing it. */
  65   if (packet->dst_id_type == SILC_ID_CLIENT) {
  66     SilcIDListData idata;
  67     SilcSocketConnection dst_sock;
  68
  69     /* Get the route to the client */
  70     dst_sock = silc_server_get_client_route(server, packet->dst_id,
  71                                             packet->dst_id_len, NULL, &idata);
  72     if (dst_sock)
  73       /* Relay the packet */
  74       silc_server_relay_packet(server, dst_sock, idata->send_key,
  75                                idata->hmac_receive, 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);
 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);
 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)) {
 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);
 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))
 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);
 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->server_type == SILC_ROUTER)
 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     if (!channel_id) {
 353       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 354                                   packet->dst_id_type);
 355       if (!channel_id)
 356         goto out;
 357     }
 358
 359     /* Get channel entry */
 360     channel = silc_idlist_find_channel_by_id(server->global_list,
 361                                              channel_id, NULL);
 362     if (!channel) {
 363       channel = silc_idlist_find_channel_by_id(server->local_list,
 364                                                channel_id, NULL);
 365       if (!channel) {
 366         silc_free(channel_id);
 367         goto out;
 368       }
 369     }
 370
 371     /* Get the topic */
 372     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 373     if (!tmp) {
 374       silc_free(channel_id);
 375       goto out;
 376     }
 377
 378     silc_free(channel->topic);
 379     channel->topic = strdup(tmp);
 380
 381     /* Send the same notify to the channel */
 382     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 383                                        FALSE, packet->buffer->data,
 384                                        packet->buffer->len, FALSE);
 385     silc_free(channel_id);
 386     break;
 387
 388   case SILC_NOTIFY_TYPE_NICK_CHANGE:
 389     {
 390       /*
 391        * Distribute the notify to local clients on the channel
 392        */
 393       unsigned char *id, *id2;
 394
 395       SILC_LOG_DEBUG(("NICK CHANGE notify"));
 396
 397       /* Get old client ID */
 398       id = silc_argument_get_arg_type(args, 1, &tmp_len);
 399       if (!id)
 400         goto out;
 401       client_id = silc_id_payload_parse_id(id, tmp_len);
 402       if (!client_id)
 403         goto out;
 404
 405       /* Get new client ID */
 406       id2 = silc_argument_get_arg_type(args, 2, &tmp_len);
 407       if (!id2)
 408         goto out;
 409       client_id2 = silc_id_payload_parse_id(id2, tmp_len);
 410       if (!client_id2)
 411         goto out;
 412
 413       SILC_LOG_DEBUG(("Old Client ID id(%s)",
 414                       silc_id_render(client_id, SILC_ID_CLIENT)));
 415       SILC_LOG_DEBUG(("New Client ID id(%s)",
 416                       silc_id_render(client_id2, SILC_ID_CLIENT)));
 417
 418       /* Replace the Client ID */
 419       client = silc_idlist_replace_client_id(server->global_list, client_id,
 420                                              client_id2);
 421       if (!client)
 422         client = silc_idlist_replace_client_id(server->local_list, client_id,
 423                                                client_id2);
 424
 425       if (client) {
 426         /* The nickname is not valid anymore, set it NULL. This causes that
 427            the nickname will be queried if someone wants to know it. */
 428         if (client->nickname)
 429           silc_free(client->nickname);
 430         client->nickname = NULL;
 431
 432         /* Send the NICK_CHANGE notify type to local clients on the channels
 433            this client is joined to. */
 434         silc_server_send_notify_on_channels(server, NULL, client,
 435                                             SILC_NOTIFY_TYPE_NICK_CHANGE, 2,
 436                                             id, tmp_len,
 437                                             id2, tmp_len);
 438       }
 439
 440       silc_free(client_id);
 441       if (!client)
 442         silc_free(client_id2);
 443       break;
 444     }
 445
 446   case SILC_NOTIFY_TYPE_CMODE_CHANGE:
 447     /*
 448      * Distribute the notify to local clients on the channel
 449      */
 450
 451     SILC_LOG_DEBUG(("CMODE CHANGE notify"));
 452
 453     if (!channel_id) {
 454       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 455                                   packet->dst_id_type);
 456       if (!channel_id)
 457         goto out;
 458     }
 459
 460     /* Get channel entry */
 461     channel = silc_idlist_find_channel_by_id(server->global_list,
 462                                              channel_id, NULL);
 463     if (!channel) {
 464       channel = silc_idlist_find_channel_by_id(server->local_list,
 465                                                channel_id, NULL);
 466       if (!channel) {
 467         silc_free(channel_id);
 468         goto out;
 469       }
 470     }
 471
 472     /* Get the mode */
 473     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 474     if (!tmp) {
 475       silc_free(channel_id);
 476       goto out;
 477     }
 478
 479     SILC_GET32_MSB(mode, tmp);
 480
 481     /* Check if mode changed */
 482     if (channel->mode == mode)
 483       break;
 484
 485     /* Send the same notify to the channel */
 486     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 487                                        FALSE, packet->buffer->data,
 488                                        packet->buffer->len, FALSE);
 489
 490     /* If the channel had private keys set and the mode was removed then
 491        we must re-generate and re-distribute a new channel key */
 492     if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
 493         !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
 494       /* Re-generate channel key */
 495       if (!silc_server_create_channel_key(server, channel, 0))
 496         goto out;
 497
 498       /* Send the channel key. This sends it to our local clients and if
 499          we are normal server to our router as well. */
 500       silc_server_send_channel_key(server, NULL, channel,
 501                                    server->server_type == SILC_ROUTER ?
 502                                    FALSE : !server->standalone);
 503     }
 504
 505     /* Change mode */
 506     channel->mode = mode;
 507     silc_free(channel_id);
 508
 509     /* Get the hmac */
 510     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 511     if (tmp) {
 512       unsigned char hash[32];
 513
 514       if (channel->hmac)
 515         silc_hmac_free(channel->hmac);
 516       if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
 517         goto out;
 518
 519       /* Set the HMAC key out of current channel key. The client must do
 520          this locally. */
 521       silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
 522                      channel->key_len / 8,
 523                      hash);
 524       silc_hmac_set_key(channel->hmac, hash,
 525                         silc_hash_len(silc_hmac_get_hash(channel->hmac)));
 526       memset(hash, 0, sizeof(hash));
 527     }
 528
 529     /* Get the passphrase */
 530     tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
 531     if (tmp) {
 532       silc_free(channel->passphrase);
 533       channel->passphrase = strdup(tmp);
 534     }
 535
 536     break;
 537
 538   case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
 539     {
 540       /*
 541        * Distribute the notify to local clients on the channel
 542        */
 543       SilcChannelClientEntry chl2 = NULL;
 544       bool notify_sent = FALSE;
 545
 546       SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
 547
 548       if (!channel_id) {
 549         channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 550                                     packet->dst_id_type);
 551         if (!channel_id)
 552           goto out;
 553       }
 554
 555       /* Get channel entry */
 556       channel = silc_idlist_find_channel_by_id(server->global_list,
 557                                                channel_id, NULL);
 558       if (!channel) {
 559         channel = silc_idlist_find_channel_by_id(server->local_list,
 560                                                  channel_id, NULL);
 561         if (!channel) {
 562           silc_free(channel_id);
 563           goto out;
 564         }
 565       }
 566
 567       /* Get the mode */
 568       tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 569       if (!tmp) {
 570         silc_free(channel_id);
 571         goto out;
 572       }
 573
 574       SILC_GET32_MSB(mode, tmp);
 575
 576       /* Get target client */
 577       tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
 578       if (!tmp)
 579         goto out;
 580       client_id = silc_id_payload_parse_id(tmp, tmp_len);
 581       if (!client_id)
 582         goto out;
 583
 584       /* Get client entry */
 585       client = silc_idlist_find_client_by_id(server->global_list,
 586                                              client_id, TRUE, NULL);
 587       if (!client) {
 588         client = silc_idlist_find_client_by_id(server->local_list,
 589                                                client_id, TRUE, NULL);
 590         if (!client) {
 591           silc_free(client_id);
 592           goto out;
 593         }
 594       }
 595       silc_free(client_id);
 596
 597       /* Get entry to the channel user list */
 598       silc_hash_table_list(channel->user_list, &htl);
 599       while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
 600         /* If the mode is channel founder and we already find a client
 601            to have that mode on the channel we will enforce the sender
 602            to change the channel founder mode away. There can be only one
 603            channel founder on the channel. */
 604         if (server->server_type == SILC_ROUTER &&
 605             mode & SILC_CHANNEL_UMODE_CHANFO &&
 606             chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
 607           SilcBuffer idp;
 608           unsigned char cumode[4];
 609
 610           if (chl->client == client && chl->mode == mode) {
 611             notify_sent = TRUE;
 612             break;
 613           }
 614
 615           mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 616           silc_server_send_notify_cumode(server, sock, FALSE, channel, mode,
 617                                          client->id, SILC_ID_CLIENT,
 618                                          client->id);
 619
 620           idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
 621           SILC_PUT32_MSB(mode, cumode);
 622           silc_server_send_notify_to_channel(server, sock, channel, FALSE,
 623                                              SILC_NOTIFY_TYPE_CUMODE_CHANGE,
 624                                              3, idp->data, idp->len,
 625                                              cumode, 4,
 626                                              idp->data, idp->len);
 627           silc_buffer_free(idp);
 628           notify_sent = TRUE;
 629
 630           /* Force the mode change if we alredy set the mode */
 631           if (chl2) {
 632             chl2->mode = mode;
 633             silc_free(channel_id);
 634             silc_hash_table_list_reset(&htl);
 635             goto out;
 636           }
 637         }
 638
 639         if (chl->client == client) {
 640           if (chl->mode == mode) {
 641             notify_sent = TRUE;
 642             break;
 643           }
 644
 645           SILC_LOG_DEBUG(("Changing the channel user mode"));
 646
 647           /* Change the mode */
 648           chl->mode = mode;
 649           if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
 650             break;
 651
 652           chl2 = chl;
 653         }
 654       }
 655       silc_hash_table_list_reset(&htl);
 656
 657       /* Send the same notify to the channel */
 658       if (!notify_sent)
 659         silc_server_packet_send_to_channel(server, sock, channel,
 660                                            packet->type,
 661                                            FALSE, packet->buffer->data,
 662                                            packet->buffer->len, FALSE);
 663
 664       silc_free(channel_id);
 665       break;
 666     }
 667
 668   case SILC_NOTIFY_TYPE_INVITE:
 669
 670     if (packet->dst_id_type == SILC_ID_CLIENT)
 671       goto out;
 672
 673     SILC_LOG_DEBUG(("INVITE notify"));
 674
 675     /* Get Channel ID */
 676     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 677     if (!tmp)
 678       goto out;
 679     channel_id = silc_id_payload_parse_id(tmp, tmp_len);
 680     if (!channel_id)
 681       goto out;
 682
 683     /* Get channel entry */
 684     channel = silc_idlist_find_channel_by_id(server->global_list,
 685                                              channel_id, NULL);
 686     if (!channel) {
 687       channel = silc_idlist_find_channel_by_id(server->local_list,
 688                                                channel_id, NULL);
 689       if (!channel) {
 690         silc_free(channel_id);
 691         goto out;
 692       }
 693     }
 694     silc_free(channel_id);
 695
 696     /* Get the added invite */
 697     tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
 698     if (tmp) {
 699       if (!channel->invite_list)
 700         channel->invite_list = silc_calloc(tmp_len + 2,
 701                                            sizeof(*channel->invite_list));
 702       else
 703         channel->invite_list = silc_realloc(channel->invite_list,
 704                                             sizeof(*channel->invite_list) *
 705                                             (tmp_len +
 706                                              strlen(channel->invite_list) +
 707                                              2));
 708       if (tmp[tmp_len - 1] == ',')
 709         tmp[tmp_len - 1] = '\0';
 710
 711       strncat(channel->invite_list, tmp, tmp_len);
 712       strncat(channel->invite_list, ",", 1);
 713     }
 714
 715     /* Get the deleted invite */
 716     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 717     if (tmp && channel->invite_list) {
 718       char *start, *end, *n;
 719
 720       if (!strncmp(channel->invite_list, tmp,
 721                    strlen(channel->invite_list) - 1)) {
 722         silc_free(channel->invite_list);
 723         channel->invite_list = NULL;
 724       } else {
 725         start = strstr(channel->invite_list, tmp);
 726         if (start && strlen(start) >= tmp_len) {
 727           end = start + tmp_len;
 728           n = silc_calloc(strlen(channel->invite_list) - tmp_len, sizeof(*n));
 729           strncat(n, channel->invite_list, start - channel->invite_list);
 730           strncat(n, end + 1, ((channel->invite_list +
 731                                 strlen(channel->invite_list)) - end) - 1);
 732           silc_free(channel->invite_list);
 733           channel->invite_list = n;
 734         }
 735       }
 736     }
 737
 738     break;
 739
 740   case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
 741     /*
 742      * Distribute to the local clients on the channel and change the
 743      * channel ID.
 744      */
 745
 746     SILC_LOG_DEBUG(("CHANNEL CHANGE"));
 747
 748     if (sock->type != SILC_SOCKET_TYPE_ROUTER)
 749       break;
 750
 751     /* Get the old Channel ID */
 752     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 753     if (!tmp)
 754       goto out;
 755     channel_id = silc_id_payload_parse_id(tmp, tmp_len);
 756     if (!channel_id)
 757       goto out;
 758
 759     /* Get the channel entry */
 760     channel = silc_idlist_find_channel_by_id(server->local_list,
 761                                              channel_id, NULL);
 762     if (!channel) {
 763       channel = silc_idlist_find_channel_by_id(server->global_list,
 764                                                channel_id, NULL);
 765       if (!channel) {
 766         silc_free(channel_id);
 767         goto out;
 768       }
 769     }
 770
 771     /* Send the notify to the channel */
 772     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 773                                        FALSE, packet->buffer->data,
 774                                        packet->buffer->len, FALSE);
 775
 776     /* Get the new Channel ID */
 777     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 778     if (!tmp)
 779       goto out;
 780     channel_id2 = silc_id_payload_parse_id(tmp, tmp_len);
 781     if (!channel_id2)
 782       goto out;
 783
 784     SILC_LOG_DEBUG(("Old Channel ID id(%s)",
 785                     silc_id_render(channel_id, SILC_ID_CHANNEL)));
 786     SILC_LOG_DEBUG(("New Channel ID id(%s)",
 787                     silc_id_render(channel_id2, SILC_ID_CHANNEL)));
 788
 789     /* Replace the Channel ID */
 790     if (!silc_idlist_replace_channel_id(server->local_list, channel_id,
 791                                         channel_id2))
 792       if (!silc_idlist_replace_channel_id(server->global_list, channel_id,
 793                                           channel_id2)) {
 794         silc_free(channel_id2);
 795         channel_id2 = NULL;
 796       }
 797
 798     if (channel_id2) {
 799       SilcBuffer users = NULL, users_modes = NULL;
 800
 801       /* Re-announce this channel which ID was changed. */
 802       silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
 803                                    channel->id,
 804                                    silc_id_get_len(channel->id,
 805                                                    SILC_ID_CHANNEL),
 806                                    channel->mode);
 807
 808       /* Re-announce our clients on the channel as the ID has changed now */
 809       silc_server_announce_get_channel_users(server, channel, &users,
 810                                              &users_modes);
 811       if (users) {
 812         silc_buffer_push(users, users->data - users->head);
 813         silc_server_packet_send(server, sock,
 814                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
 815                                 users->data, users->len, FALSE);
 816         silc_buffer_free(users);
 817       }
 818       if (users_modes) {
 819         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
 820         silc_server_packet_send_dest(server, sock,
 821                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
 822                                      channel->id, SILC_ID_CHANNEL,
 823                                      users_modes->data,
 824                                      users_modes->len, FALSE);
 825         silc_buffer_free(users_modes);
 826       }
 827
 828       /* Re-announce channel's topic */
 829       if (channel->topic) {
 830         silc_server_send_notify_topic_set(server, sock,
 831                                           server->server_type == SILC_ROUTER ?
 832                                           TRUE : FALSE, channel,
 833                                           channel->id, SILC_ID_CHANNEL,
 834                                           channel->topic);
 835       }
 836     }
 837
 838     silc_free(channel_id);
 839
 840     break;
 841
 842   case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
 843     /*
 844      * Remove the server entry and all clients that this server owns.
 845      */
 846
 847     SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
 848
 849     /* Get Server ID */
 850     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 851     if (!tmp)
 852       goto out;
 853     server_id = silc_id_payload_parse_id(tmp, tmp_len);
 854     if (!server_id)
 855       goto out;
 856
 857     /* Get server entry */
 858     server_entry = silc_idlist_find_server_by_id(server->global_list,
 859                                                  server_id, TRUE, NULL);
 860     local = TRUE;
 861     if (!server_entry) {
 862       server_entry = silc_idlist_find_server_by_id(server->local_list,
 863                                                    server_id, TRUE, NULL);
 864       local = TRUE;
 865       if (!server_entry) {
 866         /* If we are normal server then we might not have the server. Check
 867            whether router was kind enough to send the list of all clients
 868            that actually was to be removed. Remove them if the list is
 869            available. */
 870         if (server->server_type != SILC_ROUTER &&
 871             silc_argument_get_arg_num(args) > 1) {
 872           int i;
 873
 874           for (i = 1; i < silc_argument_get_arg_num(args); i++) {
 875             /* Get Client ID */
 876             tmp = silc_argument_get_arg_type(args, i + 1, &tmp_len);
 877             if (!tmp)
 878               continue;
 879             client_id = silc_id_payload_parse_id(tmp, tmp_len);
 880             if (!client_id)
 881               continue;
 882
 883             /* Get client entry */
 884             client = silc_idlist_find_client_by_id(server->global_list,
 885                                                    client_id, TRUE, &cache);
 886             local = TRUE;
 887             if (!client) {
 888               client = silc_idlist_find_client_by_id(server->local_list,
 889                                                      client_id, TRUE, &cache);
 890               local = FALSE;
 891               if (!client) {
 892                 silc_free(client_id);
 893                 continue;
 894               }
 895             }
 896             silc_free(client_id);
 897
 898             /* Update statistics */
 899             server->stat.clients--;
 900             if (server->server_type == SILC_ROUTER)
 901               server->stat.cell_clients--;
 902             SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
 903             SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
 904
 905             /* Remove the client from all channels. */
 906             silc_server_remove_from_channels(server, NULL, client,
 907                                              TRUE, NULL, FALSE);
 908
 909             /* Remove the client */
 910             silc_idlist_del_client(local ? server->local_list :
 911                                    server->global_list, client);
 912           }
 913         }
 914
 915         silc_free(server_id);
 916         goto out;
 917       }
 918     }
 919     silc_free(server_id);
 920
 921     /* Free all client entries that this server owns as they will
 922        become invalid now as well. */
 923     silc_server_remove_clients_by_server(server, server_entry, TRUE);
 924
 925     /* Remove the server entry */
 926     silc_idlist_del_server(local ? server->local_list :
 927                            server->global_list, server_entry);
 928
 929     /* XXX update statistics */
 930
 931     break;
 932
 933   case SILC_NOTIFY_TYPE_KICKED:
 934     /*
 935      * Distribute the notify to local clients on the channel
 936      */
 937
 938     SILC_LOG_DEBUG(("KICKED notify"));
 939
 940     if (!channel_id) {
 941       channel_id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
 942                                   packet->dst_id_type);
 943       if (!channel_id)
 944         goto out;
 945     }
 946
 947     /* Get channel entry */
 948     channel = silc_idlist_find_channel_by_id(server->global_list,
 949                                              channel_id, NULL);
 950     if (!channel) {
 951       channel = silc_idlist_find_channel_by_id(server->local_list,
 952                                                channel_id, NULL);
 953       if (!channel) {
 954         silc_free(channel_id);
 955         goto out;
 956       }
 957     }
 958     silc_free(channel_id);
 959
 960     /* Get client ID */
 961     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 962     if (!tmp)
 963       goto out;
 964     client_id = silc_id_payload_parse_id(tmp, tmp_len);
 965     if (!client_id)
 966       goto out;
 967
 968     /* If the the client is not in local list we check global list */
 969     client = silc_idlist_find_client_by_id(server->global_list,
 970                                            client_id, TRUE, NULL);
 971     if (!client) {
 972       client = silc_idlist_find_client_by_id(server->local_list,
 973                                              client_id, TRUE, NULL);
 974       if (!client) {
 975         silc_free(client_id);
 976         goto out;
 977       }
 978     }
 979
 980     /* Send to channel */
 981     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 982                                        FALSE, packet->buffer->data,
 983                                        packet->buffer->len, FALSE);
 984
 985     /* Remove the client from channel */
 986     silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
 987
 988     break;
 989
 990   case SILC_NOTIFY_TYPE_KILLED:
 991     {
 992       /*
 993        * Distribute the notify to local clients on channels
 994        */
 995       unsigned char *id;
 996       SilcUInt32 id_len;
 997
 998       SILC_LOG_DEBUG(("KILLED notify"));
 999
1000       /* Get client ID */
1001       id = silc_argument_get_arg_type(args, 1, &id_len);
1002       if (!id)
1003         goto out;
1004       client_id = silc_id_payload_parse_id(id, id_len);
1005       if (!client_id)
1006         goto out;
1007
1008       /* If the the client is not in local list we check global list */
1009       client = silc_idlist_find_client_by_id(server->global_list,
1010                                              client_id, TRUE, NULL);
1011       if (!client) {
1012         client = silc_idlist_find_client_by_id(server->local_list,
1013                                                client_id, TRUE, NULL);
1014         if (!client) {
1015           silc_free(client_id);
1016           goto out;
1017         }
1018       }
1019       silc_free(client_id);
1020
1021       /* If the client is one of ours, then close the connection to the
1022          client now. This removes the client from all channels as well. */
1023       if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1024         sock = client->connection;
1025         silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1026         silc_server_close_connection(server, sock);
1027         break;
1028       }
1029
1030       /* Get comment */
1031       tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1032       if (tmp_len > 128)
1033         tmp = NULL;
1034
1035       /* Send the notify to local clients on the channels except to the
1036          client who is killed. */
1037       silc_server_send_notify_on_channels(server, client, client,
1038                                           SILC_NOTIFY_TYPE_KILLED,
1039                                           tmp ? 2 : 1,
1040                                           id, id_len,
1041                                           tmp, tmp_len);
1042
1043       /* Remove the client from all channels */
1044       silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1045                                        FALSE);
1046
1047       break;
1048     }
1049
1050   case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1051     /*
1052      * Save the mode of the client.
1053      */
1054
1055     SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1056
1057     /* Get client ID */
1058     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1059     if (!tmp)
1060       goto out;
1061     client_id = silc_id_payload_parse_id(tmp, tmp_len);
1062     if (!client_id)
1063       goto out;
1064
1065     /* Get client entry */
1066     client = silc_idlist_find_client_by_id(server->global_list,
1067                                            client_id, TRUE, NULL);
1068     if (!client) {
1069       client = silc_idlist_find_client_by_id(server->local_list,
1070                                              client_id, TRUE, NULL);
1071       if (!client) {
1072         silc_free(client_id);
1073         goto out;
1074       }
1075     }
1076     silc_free(client_id);
1077
1078     /* Get the mode */
1079     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1080     if (!tmp)
1081       goto out;
1082     SILC_GET32_MSB(mode, tmp);
1083
1084 #define SILC_UMODE_STATS_UPDATE(oper, mod)      \
1085 do {                                            \
1086     if (client->mode & (mod)) {                 \
1087       if (!(mode & (mod))) {                    \
1088         if (client->connection)                 \
1089           server->stat.my_ ## oper ## _ops--;   \
1090         if (server->server_type == SILC_ROUTER) \
1091           server->stat. oper ## _ops--;         \
1092       }                                         \
1093     } else {                                    \
1094       if (mode & (mod)) {                       \
1095         if (client->connection)                 \
1096           server->stat.my_ ## oper ## _ops++;   \
1097         if (server->server_type == SILC_ROUTER) \
1098           server->stat. oper ## _ops++;         \
1099       }                                         \
1100     }                                           \
1101 } while(0)
1102
1103     /* Update statistics */
1104     SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1105     SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1106
1107     /* Save the mode */
1108     client->mode = mode;
1109
1110     break;
1111
1112   case SILC_NOTIFY_TYPE_BAN:
1113     /*
1114      * Save the ban
1115      */
1116
1117     SILC_LOG_DEBUG(("BAN notify"));
1118
1119     /* Get Channel ID */
1120     tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1121     if (!tmp)
1122       goto out;
1123     channel_id = silc_id_payload_parse_id(tmp, tmp_len);
1124     if (!channel_id)
1125       goto out;
1126
1127     /* Get channel entry */
1128     channel = silc_idlist_find_channel_by_id(server->global_list,
1129                                              channel_id, NULL);
1130     if (!channel) {
1131       channel = silc_idlist_find_channel_by_id(server->local_list,
1132                                                channel_id, NULL);
1133       if (!channel) {
1134         silc_free(channel_id);
1135         goto out;
1136       }
1137     }
1138     silc_free(channel_id);
1139
1140     /* Get the new ban and add it to the ban list */
1141     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1142     if (tmp) {
1143       if (!channel->ban_list)
1144         channel->ban_list = silc_calloc(tmp_len + 2,
1145                                         sizeof(*channel->ban_list));
1146       else
1147         channel->ban_list = silc_realloc(channel->ban_list,
1148                                          sizeof(*channel->ban_list) *
1149                                          (tmp_len +
1150                                           strlen(channel->ban_list) + 2));
1151       strncat(channel->ban_list, tmp, tmp_len);
1152       strncat(channel->ban_list, ",", 1);
1153     }
1154
1155     /* Get the ban to be removed and remove it from the list */
1156     tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1157     if (tmp && channel->ban_list) {
1158       char *start, *end, *n;
1159
1160       if (!strncmp(channel->ban_list, tmp, strlen(channel->ban_list) - 1)) {
1161         silc_free(channel->ban_list);
1162         channel->ban_list = NULL;
1163       } else {
1164         start = strstr(channel->ban_list, tmp);
1165         if (start && strlen(start) >= tmp_len) {
1166           end = start + tmp_len;
1167           n = silc_calloc(strlen(channel->ban_list) - tmp_len, sizeof(*n));
1168           strncat(n, channel->ban_list, start - channel->ban_list);
1169           strncat(n, end + 1, ((channel->ban_list +
1170                                 strlen(channel->ban_list)) - end) - 1);
1171           silc_free(channel->ban_list);
1172           channel->ban_list = n;
1173         }
1174       }
1175     }
1176     break;
1177
1178     /* Ignore rest of the notify types for now */
1179   case SILC_NOTIFY_TYPE_NONE:
1180   case SILC_NOTIFY_TYPE_MOTD:
1181     break;
1182   default:
1183     break;
1184   }
1185
1186  out:
1187   silc_notify_payload_free(payload);
1188 }
1189
1190 void silc_server_notify_list(SilcServer server,
1191                              SilcSocketConnection sock,
1192                              SilcPacketContext *packet)
1193 {
1194   SilcPacketContext *new;
1195   SilcBuffer buffer;
1196   SilcUInt16 len;
1197
1198   SILC_LOG_DEBUG(("Processing Notify List"));
1199
1200   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1201       packet->src_id_type != SILC_ID_SERVER)
1202     return;
1203
1204   /* Make copy of the original packet context, except for the actual
1205      data buffer, which we will here now fetch from the original buffer. */
1206   new = silc_packet_context_alloc();
1207   new->type = SILC_PACKET_NOTIFY;
1208   new->flags = packet->flags;
1209   new->src_id = packet->src_id;
1210   new->src_id_len = packet->src_id_len;
1211   new->src_id_type = packet->src_id_type;
1212   new->dst_id = packet->dst_id;
1213   new->dst_id_len = packet->dst_id_len;
1214   new->dst_id_type = packet->dst_id_type;
1215
1216   buffer = silc_buffer_alloc(1024);
1217   new->buffer = buffer;
1218
1219   while (packet->buffer->len) {
1220     SILC_GET16_MSB(len, packet->buffer->data + 2);
1221     if (len > packet->buffer->len)
1222       break;
1223
1224     if (len > buffer->truelen) {
1225       silc_buffer_free(buffer);
1226       buffer = silc_buffer_alloc(1024 + len);
1227     }
1228
1229     silc_buffer_pull_tail(buffer, len);
1230     silc_buffer_put(buffer, packet->buffer->data, len);
1231
1232     /* Process the Notify */
1233     silc_server_notify(server, sock, new);
1234
1235     silc_buffer_push_tail(buffer, len);
1236     silc_buffer_pull(packet->buffer, len);
1237   }
1238
1239   silc_buffer_free(buffer);
1240   silc_free(new);
1241 }
1242
1243 /* Received private message. This resolves the destination of the message
1244    and sends the packet. This is used by both server and router.  If the
1245    destination is our locally connected client this sends the packet to
1246    the client. This may also send the message for further routing if
1247    the destination is not in our server (or router). */
1248
1249 void silc_server_private_message(SilcServer server,
1250                                  SilcSocketConnection sock,
1251                                  SilcPacketContext *packet)
1252 {
1253   SilcSocketConnection dst_sock;
1254   SilcIDListData idata;
1255
1256   SILC_LOG_DEBUG(("Start"));
1257
1258   if (packet->src_id_type != SILC_ID_CLIENT ||
1259       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1260     return;
1261
1262   /* Get the route to the client */
1263   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1264                                           packet->dst_id_len, NULL, &idata);
1265   if (!dst_sock) {
1266     /* Send IDENTIFY command reply with error status to indicate that
1267        such destination ID does not exist or is invalid */
1268     SilcBuffer idp = silc_id_payload_encode_data(packet->dst_id,
1269                                                  packet->dst_id_len,
1270                                                  packet->dst_id_type);
1271     if (!idp)
1272       return;
1273
1274     if (packet->src_id_type == SILC_ID_CLIENT) {
1275       SilcClientID *client_id = silc_id_str2id(packet->src_id,
1276                                                packet->src_id_len,
1277                                                packet->src_id_type);
1278       silc_server_send_dest_command_reply(server, sock,
1279                                           client_id, SILC_ID_CLIENT,
1280                                           SILC_COMMAND_IDENTIFY,
1281                                           SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1282                                           0, 1, 2, idp->data, idp->len);
1283       silc_free(client_id);
1284     } else {
1285       silc_server_send_command_reply(server, sock, SILC_COMMAND_IDENTIFY,
1286                                      SILC_STATUS_ERR_NO_SUCH_CLIENT_ID,
1287                                      0, 1, 2, idp->data, idp->len);
1288     }
1289
1290     silc_buffer_free(idp);
1291     return;
1292   }
1293
1294   /* Send the private message */
1295   silc_server_send_private_message(server, dst_sock, idata->send_key,
1296                                    idata->hmac_send, idata->psn_send++,
1297                                    packet);
1298 }
1299
1300 /* Received private message key packet.. This packet is never for us. It is to
1301    the client in the packet's destination ID. Sending of this sort of packet
1302    equals sending private message, ie. it is sent point to point from
1303    one client to another. */
1304
1305 void silc_server_private_message_key(SilcServer server,
1306                                      SilcSocketConnection sock,
1307                                      SilcPacketContext *packet)
1308 {
1309   SilcSocketConnection dst_sock;
1310   SilcIDListData idata;
1311
1312   SILC_LOG_DEBUG(("Start"));
1313
1314   if (packet->src_id_type != SILC_ID_CLIENT ||
1315       packet->dst_id_type != SILC_ID_CLIENT)
1316     return;
1317
1318   if (!packet->dst_id)
1319     return;
1320
1321   /* Get the route to the client */
1322   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1323                                           packet->dst_id_len, NULL, &idata);
1324   if (!dst_sock)
1325     return;
1326
1327   /* Relay the packet */
1328   silc_server_relay_packet(server, dst_sock, idata->send_key,
1329                            idata->hmac_send, idata->psn_send++, packet, FALSE);
1330 }
1331
1332 /* Processes incoming command reply packet. The command reply packet may
1333    be destined to one of our clients or it may directly for us. We will
1334    call the command reply routine after processing the packet. */
1335
1336 void silc_server_command_reply(SilcServer server,
1337                                SilcSocketConnection sock,
1338                                SilcPacketContext *packet)
1339 {
1340   SilcBuffer buffer = packet->buffer;
1341   SilcClientEntry client = NULL;
1342   SilcSocketConnection dst_sock;
1343   SilcIDListData idata;
1344   SilcClientID *id = NULL;
1345
1346   SILC_LOG_DEBUG(("Start"));
1347
1348   /* Source must be server or router */
1349   if (packet->src_id_type != SILC_ID_SERVER &&
1350       sock->type != SILC_SOCKET_TYPE_ROUTER)
1351     return;
1352
1353   if (packet->dst_id_type == SILC_ID_CHANNEL)
1354     return;
1355
1356   if (packet->dst_id_type == SILC_ID_CLIENT) {
1357     /* Destination must be one of ours */
1358     id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT);
1359     if (!id)
1360       return;
1361     client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
1362     if (!client) {
1363       SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1364       silc_free(id);
1365       return;
1366     }
1367   }
1368
1369   if (packet->dst_id_type == SILC_ID_SERVER) {
1370     /* For now this must be for us */
1371     if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1372       SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1373       return;
1374     }
1375   }
1376
1377   /* Execute command reply locally for the command */
1378   silc_server_command_reply_process(server, sock, buffer);
1379
1380   if (packet->dst_id_type == SILC_ID_CLIENT && client && id) {
1381     /* Relay the packet to the client */
1382
1383     dst_sock = (SilcSocketConnection)client->connection;
1384     silc_buffer_push(buffer, SILC_PACKET_HEADER_LEN + packet->src_id_len
1385                      + packet->dst_id_len + packet->padlen);
1386
1387     silc_packet_send_prepare(dst_sock, 0, 0, buffer->len);
1388     silc_buffer_put(dst_sock->outbuf, buffer->data, buffer->len);
1389
1390     idata = (SilcIDListData)client;
1391
1392     /* Encrypt packet */
1393     silc_packet_encrypt(idata->send_key, idata->hmac_send, idata->psn_send++,
1394                         dst_sock->outbuf, buffer->len);
1395
1396     /* Send the packet */
1397     silc_server_packet_send_real(server, dst_sock, TRUE);
1398
1399     silc_free(id);
1400   }
1401 }
1402
1403 /* Process received channel message. The message can be originated from
1404    client or server. */
1405
1406 void silc_server_channel_message(SilcServer server,
1407                                  SilcSocketConnection sock,
1408                                  SilcPacketContext *packet)
1409 {
1410   SilcChannelEntry channel = NULL;
1411   SilcChannelID *id = NULL;
1412   void *sender = NULL;
1413   void *sender_entry = NULL;
1414   bool local = TRUE;
1415
1416   SILC_LOG_DEBUG(("Processing channel message"));
1417
1418   /* Sanity checks */
1419   if (packet->dst_id_type != SILC_ID_CHANNEL) {
1420     SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1421     goto out;
1422   }
1423
1424   /* Find channel entry */
1425   id = silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL);
1426   if (!id)
1427     goto out;
1428   channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
1429   if (!channel) {
1430     channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
1431     if (!channel) {
1432       SILC_LOG_DEBUG(("Could not find channel"));
1433       goto out;
1434     }
1435   }
1436
1437   /* See that this client is on the channel. If the original sender is
1438      not client (as it can be server as well) we don't do the check. */
1439   sender = silc_id_str2id(packet->src_id, packet->src_id_len,
1440                           packet->src_id_type);
1441   if (!sender)
1442     goto out;
1443   if (packet->src_id_type == SILC_ID_CLIENT) {
1444     sender_entry = silc_idlist_find_client_by_id(server->local_list,
1445                                                  sender, TRUE, NULL);
1446     if (!sender_entry) {
1447       local = FALSE;
1448       sender_entry = silc_idlist_find_client_by_id(server->global_list,
1449                                                    sender, TRUE, NULL);
1450     }
1451     if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1452                                                         channel)) {
1453       SILC_LOG_DEBUG(("Client not on channel"));
1454       goto out;
1455     }
1456
1457     /* If the packet is coming from router, but the client entry is
1458        local entry to us then some router is rerouting this to us and it is
1459        not allowed. */
1460     if (server->server_type == SILC_ROUTER &&
1461         sock->type == SILC_SOCKET_TYPE_ROUTER && local) {
1462       SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
1463       goto out;
1464     }
1465   }
1466
1467   /* Distribute the packet to our local clients. This will send the
1468      packet for further routing as well, if needed. */
1469   silc_server_packet_relay_to_channel(server, sock, channel, sender,
1470                                       packet->src_id_type, sender_entry,
1471                                       packet->buffer->data,
1472                                       packet->buffer->len, FALSE);
1473
1474  out:
1475   if (sender)
1476     silc_free(sender);
1477   if (id)
1478     silc_free(id);
1479 }
1480
1481 /* Received channel key packet. We distribute the key to all of our locally
1482    connected clients on the channel. */
1483
1484 void silc_server_channel_key(SilcServer server,
1485                              SilcSocketConnection sock,
1486                              SilcPacketContext *packet)
1487 {
1488   SilcBuffer buffer = packet->buffer;
1489   SilcChannelEntry channel;
1490
1491   if (packet->src_id_type != SILC_ID_SERVER ||
1492       (server->server_type == SILC_ROUTER &&
1493        sock->type == SILC_SOCKET_TYPE_ROUTER))
1494     return;
1495
1496   /* Save the channel key */
1497   channel = silc_server_save_channel_key(server, buffer, NULL);
1498   if (!channel)
1499     return;
1500
1501   /* Distribute the key to everybody who is on the channel. If we are router
1502      we will also send it to locally connected servers. */
1503   silc_server_send_channel_key(server, sock, channel, FALSE);
1504
1505   if (server->server_type != SILC_BACKUP_ROUTER) {
1506     /* Distribute to local cell backup routers. */
1507     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
1508                             SILC_PACKET_CHANNEL_KEY, 0,
1509                             buffer->data, buffer->len, FALSE, TRUE);
1510   }
1511 }
1512
1513 /* Received New Client packet and processes it.  Creates Client ID for the
1514    client. Client becomes registered after calling this functions. */
1515
1516 SilcClientEntry silc_server_new_client(SilcServer server,
1517                                        SilcSocketConnection sock,
1518                                        SilcPacketContext *packet)
1519 {
1520   SilcBuffer buffer = packet->buffer;
1521   SilcClientEntry client;
1522   SilcClientID *client_id;
1523   SilcBuffer reply;
1524   SilcIDListData idata;
1525   char *username = NULL, *realname = NULL, *id_string;
1526   SilcUInt16 username_len;
1527   SilcUInt32 id_len;
1528   int ret;
1529   char *hostname, *nickname;
1530   int nickfail = 0;
1531
1532   SILC_LOG_DEBUG(("Creating new client"));
1533
1534   if (sock->type != SILC_SOCKET_TYPE_CLIENT)
1535     return NULL;
1536
1537   /* Take client entry */
1538   client = (SilcClientEntry)sock->user_data;
1539   idata = (SilcIDListData)client;
1540
1541   /* Remove the old cache entry. */
1542   if (!silc_idcache_del_by_context(server->local_list->clients, client)) {
1543     SILC_LOG_ERROR(("Lost client's cache entry - report a bug"));
1544     silc_server_disconnect_remote(server, sock, "Server closed connection: "
1545                                   "Unknown client");
1546     return NULL;
1547   }
1548
1549   /* Parse incoming packet */
1550   ret = silc_buffer_unformat(buffer,
1551                              SILC_STR_UI16_NSTRING_ALLOC(&username,
1552                                                          &username_len),
1553                              SILC_STR_UI16_STRING_ALLOC(&realname),
1554                              SILC_STR_END);
1555   if (ret == -1) {
1556     silc_free(username);
1557     silc_free(realname);
1558     SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1559                     "connection", sock->hostname, sock->ip));
1560     silc_server_disconnect_remote(server, sock, "Server closed connection: "
1561                                   "Incomplete client information");
1562     return NULL;
1563   }
1564
1565   if (!username) {
1566     silc_free(username);
1567     silc_free(realname);
1568     SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
1569                     "connection", sock->hostname, sock->ip));
1570     silc_server_disconnect_remote(server, sock, "Server closed connection: "
1571                                   "Incomplete client information");
1572     return NULL;
1573   }
1574
1575   if (username_len > 128)
1576     username[128] = '\0';
1577
1578   /* Check for bad characters for nickname, and modify the nickname if
1579      it includes those. */
1580   if (silc_server_name_bad_chars(username, username_len)) {
1581     nickname = silc_server_name_modify_bad(username, username_len);
1582   } else {
1583     nickname = strdup(username);
1584   }
1585
1586   /* Make sanity checks for the hostname of the client. If the hostname
1587      is provided in the `username' check that it is the same than the
1588      resolved hostname, or if not resolved the hostname that appears in
1589      the client's public key. If the hostname is not present then put
1590      it from the resolved name or from the public key. */
1591   if (strchr(username, '@')) {
1592     SilcPublicKeyIdentifier pident;
1593     int tlen = strcspn(username, "@");
1594     char *phostname = NULL;
1595
1596     hostname = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
1597
1598     if (strcmp(sock->hostname, sock->ip) &&
1599         strcmp(sock->hostname, hostname)) {
1600       silc_free(username);
1601       silc_free(hostname);
1602       silc_free(realname);
1603       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1604                       "connection", sock->hostname, sock->ip));
1605       silc_server_disconnect_remote(server, sock,
1606                                     "Server closed connection: "
1607                                     "Incomplete client information");
1608       return NULL;
1609     }
1610
1611     pident = silc_pkcs_decode_identifier(client->data.public_key->identifier);
1612     if (pident) {
1613       phostname = strdup(pident->host);
1614       silc_pkcs_free_identifier(pident);
1615     }
1616
1617     if (!strcmp(sock->hostname, sock->ip) &&
1618         phostname && strcmp(phostname, hostname)) {
1619       silc_free(username);
1620       silc_free(hostname);
1621       silc_free(phostname);
1622       silc_free(realname);
1623       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
1624                       "connection", sock->hostname, sock->ip));
1625       silc_server_disconnect_remote(server, sock,
1626                                     "Server closed connection: "
1627                                     "Incomplete client information");
1628       return NULL;
1629     }
1630
1631     silc_free(phostname);
1632   } else {
1633     /* The hostname is not present, add it. */
1634     char *newusername;
1635     /* XXX For now we cannot take the host name from the public key since
1636        they are not trusted or we cannot verify them as trusted. Just take
1637        what the resolved name or address is. */
1638 #if 0
1639     if (strcmp(sock->hostname, sock->ip)) {
1640 #endif
1641       newusername = silc_calloc(strlen(username) +
1642                                 strlen(sock->hostname) + 2,
1643                                 sizeof(*newusername));
1644       strncat(newusername, username, strlen(username));
1645       strncat(newusername, "@", 1);
1646       strncat(newusername, sock->hostname, strlen(sock->hostname));
1647       silc_free(username);
1648       username = newusername;
1649 #if 0
1650     } else {
1651       SilcPublicKeyIdentifier pident =
1652         silc_pkcs_decode_identifier(client->data.public_key->identifier);
1653
1654       if (pident) {
1655         newusername = silc_calloc(strlen(username) +
1656                                   strlen(pident->host) + 2,
1657                                   sizeof(*newusername));
1658         strncat(newusername, username, strlen(username));
1659         strncat(newusername, "@", 1);
1660         strncat(newusername, pident->host, strlen(pident->host));
1661         silc_free(username);
1662         username = newusername;
1663         silc_pkcs_free_identifier(pident);
1664       }
1665     }
1666 #endif
1667   }
1668
1669   /* Create Client ID */
1670   while (!silc_id_create_client_id(server, server->id, server->rng,
1671                                    server->md5hash, nickname, &client_id)) {
1672     nickfail++;
1673     snprintf(&nickname[strlen(nickname) - 1], 1, "%d", nickfail);
1674   }
1675
1676   /* Update client entry */
1677   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1678   client->nickname = nickname;
1679   client->username = username;
1680   client->userinfo = realname ? realname : strdup(" ");
1681   client->id = client_id;
1682   id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
1683
1684   /* Add the client again to the ID cache */
1685   silc_idcache_add(server->local_list->clients, client->nickname,
1686                    client_id, client, 0, NULL);
1687
1688   /* Notify our router about new client on the SILC network */
1689   if (!server->standalone)
1690     silc_server_send_new_id(server, (SilcSocketConnection)
1691                             server->router->connection,
1692                             server->server_type == SILC_ROUTER ? TRUE : FALSE,
1693                             client->id, SILC_ID_CLIENT, id_len);
1694
1695   /* Send the new client ID to the client. */
1696   id_string = silc_id_id2str(client->id, SILC_ID_CLIENT);
1697   reply = silc_buffer_alloc(2 + 2 + id_len);
1698   silc_buffer_pull_tail(reply, SILC_BUFFER_END(reply));
1699   silc_buffer_format(reply,
1700                      SILC_STR_UI_SHORT(SILC_ID_CLIENT),
1701                      SILC_STR_UI_SHORT(id_len),
1702                      SILC_STR_UI_XNSTRING(id_string, id_len),
1703                      SILC_STR_END);
1704   silc_server_packet_send(server, sock, SILC_PACKET_NEW_ID, 0,
1705                           reply->data, reply->len, FALSE);
1706   silc_free(id_string);
1707   silc_buffer_free(reply);
1708
1709   /* Send some nice info to the client */
1710   SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1711                           ("Welcome to the SILC Network %s",
1712                            username));
1713   SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1714                           ("Your host is %s, running version %s",
1715                            server->config->server_info->server_name,
1716                            server_version));
1717   if (server->server_type == SILC_ROUTER) {
1718     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1719                             ("There are %d clients on %d servers in SILC "
1720                              "Network", server->stat.clients,
1721                              server->stat.servers + 1));
1722     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1723                             ("There are %d clients on %d server in our cell",
1724                              server->stat.cell_clients,
1725                              server->stat.cell_servers + 1));
1726     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1727                             ("I have %d clients, %d channels, %d servers and "
1728                              "%d routers",
1729                              server->stat.my_clients,
1730                              server->stat.my_channels,
1731                              server->stat.my_servers,
1732                              server->stat.my_routers));
1733     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1734                             ("There are %d server operators and %d router "
1735                              "operators online",
1736                              server->stat.server_ops,
1737                              server->stat.router_ops));
1738     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1739                             ("I have %d operators online",
1740                              server->stat.my_router_ops +
1741                              server->stat.my_server_ops));
1742   } else {
1743     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1744                             ("I have %d clients and %d channels formed",
1745                              server->stat.my_clients,
1746                              server->stat.my_channels));
1747     SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1748                             ("%d operators online",
1749                              server->stat.my_server_ops));
1750   }
1751   SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1752                           ("Your connection is secured with %s cipher, "
1753                            "key length %d bits",
1754                            idata->send_key->cipher->name,
1755                            idata->send_key->cipher->key_len));
1756   SILC_SERVER_SEND_NOTIFY(server, sock, SILC_NOTIFY_TYPE_NONE,
1757                           ("Your current nickname is %s",
1758                            client->nickname));
1759
1760   /* Send motd */
1761   silc_server_send_motd(server, sock);
1762
1763   return client;
1764 }
1765
1766 /* Create new server. This processes received New Server packet and
1767    saves the received Server ID. The server is our locally connected
1768    server thus we save all the information and save it to local list.
1769    This funtion can be used by both normal server and router server.
1770    If normal server uses this it means that its router has connected
1771    to the server. If router uses this it means that one of the cell's
1772    servers is connected to the router. */
1773
1774 SilcServerEntry silc_server_new_server(SilcServer server,
1775                                        SilcSocketConnection sock,
1776                                        SilcPacketContext *packet)
1777 {
1778   SilcBuffer buffer = packet->buffer;
1779   SilcServerEntry new_server, server_entry;
1780   SilcServerID *server_id;
1781   SilcIDListData idata;
1782   unsigned char *server_name, *id_string;
1783   SilcUInt16 id_len, name_len;
1784   int ret;
1785   bool local = TRUE;
1786
1787   SILC_LOG_DEBUG(("Creating new server"));
1788
1789   if (sock->type != SILC_SOCKET_TYPE_SERVER &&
1790       sock->type != SILC_SOCKET_TYPE_ROUTER)
1791     return NULL;
1792
1793   /* Take server entry */
1794   new_server = (SilcServerEntry)sock->user_data;
1795   idata = (SilcIDListData)new_server;
1796
1797   /* Remove the old cache entry */
1798   if (!silc_idcache_del_by_context(server->local_list->servers, new_server)) {
1799     silc_idcache_del_by_context(server->global_list->servers, new_server);
1800     local = FALSE;
1801   }
1802
1803   /* Parse the incoming packet */
1804   ret = silc_buffer_unformat(buffer,
1805                              SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1806                              SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1807                                                          &name_len),
1808                              SILC_STR_END);
1809   if (ret == -1) {
1810     if (id_string)
1811       silc_free(id_string);
1812     if (server_name)
1813       silc_free(server_name);
1814     return NULL;
1815   }
1816
1817   if (id_len > buffer->len) {
1818     silc_free(id_string);
1819     silc_free(server_name);
1820     return NULL;
1821   }
1822
1823   if (name_len > 256)
1824     server_name[255] = '\0';
1825
1826   /* Get Server ID */
1827   server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1828   if (!server_id) {
1829     silc_free(id_string);
1830     silc_free(server_name);
1831     return NULL;
1832   }
1833   silc_free(id_string);
1834
1835   /* Check that we do not have this ID already */
1836   server_entry = silc_idlist_find_server_by_id(server->local_list,
1837                                                server_id, TRUE, NULL);
1838   if (server_entry) {
1839     silc_idcache_del_by_context(server->local_list->servers, server_entry);
1840   } else {
1841     server_entry = silc_idlist_find_server_by_id(server->global_list,
1842                                                  server_id, TRUE, NULL);
1843     if (server_entry)
1844       silc_idcache_del_by_context(server->global_list->servers, server_entry);
1845   }
1846
1847   /* Update server entry */
1848   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1849   new_server->server_name = server_name;
1850   new_server->id = server_id;
1851
1852   SILC_LOG_DEBUG(("New server id(%s)",
1853                   silc_id_render(server_id, SILC_ID_SERVER)));
1854
1855   /* Add again the entry to the ID cache. */
1856   silc_idcache_add(local ? server->local_list->servers :
1857                    server->global_list->servers, server_name, server_id,
1858                    new_server, 0, NULL);
1859
1860   /* Distribute the information about new server in the SILC network
1861      to our router. If we are normal server we won't send anything
1862      since this connection must be our router connection. */
1863   if (server->server_type == SILC_ROUTER && !server->standalone &&
1864       server->router->connection != sock)
1865     silc_server_send_new_id(server, server->router->connection,
1866                             TRUE, new_server->id, SILC_ID_SERVER,
1867                             silc_id_get_len(server_id, SILC_ID_SERVER));
1868
1869   if (server->server_type == SILC_ROUTER)
1870     server->stat.cell_servers++;
1871
1872   /* Check whether this router connection has been replaced by an
1873      backup router. If it has been then we'll disable the server and will
1874      ignore everything it will send until the backup router resuming
1875      protocol has been completed. */
1876   if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1877       silc_server_backup_replaced_get(server, server_id, NULL)) {
1878     /* Send packet to the server indicating that it cannot use this
1879        connection as it has been replaced by backup router. */
1880     SilcBuffer packet = silc_buffer_alloc(2);
1881     silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1882     silc_buffer_format(packet,
1883                        SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
1884                        SILC_STR_UI_CHAR(0),
1885                        SILC_STR_END);
1886     silc_server_packet_send(server, sock,
1887                             SILC_PACKET_RESUME_ROUTER, 0,
1888                             packet->data, packet->len, TRUE);
1889     silc_buffer_free(packet);
1890
1891     /* Mark the router disabled. The data sent earlier will go but nothing
1892        after this does not go to this connection. */
1893     idata->status |= SILC_IDLIST_STATUS_DISABLED;
1894   } else {
1895     /* If it is router announce our stuff to it. */
1896     if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1897         server->server_type == SILC_ROUTER) {
1898       silc_server_announce_servers(server, FALSE, 0, sock);
1899       silc_server_announce_clients(server, 0, sock);
1900       silc_server_announce_channels(server, 0, sock);
1901     }
1902   }
1903
1904   return new_server;
1905 }
1906
1907 /* Processes incoming New ID packet. New ID Payload is used to distribute
1908    information about newly registered clients and servers. */
1909
1910 static void silc_server_new_id_real(SilcServer server,
1911                                     SilcSocketConnection sock,
1912                                     SilcPacketContext *packet,
1913                                     int broadcast)
1914 {
1915   SilcBuffer buffer = packet->buffer;
1916   SilcIDList id_list;
1917   SilcServerEntry router, server_entry;
1918   SilcSocketConnection router_sock;
1919   SilcIDPayload idp;
1920   SilcIdType id_type;
1921   void *id;
1922
1923   SILC_LOG_DEBUG(("Processing new ID"));
1924
1925   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1926       server->server_type == SILC_SERVER ||
1927       packet->src_id_type != SILC_ID_SERVER)
1928     return;
1929
1930   idp = silc_id_payload_parse(buffer->data, buffer->len);
1931   if (!idp)
1932     return;
1933
1934   id_type = silc_id_payload_get_type(idp);
1935
1936   /* Normal server cannot have other normal server connections */
1937   server_entry = (SilcServerEntry)sock->user_data;
1938   if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
1939       server_entry->server_type == SILC_SERVER)
1940     goto out;
1941
1942   id = silc_id_payload_get_id(idp);
1943   if (!id)
1944     goto out;
1945
1946   /* If the packet is coming from server then use the sender as the
1947      origin of the the packet. If it came from router then check the real
1948      sender of the packet and use that as the origin. */
1949   if (sock->type == SILC_SOCKET_TYPE_SERVER) {
1950     id_list = server->local_list;
1951     router_sock = sock;
1952     router = sock->user_data;
1953
1954     /* If the sender is backup router and ID is server (and we are not
1955        backup router) then switch the entry to global list. */
1956     if (server_entry->server_type == SILC_BACKUP_ROUTER &&
1957         id_type == SILC_ID_SERVER &&
1958         server->id_entry->server_type != SILC_BACKUP_ROUTER) {
1959       id_list = server->global_list;
1960       router_sock = server->router ? server->router->connection : sock;
1961     }
1962   } else {
1963     void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1964                                      packet->src_id_type);
1965     router = silc_idlist_find_server_by_id(server->global_list,
1966                                            sender_id, TRUE, NULL);
1967     if (!router)
1968       router = silc_idlist_find_server_by_id(server->local_list,
1969                                              sender_id, TRUE, NULL);
1970     silc_free(sender_id);
1971     router_sock = sock;
1972     id_list = server->global_list;
1973   }
1974
1975   if (!router)
1976     goto out;
1977
1978   switch(id_type) {
1979   case SILC_ID_CLIENT:
1980     {
1981       SilcClientEntry entry;
1982
1983       /* Check that we do not have this client already */
1984       entry = silc_idlist_find_client_by_id(server->global_list,
1985                                             id, server->server_type,
1986                                             NULL);
1987       if (!entry)
1988         entry = silc_idlist_find_client_by_id(server->local_list,
1989                                               id, server->server_type,
1990                                               NULL);
1991       if (entry) {
1992         SILC_LOG_DEBUG(("Ignoring client that we already have"));
1993         goto out;
1994       }
1995
1996       SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
1997                       silc_id_render(id, SILC_ID_CLIENT),
1998                       sock->type == SILC_SOCKET_TYPE_SERVER ?
1999                       "Server" : "Router", sock->hostname));
2000
2001       /* As a router we keep information of all global information in our
2002          global list. Cell wide information however is kept in the local
2003          list. */
2004       entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2005                                      id, router, NULL, 0);
2006       if (!entry) {
2007         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2008
2009         /* Inform the sender that the ID is not usable */
2010         silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2011         goto out;
2012       }
2013       entry->nickname = NULL;
2014       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2015
2016       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2017         server->stat.cell_clients++;
2018       server->stat.clients++;
2019     }
2020     break;
2021
2022   case SILC_ID_SERVER:
2023     {
2024       SilcServerEntry entry;
2025
2026       /* If the ID is mine, ignore it. */
2027       if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2028         SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2029         break;
2030       }
2031
2032       /* If the ID is the sender's ID, ignore it (we have it already) */
2033       if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2034         SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2035         break;
2036       }
2037
2038       /* Check that we do not have this server already */
2039       entry = silc_idlist_find_server_by_id(server->global_list,
2040                                             id, server->server_type,
2041                                             NULL);
2042       if (!entry)
2043         entry = silc_idlist_find_server_by_id(server->local_list,
2044                                               id, server->server_type,
2045                                               NULL);
2046       if (entry) {
2047         SILC_LOG_DEBUG(("Ignoring server that we already have"));
2048         goto out;
2049       }
2050
2051       SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2052                       silc_id_render(id, SILC_ID_SERVER),
2053                       sock->type == SILC_SOCKET_TYPE_SERVER ?
2054                       "Server" : "Router", sock->hostname));
2055
2056       /* As a router we keep information of all global information in our
2057          global list. Cell wide information however is kept in the local
2058          list. */
2059       entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2060                                      router_sock);
2061       if (!entry) {
2062         SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2063         goto out;
2064       }
2065       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2066
2067       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2068         server->stat.cell_servers++;
2069       server->stat.servers++;
2070     }
2071     break;
2072
2073   case SILC_ID_CHANNEL:
2074     SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2075     goto out;
2076     break;
2077
2078   default:
2079     goto out;
2080     break;
2081   }
2082
2083   /* If the sender of this packet is server and we are router we need to
2084      broadcast this packet to other routers in the network. */
2085   if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
2086       sock->type == SILC_SOCKET_TYPE_SERVER &&
2087       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2088     SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2089     silc_server_packet_send(server, server->router->connection,
2090                             packet->type,
2091                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2092                             buffer->data, buffer->len, FALSE);
2093     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2094                             packet->type, packet->flags,
2095                             packet->buffer->data, packet->buffer->len,
2096                             FALSE, TRUE);
2097   }
2098
2099  out:
2100   silc_id_payload_free(idp);
2101 }
2102
2103
2104 /* Processes incoming New ID packet. New ID Payload is used to distribute
2105    information about newly registered clients and servers. */
2106
2107 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2108                         SilcPacketContext *packet)
2109 {
2110   silc_server_new_id_real(server, sock, packet, TRUE);
2111 }
2112
2113 /* Receoved New Id List packet, list of New ID payloads inside one
2114    packet. Process the New ID payloads one by one. */
2115
2116 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2117                              SilcPacketContext *packet)
2118 {
2119   SilcPacketContext *new_id;
2120   SilcBuffer idp;
2121   SilcUInt16 id_len;
2122
2123   SILC_LOG_DEBUG(("Processing New ID List"));
2124
2125   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2126       packet->src_id_type != SILC_ID_SERVER)
2127     return;
2128
2129   /* If the sender of this packet is server and we are router we need to
2130      broadcast this packet to other routers in the network. Broadcast
2131      this list packet instead of multiple New ID packets. */
2132   if (!server->standalone && server->server_type == SILC_ROUTER &&
2133       sock->type == SILC_SOCKET_TYPE_SERVER &&
2134       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2135     SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2136     silc_server_packet_send(server, server->router->connection,
2137                             packet->type,
2138                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2139                             packet->buffer->data, packet->buffer->len, FALSE);
2140     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2141                             packet->type, packet->flags,
2142                             packet->buffer->data, packet->buffer->len,
2143                             FALSE, TRUE);
2144   }
2145
2146   /* Make copy of the original packet context, except for the actual
2147      data buffer, which we will here now fetch from the original buffer. */
2148   new_id = silc_packet_context_alloc();
2149   new_id->type = SILC_PACKET_NEW_ID;
2150   new_id->flags = packet->flags;
2151   new_id->src_id = packet->src_id;
2152   new_id->src_id_len = packet->src_id_len;
2153   new_id->src_id_type = packet->src_id_type;
2154   new_id->dst_id = packet->dst_id;
2155   new_id->dst_id_len = packet->dst_id_len;
2156   new_id->dst_id_type = packet->dst_id_type;
2157
2158   idp = silc_buffer_alloc(256);
2159   new_id->buffer = idp;
2160
2161   while (packet->buffer->len) {
2162     SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2163     if ((id_len > packet->buffer->len) ||
2164         (id_len > idp->truelen))
2165       break;
2166
2167     silc_buffer_pull_tail(idp, 4 + id_len);
2168     silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2169
2170     /* Process the New ID */
2171     silc_server_new_id_real(server, sock, new_id, FALSE);
2172
2173     silc_buffer_push_tail(idp, 4 + id_len);
2174     silc_buffer_pull(packet->buffer, 4 + id_len);
2175   }
2176
2177   silc_buffer_free(idp);
2178   silc_free(new_id);
2179 }
2180
2181 /* Received New Channel packet. Information about new channels in the
2182    network are distributed using this packet. Save the information about
2183    the new channel. This usually comes from router but also normal server
2184    can send this to notify channels it has when it connects to us. */
2185
2186 void silc_server_new_channel(SilcServer server,
2187                              SilcSocketConnection sock,
2188                              SilcPacketContext *packet)
2189 {
2190   SilcChannelPayload payload;
2191   SilcChannelID *channel_id;
2192   char *channel_name;
2193   SilcUInt32 name_len;
2194   unsigned char *id;
2195   SilcUInt32 id_len;
2196   SilcUInt32 mode;
2197   SilcServerEntry server_entry;
2198   SilcChannelEntry channel;
2199
2200   SILC_LOG_DEBUG(("Processing New Channel"));
2201
2202   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2203       packet->src_id_type != SILC_ID_SERVER ||
2204       server->server_type == SILC_SERVER)
2205     return;
2206
2207   /* Parse the channel payload */
2208   payload = silc_channel_payload_parse(packet->buffer->data,
2209                                        packet->buffer->len);
2210   if (!payload)
2211     return;
2212
2213   /* Get the channel ID */
2214   channel_id = silc_channel_get_id_parse(payload);
2215   if (!channel_id) {
2216     silc_channel_payload_free(payload);
2217     return;
2218   }
2219
2220   channel_name = silc_channel_get_name(payload, &name_len);
2221   if (name_len > 256)
2222     channel_name[255] = '\0';
2223
2224   id = silc_channel_get_id(payload, &id_len);
2225
2226   server_entry = (SilcServerEntry)sock->user_data;
2227
2228   if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2229     /* Add the channel to global list as it is coming from router. It
2230        cannot be our own channel as it is coming from router. */
2231
2232     /* Check that we don't already have this channel */
2233     channel = silc_idlist_find_channel_by_name(server->local_list,
2234                                                channel_name, NULL);
2235     if (!channel)
2236       channel = silc_idlist_find_channel_by_name(server->global_list,
2237                                                  channel_name, NULL);
2238     if (!channel) {
2239       SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2240                       silc_id_render(channel_id, SILC_ID_CHANNEL),
2241                       sock->hostname));
2242
2243       silc_idlist_add_channel(server->global_list, strdup(channel_name),
2244                               0, channel_id, sock->user_data, NULL, NULL, 0);
2245       server->stat.channels++;
2246     }
2247   } else {
2248     /* The channel is coming from our server, thus it is in our cell
2249        we will add it to our local list. */
2250     SilcBuffer chk;
2251
2252     SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2253                     silc_id_render(channel_id, SILC_ID_CHANNEL),
2254                     sock->hostname));
2255
2256     /* Check that we don't already have this channel */
2257     channel = silc_idlist_find_channel_by_name(server->local_list,
2258                                                channel_name, NULL);
2259     if (!channel)
2260       channel = silc_idlist_find_channel_by_name(server->global_list,
2261                                                  channel_name, NULL);
2262
2263     /* If the channel does not exist, then create it. This creates a new
2264        key to the channel as well that we will send to the server. */
2265     if (!channel) {
2266       /* The protocol says that the Channel ID's IP address must be based
2267          on the router's IP address.  Check whether the ID is based in our
2268          IP and if it is not then create a new ID and enforce the server
2269          to switch the ID. */
2270       if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2271           !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2272         SilcChannelID *tmp;
2273         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2274
2275         if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2276           silc_server_send_notify_channel_change(server, sock, FALSE,
2277                                                  channel_id, tmp);
2278           silc_free(channel_id);
2279           channel_id = tmp;
2280         }
2281       }
2282
2283       /* Create the channel with the provided Channel ID */
2284       channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2285                                                        channel_name,
2286                                                        channel_id, FALSE);
2287       if (!channel) {
2288         silc_channel_payload_free(payload);
2289         silc_free(channel_id);
2290         return;
2291       }
2292
2293       /* Get the mode and set it to the channel */
2294       channel->mode = silc_channel_get_mode(payload);
2295
2296       /* Send the new channel key to the server */
2297       id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2298       id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2299       chk = silc_channel_key_payload_encode(id_len, id,
2300                                             strlen(channel->channel_key->
2301                                                    cipher->name),
2302                                             channel->channel_key->cipher->name,
2303                                             channel->key_len / 8,
2304                                             channel->key);
2305       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2306                               chk->data, chk->len, FALSE);
2307       silc_buffer_free(chk);
2308
2309     } else {
2310       /* The channel exist by that name, check whether the ID's match.
2311          If they don't then we'll force the server to use the ID we have.
2312          We also create a new key for the channel. */
2313       SilcBuffer users = NULL, users_modes = NULL;
2314
2315       if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2316         /* They don't match, send CHANNEL_CHANGE notify to the server to
2317            force the ID change. */
2318         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2319         silc_server_send_notify_channel_change(server, sock, FALSE,
2320                                                channel_id, channel->id);
2321       }
2322
2323       /* If the mode is different from what we have then enforce the
2324          mode change. */
2325       mode = silc_channel_get_mode(payload);
2326       if (channel->mode != mode) {
2327         SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
2328         silc_server_send_notify_cmode(server, sock, FALSE, channel,
2329                                       channel->mode, server->id,
2330                                       SILC_ID_SERVER,
2331                                       channel->cipher, channel->hmac_name,
2332                                       channel->passphrase);
2333       }
2334
2335       /* Create new key for the channel and send it to the server and
2336          everybody else possibly on the channel. */
2337
2338       if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
2339         if (!silc_server_create_channel_key(server, channel, 0))
2340           return;
2341
2342         /* Send to the channel */
2343         silc_server_send_channel_key(server, sock, channel, FALSE);
2344         id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2345         id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2346
2347         /* Send to the server */
2348         chk = silc_channel_key_payload_encode(id_len, id,
2349                                               strlen(channel->channel_key->
2350                                                      cipher->name),
2351                                               channel->channel_key->
2352                                               cipher->name,
2353                                               channel->key_len / 8,
2354                                               channel->key);
2355         silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2356                                 chk->data, chk->len, FALSE);
2357         silc_buffer_free(chk);
2358         silc_free(id);
2359       }
2360
2361       silc_free(channel_id);
2362
2363       /* Since the channel is coming from server and we also know about it
2364          then send the JOIN notify to the server so that it see's our
2365          users on the channel "joining" the channel. */
2366       silc_server_announce_get_channel_users(server, channel, &users,
2367                                              &users_modes);
2368       if (users) {
2369         silc_buffer_push(users, users->data - users->head);
2370         silc_server_packet_send(server, sock,
2371                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2372                                 users->data, users->len, FALSE);
2373         silc_buffer_free(users);
2374       }
2375       if (users_modes) {
2376         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
2377         silc_server_packet_send_dest(server, sock,
2378                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2379                                      channel->id, SILC_ID_CHANNEL,
2380                                      users_modes->data,
2381                                      users_modes->len, FALSE);
2382         silc_buffer_free(users_modes);
2383       }
2384     }
2385   }
2386
2387   silc_channel_payload_free(payload);
2388 }
2389
2390 /* Received New Channel List packet, list of New Channel List payloads inside
2391    one packet. Process the New Channel payloads one by one. */
2392
2393 void silc_server_new_channel_list(SilcServer server,
2394                                   SilcSocketConnection sock,
2395                                   SilcPacketContext *packet)
2396 {
2397   SilcPacketContext *new;
2398   SilcBuffer buffer;
2399   SilcUInt16 len1, len2;
2400
2401   SILC_LOG_DEBUG(("Processing New Channel List"));
2402
2403   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2404       packet->src_id_type != SILC_ID_SERVER ||
2405       server->server_type == SILC_SERVER)
2406     return;
2407
2408   /* If the sender of this packet is server and we are router we need to
2409      broadcast this packet to other routers in the network. Broadcast
2410      this list packet instead of multiple New Channel packets. */
2411   if (!server->standalone && server->server_type == SILC_ROUTER &&
2412       sock->type == SILC_SOCKET_TYPE_SERVER &&
2413       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2414     SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2415     silc_server_packet_send(server, server->router->connection,
2416                             packet->type,
2417                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2418                             packet->buffer->data, packet->buffer->len, FALSE);
2419     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2420                             packet->type, packet->flags,
2421                             packet->buffer->data, packet->buffer->len,
2422                             FALSE, TRUE);
2423   }
2424
2425   /* Make copy of the original packet context, except for the actual
2426      data buffer, which we will here now fetch from the original buffer. */
2427   new = silc_packet_context_alloc();
2428   new->type = SILC_PACKET_NEW_CHANNEL;
2429   new->flags = packet->flags;
2430   new->src_id = packet->src_id;
2431   new->src_id_len = packet->src_id_len;
2432   new->src_id_type = packet->src_id_type;
2433   new->dst_id = packet->dst_id;
2434   new->dst_id_len = packet->dst_id_len;
2435   new->dst_id_type = packet->dst_id_type;
2436
2437   buffer = silc_buffer_alloc(512);
2438   new->buffer = buffer;
2439
2440   while (packet->buffer->len) {
2441     SILC_GET16_MSB(len1, packet->buffer->data);
2442     if ((len1 > packet->buffer->len) ||
2443         (len1 > buffer->truelen))
2444       break;
2445
2446     SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2447     if ((len2 > packet->buffer->len) ||
2448         (len2 > buffer->truelen))
2449       break;
2450
2451     silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2452     silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2453
2454     /* Process the New Channel */
2455     silc_server_new_channel(server, sock, new);
2456
2457     silc_buffer_push_tail(buffer, 8 + len1 + len2);
2458     silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2459   }
2460
2461   silc_buffer_free(buffer);
2462   silc_free(new);
2463 }
2464
2465 /* Received key agreement packet. This packet is never for us. It is to
2466    the client in the packet's destination ID. Sending of this sort of packet
2467    equals sending private message, ie. it is sent point to point from
2468    one client to another. */
2469
2470 void silc_server_key_agreement(SilcServer server,
2471                                SilcSocketConnection sock,
2472                                SilcPacketContext *packet)
2473 {
2474   SilcSocketConnection dst_sock;
2475   SilcIDListData idata;
2476
2477   SILC_LOG_DEBUG(("Start"));
2478
2479   if (packet->src_id_type != SILC_ID_CLIENT ||
2480       packet->dst_id_type != SILC_ID_CLIENT)
2481     return;
2482
2483   if (!packet->dst_id)
2484     return;
2485
2486   /* Get the route to the client */
2487   dst_sock = silc_server_get_client_route(server, packet->dst_id,
2488                                           packet->dst_id_len, NULL, &idata);
2489   if (!dst_sock)
2490     return;
2491
2492   /* Relay the packet */
2493   silc_server_relay_packet(server, dst_sock, idata->send_key,
2494                            idata->hmac_send, idata->psn_send++,
2495                            packet, FALSE);
2496 }
2497
2498 /* Received connection auth request packet that is used during connection
2499    phase to resolve the mandatory authentication method.  This packet can
2500    actually be received at anytime but usually it is used only during
2501    the connection authentication phase. Now, protocol says that this packet
2502    can come from client or server, however, we support only this coming
2503    from client and expect that server always knows what authentication
2504    method to use. */
2505
2506 void silc_server_connection_auth_request(SilcServer server,
2507                                          SilcSocketConnection sock,
2508                                          SilcPacketContext *packet)
2509 {
2510   SilcServerConfigClient *client = NULL;
2511   SilcUInt16 conn_type;
2512   int ret;
2513   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
2514
2515   SILC_LOG_DEBUG(("Start"));
2516
2517   if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2518     return;
2519
2520   /* Parse the payload */
2521   ret = silc_buffer_unformat(packet->buffer,
2522                              SILC_STR_UI_SHORT(&conn_type),
2523                              SILC_STR_UI_SHORT(NULL),
2524                              SILC_STR_END);
2525   if (ret == -1)
2526     return;
2527
2528   if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2529     return;
2530
2531   /* Get the authentication method for the client */
2532   auth_meth = SILC_AUTH_NONE;
2533   client = silc_server_config_find_client(server, sock->ip);
2534   if (!client)
2535     client = silc_server_config_find_client(server, sock->hostname);
2536   if (client) {
2537     if (client->passphrase) {
2538       if (client->publickey && !server->config->prefer_passphrase_auth)
2539         auth_meth = SILC_AUTH_PUBLIC_KEY;
2540       else
2541         auth_meth = SILC_AUTH_PASSWORD;
2542     } else if (client->publickey)
2543       auth_meth = SILC_AUTH_PUBLIC_KEY;
2544   }
2545
2546   /* Send it back to the client */
2547   silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
2548 }
2549
2550 /* Received REKEY packet. The sender of the packet wants to regenerate
2551    its session keys. This starts the REKEY protocol. */
2552
2553 void silc_server_rekey(SilcServer server,
2554                        SilcSocketConnection sock,
2555                        SilcPacketContext *packet)
2556 {
2557   SilcProtocol protocol;
2558   SilcServerRekeyInternalContext *proto_ctx;
2559   SilcIDListData idata = (SilcIDListData)sock->user_data;
2560
2561   SILC_LOG_DEBUG(("Start"));
2562
2563   /* Allocate internal protocol context. This is sent as context
2564      to the protocol. */
2565   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2566   proto_ctx->server = (void *)server;
2567   proto_ctx->sock = sock;
2568   proto_ctx->responder = TRUE;
2569   proto_ctx->pfs = idata->rekey->pfs;
2570
2571   /* Perform rekey protocol. Will call the final callback after the
2572      protocol is over. */
2573   silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2574                       &protocol, proto_ctx, silc_server_rekey_final);
2575   sock->protocol = protocol;
2576
2577   if (proto_ctx->pfs == FALSE)
2578     /* Run the protocol */
2579     silc_protocol_execute(protocol, server->schedule, 0, 0);
2580 }
2581
2582 /* Received file transger packet. This packet is never for us. It is to
2583    the client in the packet's destination ID. Sending of this sort of packet
2584    equals sending private message, ie. it is sent point to point from
2585    one client to another. */
2586
2587 void silc_server_ftp(SilcServer server,
2588                      SilcSocketConnection sock,
2589                      SilcPacketContext *packet)
2590 {
2591   SilcSocketConnection dst_sock;
2592   SilcIDListData idata;
2593
2594   SILC_LOG_DEBUG(("Start"));
2595
2596   if (packet->src_id_type != SILC_ID_CLIENT ||
2597       packet->dst_id_type != SILC_ID_CLIENT)
2598     return;
2599
2600   if (!packet->dst_id)
2601     return;
2602
2603   /* Get the route to the client */
2604   dst_sock = silc_server_get_client_route(server, packet->dst_id,
2605                                           packet->dst_id_len, NULL, &idata);
2606   if (!dst_sock)
2607     return;
2608
2609   /* Relay the packet */
2610   silc_server_relay_packet(server, dst_sock, idata->send_key,
2611                            idata->hmac_send, idata->psn_send++,
2612                            packet, FALSE);
2613 }