apps/silcd/packet_receive.c

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