apps/silcd/packet_receive.c

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