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_INFO(("Unauthenticated client attempted to register to network"));
1544     silc_server_disconnect_remote(server, sock, "Server closed connection: "
1545                                   "You have not been authenticated");
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     if (!silc_idcache_del_by_context(server->global_list->servers,
1800                                      new_server)) {
1801       SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
1802                      "network", (sock->type == SILC_SOCKET_TYPE_SERVER ?
1803                                  "server" : "router")));
1804       silc_server_disconnect_remote(server, sock, "Server closed connection: "
1805                                     "You have not been authenticated");
1806       return NULL;
1807     }
1808     local = FALSE;
1809   }
1810
1811   /* Parse the incoming packet */
1812   ret = silc_buffer_unformat(buffer,
1813                              SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
1814                              SILC_STR_UI16_NSTRING_ALLOC(&server_name,
1815                                                          &name_len),
1816                              SILC_STR_END);
1817   if (ret == -1) {
1818     if (id_string)
1819       silc_free(id_string);
1820     if (server_name)
1821       silc_free(server_name);
1822     return NULL;
1823   }
1824
1825   if (id_len > buffer->len) {
1826     silc_free(id_string);
1827     silc_free(server_name);
1828     return NULL;
1829   }
1830
1831   if (name_len > 256)
1832     server_name[255] = '\0';
1833
1834   /* Get Server ID */
1835   server_id = silc_id_str2id(id_string, id_len, SILC_ID_SERVER);
1836   if (!server_id) {
1837     silc_free(id_string);
1838     silc_free(server_name);
1839     return NULL;
1840   }
1841   silc_free(id_string);
1842
1843   /* Check for valid server ID */
1844   if (!silc_id_is_valid_server_id(server, server_id, sock)) {
1845     SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
1846                    sock->ip, sock->hostname));
1847     silc_server_disconnect_remote(server, sock, "Server closed connection: "
1848                                   "Your Server ID is not valid");
1849     silc_free(server_name);
1850     return NULL;
1851   }
1852
1853   /* Check that we do not have this ID already */
1854   server_entry = silc_idlist_find_server_by_id(server->local_list,
1855                                                server_id, TRUE, NULL);
1856   if (server_entry) {
1857     silc_idcache_del_by_context(server->local_list->servers, server_entry);
1858   } else {
1859     server_entry = silc_idlist_find_server_by_id(server->global_list,
1860                                                  server_id, TRUE, NULL);
1861     if (server_entry)
1862       silc_idcache_del_by_context(server->global_list->servers, server_entry);
1863   }
1864
1865   /* Update server entry */
1866   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
1867   new_server->server_name = server_name;
1868   new_server->id = server_id;
1869
1870   SILC_LOG_DEBUG(("New server id(%s)",
1871                   silc_id_render(server_id, SILC_ID_SERVER)));
1872
1873   /* Add again the entry to the ID cache. */
1874   silc_idcache_add(local ? server->local_list->servers :
1875                    server->global_list->servers, server_name, server_id,
1876                    new_server, 0, NULL);
1877
1878   /* Distribute the information about new server in the SILC network
1879      to our router. If we are normal server we won't send anything
1880      since this connection must be our router connection. */
1881   if (server->server_type == SILC_ROUTER && !server->standalone &&
1882       server->router->connection != sock)
1883     silc_server_send_new_id(server, server->router->connection,
1884                             TRUE, new_server->id, SILC_ID_SERVER,
1885                             silc_id_get_len(server_id, SILC_ID_SERVER));
1886
1887   if (server->server_type == SILC_ROUTER)
1888     server->stat.cell_servers++;
1889
1890   /* Check whether this router connection has been replaced by an
1891      backup router. If it has been then we'll disable the server and will
1892      ignore everything it will send until the backup router resuming
1893      protocol has been completed. */
1894   if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1895       silc_server_backup_replaced_get(server, server_id, NULL)) {
1896     /* Send packet to the server indicating that it cannot use this
1897        connection as it has been replaced by backup router. */
1898     SilcBuffer packet = silc_buffer_alloc(2);
1899     silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1900     silc_buffer_format(packet,
1901                        SILC_STR_UI_CHAR(SILC_SERVER_BACKUP_REPLACED),
1902                        SILC_STR_UI_CHAR(0),
1903                        SILC_STR_END);
1904     silc_server_packet_send(server, sock,
1905                             SILC_PACKET_RESUME_ROUTER, 0,
1906                             packet->data, packet->len, TRUE);
1907     silc_buffer_free(packet);
1908
1909     /* Mark the router disabled. The data sent earlier will go but nothing
1910        after this does not go to this connection. */
1911     idata->status |= SILC_IDLIST_STATUS_DISABLED;
1912   } else {
1913     /* If it is router announce our stuff to it. */
1914     if (sock->type == SILC_SOCKET_TYPE_ROUTER &&
1915         server->server_type == SILC_ROUTER) {
1916       silc_server_announce_servers(server, FALSE, 0, sock);
1917       silc_server_announce_clients(server, 0, sock);
1918       silc_server_announce_channels(server, 0, sock);
1919     }
1920   }
1921
1922   return new_server;
1923 }
1924
1925 /* Processes incoming New ID packet. New ID Payload is used to distribute
1926    information about newly registered clients and servers. */
1927
1928 static void silc_server_new_id_real(SilcServer server,
1929                                     SilcSocketConnection sock,
1930                                     SilcPacketContext *packet,
1931                                     int broadcast)
1932 {
1933   SilcBuffer buffer = packet->buffer;
1934   SilcIDList id_list;
1935   SilcServerEntry router, server_entry;
1936   SilcSocketConnection router_sock;
1937   SilcIDPayload idp;
1938   SilcIdType id_type;
1939   void *id;
1940
1941   SILC_LOG_DEBUG(("Processing new ID"));
1942
1943   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
1944       server->server_type == SILC_SERVER ||
1945       packet->src_id_type != SILC_ID_SERVER)
1946     return;
1947
1948   idp = silc_id_payload_parse(buffer->data, buffer->len);
1949   if (!idp)
1950     return;
1951
1952   id_type = silc_id_payload_get_type(idp);
1953
1954   /* Normal server cannot have other normal server connections */
1955   server_entry = (SilcServerEntry)sock->user_data;
1956   if (id_type == SILC_ID_SERVER && sock->type == SILC_SOCKET_TYPE_SERVER &&
1957       server_entry->server_type == SILC_SERVER)
1958     goto out;
1959
1960   id = silc_id_payload_get_id(idp);
1961   if (!id)
1962     goto out;
1963
1964   /* If the packet is coming from server then use the sender as the
1965      origin of the the packet. If it came from router then check the real
1966      sender of the packet and use that as the origin. */
1967   if (sock->type == SILC_SOCKET_TYPE_SERVER) {
1968     id_list = server->local_list;
1969     router_sock = sock;
1970     router = sock->user_data;
1971
1972     /* If the sender is backup router and ID is server (and we are not
1973        backup router) then switch the entry to global list. */
1974     if (server_entry->server_type == SILC_BACKUP_ROUTER &&
1975         id_type == SILC_ID_SERVER &&
1976         server->id_entry->server_type != SILC_BACKUP_ROUTER) {
1977       id_list = server->global_list;
1978       router_sock = server->router ? server->router->connection : sock;
1979     }
1980   } else {
1981     void *sender_id = silc_id_str2id(packet->src_id, packet->src_id_len,
1982                                      packet->src_id_type);
1983     router = silc_idlist_find_server_by_id(server->global_list,
1984                                            sender_id, TRUE, NULL);
1985     if (!router)
1986       router = silc_idlist_find_server_by_id(server->local_list,
1987                                              sender_id, TRUE, NULL);
1988     silc_free(sender_id);
1989     router_sock = sock;
1990     id_list = server->global_list;
1991   }
1992
1993   if (!router)
1994     goto out;
1995
1996   switch(id_type) {
1997   case SILC_ID_CLIENT:
1998     {
1999       SilcClientEntry entry;
2000
2001       /* Check that we do not have this client already */
2002       entry = silc_idlist_find_client_by_id(server->global_list,
2003                                             id, server->server_type,
2004                                             NULL);
2005       if (!entry)
2006         entry = silc_idlist_find_client_by_id(server->local_list,
2007                                               id, server->server_type,
2008                                               NULL);
2009       if (entry) {
2010         SILC_LOG_DEBUG(("Ignoring client that we already have"));
2011         goto out;
2012       }
2013
2014       SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2015                       silc_id_render(id, SILC_ID_CLIENT),
2016                       sock->type == SILC_SOCKET_TYPE_SERVER ?
2017                       "Server" : "Router", sock->hostname));
2018
2019       /* As a router we keep information of all global information in our
2020          global list. Cell wide information however is kept in the local
2021          list. */
2022       entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2023                                      id, router, NULL, 0);
2024       if (!entry) {
2025         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2026
2027         /* Inform the sender that the ID is not usable */
2028         silc_server_send_notify_signoff(server, sock, FALSE, id, NULL);
2029         goto out;
2030       }
2031       entry->nickname = NULL;
2032       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2033
2034       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2035         server->stat.cell_clients++;
2036       server->stat.clients++;
2037     }
2038     break;
2039
2040   case SILC_ID_SERVER:
2041     {
2042       SilcServerEntry entry;
2043
2044       /* If the ID is mine, ignore it. */
2045       if (SILC_ID_SERVER_COMPARE(id, server->id)) {
2046         SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2047         break;
2048       }
2049
2050       /* If the ID is the sender's ID, ignore it (we have it already) */
2051       if (SILC_ID_SERVER_COMPARE(id, router->id)) {
2052         SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2053         break;
2054       }
2055
2056       /* Check that we do not have this server already */
2057       entry = silc_idlist_find_server_by_id(server->global_list,
2058                                             id, server->server_type,
2059                                             NULL);
2060       if (!entry)
2061         entry = silc_idlist_find_server_by_id(server->local_list,
2062                                               id, server->server_type,
2063                                               NULL);
2064       if (entry) {
2065         SILC_LOG_DEBUG(("Ignoring server that we already have"));
2066         goto out;
2067       }
2068
2069       SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2070                       silc_id_render(id, SILC_ID_SERVER),
2071                       sock->type == SILC_SOCKET_TYPE_SERVER ?
2072                       "Server" : "Router", sock->hostname));
2073
2074       /* As a router we keep information of all global information in our
2075          global list. Cell wide information however is kept in the local
2076          list. */
2077       entry = silc_idlist_add_server(id_list, NULL, 0, id, router,
2078                                      router_sock);
2079       if (!entry) {
2080         SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2081         goto out;
2082       }
2083       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2084
2085       if (sock->type == SILC_SOCKET_TYPE_SERVER)
2086         server->stat.cell_servers++;
2087       server->stat.servers++;
2088     }
2089     break;
2090
2091   case SILC_ID_CHANNEL:
2092     SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2093     goto out;
2094     break;
2095
2096   default:
2097     goto out;
2098     break;
2099   }
2100
2101   /* If the sender of this packet is server and we are router we need to
2102      broadcast this packet to other routers in the network. */
2103   if (broadcast && !server->standalone && server->server_type == SILC_ROUTER &&
2104       sock->type == SILC_SOCKET_TYPE_SERVER &&
2105       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2106     SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2107     silc_server_packet_send(server, server->router->connection,
2108                             packet->type,
2109                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2110                             buffer->data, buffer->len, FALSE);
2111     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2112                             packet->type, packet->flags,
2113                             packet->buffer->data, packet->buffer->len,
2114                             FALSE, TRUE);
2115   }
2116
2117  out:
2118   silc_id_payload_free(idp);
2119 }
2120
2121
2122 /* Processes incoming New ID packet. New ID Payload is used to distribute
2123    information about newly registered clients and servers. */
2124
2125 void silc_server_new_id(SilcServer server, SilcSocketConnection sock,
2126                         SilcPacketContext *packet)
2127 {
2128   silc_server_new_id_real(server, sock, packet, TRUE);
2129 }
2130
2131 /* Receoved New Id List packet, list of New ID payloads inside one
2132    packet. Process the New ID payloads one by one. */
2133
2134 void silc_server_new_id_list(SilcServer server, SilcSocketConnection sock,
2135                              SilcPacketContext *packet)
2136 {
2137   SilcPacketContext *new_id;
2138   SilcBuffer idp;
2139   SilcUInt16 id_len;
2140
2141   SILC_LOG_DEBUG(("Processing New ID List"));
2142
2143   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2144       packet->src_id_type != SILC_ID_SERVER)
2145     return;
2146
2147   /* If the sender of this packet is server and we are router we need to
2148      broadcast this packet to other routers in the network. Broadcast
2149      this list packet instead of multiple New ID packets. */
2150   if (!server->standalone && server->server_type == SILC_ROUTER &&
2151       sock->type == SILC_SOCKET_TYPE_SERVER &&
2152       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2153     SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2154     silc_server_packet_send(server, server->router->connection,
2155                             packet->type,
2156                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2157                             packet->buffer->data, packet->buffer->len, FALSE);
2158     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2159                             packet->type, packet->flags,
2160                             packet->buffer->data, packet->buffer->len,
2161                             FALSE, TRUE);
2162   }
2163
2164   /* Make copy of the original packet context, except for the actual
2165      data buffer, which we will here now fetch from the original buffer. */
2166   new_id = silc_packet_context_alloc();
2167   new_id->type = SILC_PACKET_NEW_ID;
2168   new_id->flags = packet->flags;
2169   new_id->src_id = packet->src_id;
2170   new_id->src_id_len = packet->src_id_len;
2171   new_id->src_id_type = packet->src_id_type;
2172   new_id->dst_id = packet->dst_id;
2173   new_id->dst_id_len = packet->dst_id_len;
2174   new_id->dst_id_type = packet->dst_id_type;
2175
2176   idp = silc_buffer_alloc(256);
2177   new_id->buffer = idp;
2178
2179   while (packet->buffer->len) {
2180     SILC_GET16_MSB(id_len, packet->buffer->data + 2);
2181     if ((id_len > packet->buffer->len) ||
2182         (id_len > idp->truelen))
2183       break;
2184
2185     silc_buffer_pull_tail(idp, 4 + id_len);
2186     silc_buffer_put(idp, packet->buffer->data, 4 + id_len);
2187
2188     /* Process the New ID */
2189     silc_server_new_id_real(server, sock, new_id, FALSE);
2190
2191     silc_buffer_push_tail(idp, 4 + id_len);
2192     silc_buffer_pull(packet->buffer, 4 + id_len);
2193   }
2194
2195   silc_buffer_free(idp);
2196   silc_free(new_id);
2197 }
2198
2199 /* Received New Channel packet. Information about new channels in the
2200    network are distributed using this packet. Save the information about
2201    the new channel. This usually comes from router but also normal server
2202    can send this to notify channels it has when it connects to us. */
2203
2204 void silc_server_new_channel(SilcServer server,
2205                              SilcSocketConnection sock,
2206                              SilcPacketContext *packet)
2207 {
2208   SilcChannelPayload payload;
2209   SilcChannelID *channel_id;
2210   char *channel_name;
2211   SilcUInt32 name_len;
2212   unsigned char *id;
2213   SilcUInt32 id_len;
2214   SilcUInt32 mode;
2215   SilcServerEntry server_entry;
2216   SilcChannelEntry channel;
2217
2218   SILC_LOG_DEBUG(("Processing New Channel"));
2219
2220   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2221       packet->src_id_type != SILC_ID_SERVER ||
2222       server->server_type == SILC_SERVER)
2223     return;
2224
2225   /* Parse the channel payload */
2226   payload = silc_channel_payload_parse(packet->buffer->data,
2227                                        packet->buffer->len);
2228   if (!payload)
2229     return;
2230
2231   /* Get the channel ID */
2232   channel_id = silc_channel_get_id_parse(payload);
2233   if (!channel_id) {
2234     silc_channel_payload_free(payload);
2235     return;
2236   }
2237
2238   channel_name = silc_channel_get_name(payload, &name_len);
2239   if (name_len > 256)
2240     channel_name[255] = '\0';
2241
2242   id = silc_channel_get_id(payload, &id_len);
2243
2244   server_entry = (SilcServerEntry)sock->user_data;
2245
2246   if (sock->type == SILC_SOCKET_TYPE_ROUTER) {
2247     /* Add the channel to global list as it is coming from router. It
2248        cannot be our own channel as it is coming from router. */
2249
2250     /* Check that we don't already have this channel */
2251     channel = silc_idlist_find_channel_by_name(server->local_list,
2252                                                channel_name, NULL);
2253     if (!channel)
2254       channel = silc_idlist_find_channel_by_name(server->global_list,
2255                                                  channel_name, NULL);
2256     if (!channel) {
2257       SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2258                       silc_id_render(channel_id, SILC_ID_CHANNEL),
2259                       sock->hostname));
2260
2261       silc_idlist_add_channel(server->global_list, strdup(channel_name),
2262                               0, channel_id, sock->user_data, NULL, NULL, 0);
2263       server->stat.channels++;
2264     }
2265   } else {
2266     /* The channel is coming from our server, thus it is in our cell
2267        we will add it to our local list. */
2268     SilcBuffer chk;
2269
2270     SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2271                     silc_id_render(channel_id, SILC_ID_CHANNEL),
2272                     sock->hostname));
2273
2274     /* Check that we don't already have this channel */
2275     channel = silc_idlist_find_channel_by_name(server->local_list,
2276                                                channel_name, NULL);
2277     if (!channel)
2278       channel = silc_idlist_find_channel_by_name(server->global_list,
2279                                                  channel_name, NULL);
2280
2281     /* If the channel does not exist, then create it. This creates a new
2282        key to the channel as well that we will send to the server. */
2283     if (!channel) {
2284       /* The protocol says that the Channel ID's IP address must be based
2285          on the router's IP address.  Check whether the ID is based in our
2286          IP and if it is not then create a new ID and enforce the server
2287          to switch the ID. */
2288       if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2289           !SILC_ID_COMPARE(channel_id, server->id, server->id->ip.data_len)) {
2290         SilcChannelID *tmp;
2291         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2292
2293         if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2294           silc_server_send_notify_channel_change(server, sock, FALSE,
2295                                                  channel_id, tmp);
2296           silc_free(channel_id);
2297           channel_id = tmp;
2298         }
2299       }
2300
2301       /* Create the channel with the provided Channel ID */
2302       channel = silc_server_create_new_channel_with_id(server, NULL, NULL,
2303                                                        channel_name,
2304                                                        channel_id, FALSE);
2305       if (!channel) {
2306         silc_channel_payload_free(payload);
2307         silc_free(channel_id);
2308         return;
2309       }
2310
2311       /* Get the mode and set it to the channel */
2312       channel->mode = silc_channel_get_mode(payload);
2313
2314       /* Send the new channel key to the server */
2315       id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2316       id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2317       chk = silc_channel_key_payload_encode(id_len, id,
2318                                             strlen(channel->channel_key->
2319                                                    cipher->name),
2320                                             channel->channel_key->cipher->name,
2321                                             channel->key_len / 8,
2322                                             channel->key);
2323       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2324                               chk->data, chk->len, FALSE);
2325       silc_buffer_free(chk);
2326
2327     } else {
2328       /* The channel exist by that name, check whether the ID's match.
2329          If they don't then we'll force the server to use the ID we have.
2330          We also create a new key for the channel. */
2331       SilcBuffer users = NULL, users_modes = NULL;
2332
2333       if (!SILC_ID_CHANNEL_COMPARE(channel_id, channel->id)) {
2334         /* They don't match, send CHANNEL_CHANGE notify to the server to
2335            force the ID change. */
2336         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2337         silc_server_send_notify_channel_change(server, sock, FALSE,
2338                                                channel_id, channel->id);
2339       }
2340
2341       /* If the mode is different from what we have then enforce the
2342          mode change. */
2343       mode = silc_channel_get_mode(payload);
2344       if (channel->mode != mode) {
2345         SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
2346         silc_server_send_notify_cmode(server, sock, FALSE, channel,
2347                                       channel->mode, server->id,
2348                                       SILC_ID_SERVER,
2349                                       channel->cipher, channel->hmac_name,
2350                                       channel->passphrase);
2351       }
2352
2353       /* Create new key for the channel and send it to the server and
2354          everybody else possibly on the channel. */
2355
2356       if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
2357         if (!silc_server_create_channel_key(server, channel, 0))
2358           return;
2359
2360         /* Send to the channel */
2361         silc_server_send_channel_key(server, sock, channel, FALSE);
2362         id = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
2363         id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
2364
2365         /* Send to the server */
2366         chk = silc_channel_key_payload_encode(id_len, id,
2367                                               strlen(channel->channel_key->
2368                                                      cipher->name),
2369                                               channel->channel_key->
2370                                               cipher->name,
2371                                               channel->key_len / 8,
2372                                               channel->key);
2373         silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
2374                                 chk->data, chk->len, FALSE);
2375         silc_buffer_free(chk);
2376         silc_free(id);
2377       }
2378
2379       silc_free(channel_id);
2380
2381       /* Since the channel is coming from server and we also know about it
2382          then send the JOIN notify to the server so that it see's our
2383          users on the channel "joining" the channel. */
2384       silc_server_announce_get_channel_users(server, channel, &users,
2385                                              &users_modes);
2386       if (users) {
2387         silc_buffer_push(users, users->data - users->head);
2388         silc_server_packet_send(server, sock,
2389                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2390                                 users->data, users->len, FALSE);
2391         silc_buffer_free(users);
2392       }
2393       if (users_modes) {
2394         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
2395         silc_server_packet_send_dest(server, sock,
2396                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
2397                                      channel->id, SILC_ID_CHANNEL,
2398                                      users_modes->data,
2399                                      users_modes->len, FALSE);
2400         silc_buffer_free(users_modes);
2401       }
2402     }
2403   }
2404
2405   silc_channel_payload_free(payload);
2406 }
2407
2408 /* Received New Channel List packet, list of New Channel List payloads inside
2409    one packet. Process the New Channel payloads one by one. */
2410
2411 void silc_server_new_channel_list(SilcServer server,
2412                                   SilcSocketConnection sock,
2413                                   SilcPacketContext *packet)
2414 {
2415   SilcPacketContext *new;
2416   SilcBuffer buffer;
2417   SilcUInt16 len1, len2;
2418
2419   SILC_LOG_DEBUG(("Processing New Channel List"));
2420
2421   if (sock->type == SILC_SOCKET_TYPE_CLIENT ||
2422       packet->src_id_type != SILC_ID_SERVER ||
2423       server->server_type == SILC_SERVER)
2424     return;
2425
2426   /* If the sender of this packet is server and we are router we need to
2427      broadcast this packet to other routers in the network. Broadcast
2428      this list packet instead of multiple New Channel packets. */
2429   if (!server->standalone && server->server_type == SILC_ROUTER &&
2430       sock->type == SILC_SOCKET_TYPE_SERVER &&
2431       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2432     SILC_LOG_DEBUG(("Broadcasting received New Channel List packet"));
2433     silc_server_packet_send(server, server->router->connection,
2434                             packet->type,
2435                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2436                             packet->buffer->data, packet->buffer->len, FALSE);
2437     silc_server_backup_send(server, (SilcServerEntry)sock->user_data,
2438                             packet->type, packet->flags,
2439                             packet->buffer->data, packet->buffer->len,
2440                             FALSE, TRUE);
2441   }
2442
2443   /* Make copy of the original packet context, except for the actual
2444      data buffer, which we will here now fetch from the original buffer. */
2445   new = silc_packet_context_alloc();
2446   new->type = SILC_PACKET_NEW_CHANNEL;
2447   new->flags = packet->flags;
2448   new->src_id = packet->src_id;
2449   new->src_id_len = packet->src_id_len;
2450   new->src_id_type = packet->src_id_type;
2451   new->dst_id = packet->dst_id;
2452   new->dst_id_len = packet->dst_id_len;
2453   new->dst_id_type = packet->dst_id_type;
2454
2455   buffer = silc_buffer_alloc(512);
2456   new->buffer = buffer;
2457
2458   while (packet->buffer->len) {
2459     SILC_GET16_MSB(len1, packet->buffer->data);
2460     if ((len1 > packet->buffer->len) ||
2461         (len1 > buffer->truelen))
2462       break;
2463
2464     SILC_GET16_MSB(len2, packet->buffer->data + 2 + len1);
2465     if ((len2 > packet->buffer->len) ||
2466         (len2 > buffer->truelen))
2467       break;
2468
2469     silc_buffer_pull_tail(buffer, 8 + len1 + len2);
2470     silc_buffer_put(buffer, packet->buffer->data, 8 + len1 + len2);
2471
2472     /* Process the New Channel */
2473     silc_server_new_channel(server, sock, new);
2474
2475     silc_buffer_push_tail(buffer, 8 + len1 + len2);
2476     silc_buffer_pull(packet->buffer, 8 + len1 + len2);
2477   }
2478
2479   silc_buffer_free(buffer);
2480   silc_free(new);
2481 }
2482
2483 /* Received key agreement packet. This packet is never for us. It is to
2484    the client in the packet's destination ID. Sending of this sort of packet
2485    equals sending private message, ie. it is sent point to point from
2486    one client to another. */
2487
2488 void silc_server_key_agreement(SilcServer server,
2489                                SilcSocketConnection sock,
2490                                SilcPacketContext *packet)
2491 {
2492   SilcSocketConnection dst_sock;
2493   SilcIDListData idata;
2494
2495   SILC_LOG_DEBUG(("Start"));
2496
2497   if (packet->src_id_type != SILC_ID_CLIENT ||
2498       packet->dst_id_type != SILC_ID_CLIENT)
2499     return;
2500
2501   if (!packet->dst_id)
2502     return;
2503
2504   /* Get the route to the client */
2505   dst_sock = silc_server_get_client_route(server, packet->dst_id,
2506                                           packet->dst_id_len, NULL, &idata);
2507   if (!dst_sock)
2508     return;
2509
2510   /* Relay the packet */
2511   silc_server_relay_packet(server, dst_sock, idata->send_key,
2512                            idata->hmac_send, idata->psn_send++,
2513                            packet, FALSE);
2514 }
2515
2516 /* Received connection auth request packet that is used during connection
2517    phase to resolve the mandatory authentication method.  This packet can
2518    actually be received at anytime but usually it is used only during
2519    the connection authentication phase. Now, protocol says that this packet
2520    can come from client or server, however, we support only this coming
2521    from client and expect that server always knows what authentication
2522    method to use. */
2523
2524 void silc_server_connection_auth_request(SilcServer server,
2525                                          SilcSocketConnection sock,
2526                                          SilcPacketContext *packet)
2527 {
2528   SilcServerConfigClient *client = NULL;
2529   SilcUInt16 conn_type;
2530   int ret;
2531   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
2532
2533   SILC_LOG_DEBUG(("Start"));
2534
2535   if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT)
2536     return;
2537
2538   /* Parse the payload */
2539   ret = silc_buffer_unformat(packet->buffer,
2540                              SILC_STR_UI_SHORT(&conn_type),
2541                              SILC_STR_UI_SHORT(NULL),
2542                              SILC_STR_END);
2543   if (ret == -1)
2544     return;
2545
2546   if (conn_type != SILC_SOCKET_TYPE_CLIENT)
2547     return;
2548
2549   /* Get the authentication method for the client */
2550   auth_meth = SILC_AUTH_NONE;
2551   client = silc_server_config_find_client(server, sock->ip);
2552   if (!client)
2553     client = silc_server_config_find_client(server, sock->hostname);
2554   if (client) {
2555     if (client->passphrase) {
2556       if (client->publickeys && !server->config->prefer_passphrase_auth)
2557         auth_meth = SILC_AUTH_PUBLIC_KEY;
2558       else
2559         auth_meth = SILC_AUTH_PASSWORD;
2560     } else if (client->publickeys)
2561       auth_meth = SILC_AUTH_PUBLIC_KEY;
2562   }
2563
2564   /* Send it back to the client */
2565   silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
2566 }
2567
2568 /* Received REKEY packet. The sender of the packet wants to regenerate
2569    its session keys. This starts the REKEY protocol. */
2570
2571 void silc_server_rekey(SilcServer server,
2572                        SilcSocketConnection sock,
2573                        SilcPacketContext *packet)
2574 {
2575   SilcProtocol protocol;
2576   SilcServerRekeyInternalContext *proto_ctx;
2577   SilcIDListData idata = (SilcIDListData)sock->user_data;
2578
2579   SILC_LOG_DEBUG(("Start"));
2580
2581   /* Allocate internal protocol context. This is sent as context
2582      to the protocol. */
2583   proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
2584   proto_ctx->server = (void *)server;
2585   proto_ctx->sock = sock;
2586   proto_ctx->responder = TRUE;
2587   proto_ctx->pfs = idata->rekey->pfs;
2588
2589   /* Perform rekey protocol. Will call the final callback after the
2590      protocol is over. */
2591   silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
2592                       &protocol, proto_ctx, silc_server_rekey_final);
2593   sock->protocol = protocol;
2594
2595   if (proto_ctx->pfs == FALSE)
2596     /* Run the protocol */
2597     silc_protocol_execute(protocol, server->schedule, 0, 0);
2598 }
2599
2600 /* Received file transger packet. This packet is never for us. It is to
2601    the client in the packet's destination ID. Sending of this sort of packet
2602    equals sending private message, ie. it is sent point to point from
2603    one client to another. */
2604
2605 void silc_server_ftp(SilcServer server,
2606                      SilcSocketConnection sock,
2607                      SilcPacketContext *packet)
2608 {
2609   SilcSocketConnection dst_sock;
2610   SilcIDListData idata;
2611
2612   SILC_LOG_DEBUG(("Start"));
2613
2614   if (packet->src_id_type != SILC_ID_CLIENT ||
2615       packet->dst_id_type != SILC_ID_CLIENT)
2616     return;
2617
2618   if (!packet->dst_id)
2619     return;
2620
2621   /* Get the route to the client */
2622   dst_sock = silc_server_get_client_route(server, packet->dst_id,
2623                                           packet->dst_id_len, NULL, &idata);
2624   if (!dst_sock)
2625     return;
2626
2627   /* Relay the packet */
2628   silc_server_relay_packet(server, dst_sock, idata->send_key,
2629                            idata->hmac_send, idata->psn_send++,
2630                            packet, FALSE);
2631 }