apps/silcd/packet_receive.c

   1 /*
   2
   3   packet_receive.c
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   6
   7   Copyright (C) 1997 - 2007 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 #include "serverincludes.h"
  22 #include "server_internal.h"
  23
  24 /* Received notify packet. Server can receive notify packets from router.
  25    Server then relays the notify messages to clients if needed. */
  26
  27 static void silc_server_notify_process(SilcServer server,
  28                                        SilcPacketStream sock,
  29                                        SilcPacket packet,
  30                                        SilcBuffer buffer)
  31 {
  32   SilcIDListData idata = silc_packet_get_context(sock);
  33   SilcNotifyPayload payload;
  34   SilcNotifyType type;
  35   SilcArgumentPayload args;
  36   SilcChannelID channel_id;
  37   SilcID id, id2;
  38   SilcChannelEntry channel = NULL;
  39   SilcClientEntry client = NULL, client2 = NULL;
  40   SilcServerEntry server_entry = NULL;
  41   SilcChannelClientEntry chl;
  42   SilcIDCacheEntry cache = NULL;
  43   SilcHashTableList htl;
  44   SilcUInt32 mode;
  45   unsigned char *tmp, *tmp2;
  46   SilcUInt32 tmp_len, tmp2_len;
  47   SilcBool local, ret;
  48
  49   if (idata->conn_type == SILC_CONN_CLIENT) {
  50     SILC_LOG_DEBUG(("Notify received from client, drop it"));
  51     return;
  52   }
  53
  54   if (packet->src_id_type != SILC_ID_SERVER){
  55     SILC_LOG_DEBUG(("Bad notify packet received"));
  56     return;
  57   }
  58
  59   if (!packet->dst_id) {
  60     SILC_LOG_DEBUG(("Bad notify packet received"));
  61     return;
  62   }
  63
  64   /* If the packet is destined directly to a client then relay the packet
  65      before processing it. */
  66   if (packet->dst_id_type == SILC_ID_CLIENT) {
  67     SilcIDListData idata;
  68     SilcPacketStream dst_sock;
  69
  70     /* Get the route to the client */
  71     dst_sock = silc_server_get_client_route(server, packet->dst_id,
  72                                             packet->dst_id_len, NULL,
  73                                             &idata, NULL);
  74     if (dst_sock)
  75       /* Relay the packet */
  76       silc_server_packet_route(server, dst_sock, packet);
  77   }
  78
  79   /* Parse the Notify Payload */
  80   payload = silc_notify_payload_parse(buffer->data, silc_buffer_len(buffer));
  81   if (!payload) {
  82     SILC_LOG_DEBUG(("Marlformed notify payload"));
  83     return;
  84   }
  85
  86   /* If we are router and this packet is not already broadcast packet
  87      we will broadcast it. The sending socket really cannot be router or
  88      the router is buggy. If this packet is coming from router then it must
  89      have the broadcast flag set already and we won't do anything. */
  90   if (server->server_type == SILC_ROUTER &&
  91       idata->conn_type == SILC_CONN_SERVER &&
  92       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
  93     SILC_LOG_DEBUG(("Broadcasting received Notify packet"));
  94     if (packet->dst_id_type == SILC_ID_CHANNEL) {
  95       /* Packet is destined to channel */
  96       if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
  97                           packet->dst_id_type, &channel_id,
  98                           sizeof(channel_id))) {
  99         SILC_LOG_DEBUG(("Malformed destination ID in notify packet"));
 100         goto out;
 101       }
 102
 103       silc_server_packet_send_dest(server, SILC_PRIMARY_ROUTE(server),
 104                                    packet->type, packet->flags |
 105                                    SILC_PACKET_FLAG_BROADCAST,
 106                                    &channel_id, SILC_ID_CHANNEL,
 107                                    buffer->data, silc_buffer_len(buffer));
 108       silc_server_backup_send_dest(server, (SilcServerEntry)idata,
 109                                    packet->type, packet->flags,
 110                                    &channel_id, SILC_ID_CHANNEL,
 111                                    buffer->data, silc_buffer_len(buffer),
 112                                    FALSE, TRUE);
 113     } else {
 114       /* Packet is destined to client or server */
 115       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
 116                               packet->type,
 117                               packet->flags | SILC_PACKET_FLAG_BROADCAST,
 118                               buffer->data, silc_buffer_len(buffer));
 119       silc_server_backup_send(server, (SilcServerEntry)idata,
 120                               packet->type, packet->flags,
 121                               buffer->data, silc_buffer_len(buffer),
 122                               FALSE, TRUE);
 123     }
 124   }
 125
 126   type = silc_notify_get_type(payload);
 127   args = silc_notify_get_args(payload);
 128   if (!args) {
 129     SILC_LOG_DEBUG(("Notify doesn't have any arguments, drop it"));
 130     goto out;
 131   }
 132
 133   switch(type) {
 134   case SILC_NOTIFY_TYPE_JOIN:
 135     /*
 136      * Distribute the notify to local clients on the channel
 137      */
 138     SILC_LOG_DEBUG(("JOIN notify"));
 139
 140     /* Get Channel ID */
 141     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
 142       goto out;
 143
 144     /* Get channel entry */
 145     channel = silc_idlist_find_channel_by_id(server->global_list,
 146                                              SILC_ID_GET_ID(id), NULL);
 147     if (!channel) {
 148       channel = silc_idlist_find_channel_by_id(server->local_list,
 149                                                SILC_ID_GET_ID(id), NULL);
 150       if (!channel) {
 151         SILC_LOG_DEBUG(("Notify for unknown channel %s",
 152                         silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
 153         goto out;
 154       }
 155     }
 156
 157     /* Get client ID */
 158     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 159       goto out;
 160
 161     /* If the the client is not in local list we check global list (ie. the
 162        channel will be global channel) and if it does not exist then create
 163        entry for the client. */
 164     client = silc_idlist_find_client_by_id(server->global_list,
 165                                            SILC_ID_GET_ID(id),
 166                                            server->server_type,
 167                                            &cache);
 168     if (!client) {
 169       client = silc_idlist_find_client_by_id(server->local_list,
 170                                              SILC_ID_GET_ID(id),
 171                                              server->server_type,
 172                                              &cache);
 173       if (!client) {
 174         /* If router did not find the client the it is bogus */
 175         if (server->server_type != SILC_SERVER)
 176           goto out;
 177
 178         client =
 179           silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
 180                                  silc_id_dup(SILC_ID_GET_ID(id),
 181                                              SILC_ID_CLIENT),
 182                                  (SilcServerEntry)idata, NULL);
 183         if (!client) {
 184           SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
 185           goto out;
 186         }
 187
 188         client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
 189       }
 190     }
 191
 192     /* Do not process the notify if the client is not registered */
 193     if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
 194       break;
 195
 196     /* Do not add client to channel if it is there already */
 197     if (silc_server_client_on_channel(client, channel, NULL)) {
 198       SILC_LOG_DEBUG(("Client already on channel %s",
 199                       channel->channel_name));
 200       break;
 201     }
 202
 203     /* Send to channel */
 204     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 205                                        FALSE, TRUE, buffer->data,
 206                                        silc_buffer_len(buffer));
 207
 208     if (server->server_type != SILC_ROUTER &&
 209         idata->conn_type == SILC_CONN_ROUTER)
 210       /* The channel is global now */
 211       channel->global_users = TRUE;
 212
 213     SILC_LOG_DEBUG(("Joining to channel %s", channel->channel_name));
 214
 215     /* JOIN the global client to the channel (local clients (if router
 216        created the channel) is joined in the pending JOIN command). */
 217     chl = silc_calloc(1, sizeof(*chl));
 218     if (!chl)
 219       goto out;
 220     chl->client = client;
 221     chl->channel = channel;
 222
 223     if (server->server_type != SILC_ROUTER ||
 224         idata->conn_type == SILC_CONN_ROUTER) {
 225       /* If founder auth is set, first client is not automatically founder. */
 226       if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
 227         /* If this is the first one on the channel then it is the founder of
 228            the channel. This is done on normal server and on router if this
 229            notify is coming from router */
 230         if (!silc_hash_table_count(channel->user_list)) {
 231           SILC_LOG_DEBUG(("Client %s is founder on channel",
 232                           silc_id_render(chl->client->id, SILC_ID_CLIENT)));
 233           chl->mode = (SILC_CHANNEL_UMODE_CHANOP | SILC_CHANNEL_UMODE_CHANFO);
 234         }
 235       }
 236     }
 237
 238     silc_hash_table_add(channel->user_list, client, chl);
 239     silc_hash_table_add(client->channels, channel, chl);
 240     channel->user_count++;
 241     channel->disabled = FALSE;
 242
 243     /* Update statistics */
 244     if (server->server_type == SILC_ROUTER) {
 245       if (idata->conn_type != SILC_CONN_ROUTER)
 246         server->stat.cell_chanclients++;
 247       server->stat.chanclients++;
 248     }
 249
 250     break;
 251
 252   case SILC_NOTIFY_TYPE_LEAVE:
 253     /*
 254      * Distribute the notify to local clients on the channel
 255      */
 256     SILC_LOG_DEBUG(("LEAVE notify"));
 257
 258     if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
 259                         packet->dst_id_type, &channel_id,
 260                         sizeof(channel_id)))
 261       goto out;
 262
 263     /* Get channel entry */
 264     channel = silc_idlist_find_channel_by_id(server->global_list,
 265                                              &channel_id, NULL);
 266     if (!channel) {
 267       channel = silc_idlist_find_channel_by_id(server->local_list,
 268                                                &channel_id, NULL);
 269       if (!channel) {
 270         SILC_LOG_DEBUG(("Notify for unknown channel %s",
 271                         silc_id_render(&channel_id, SILC_ID_CHANNEL)));
 272         goto out;
 273       }
 274     }
 275
 276     /* Get client ID */
 277     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 278       goto out;
 279
 280     /* Get client entry */
 281     client = silc_idlist_find_client_by_id(server->global_list,
 282                                            SILC_ID_GET_ID(id), TRUE, NULL);
 283     if (!client) {
 284       client = silc_idlist_find_client_by_id(server->local_list,
 285                                              SILC_ID_GET_ID(id), TRUE, NULL);
 286       if (!client)
 287         goto out;
 288     }
 289
 290     /* Check if on channel */
 291     if (!silc_server_client_on_channel(client, channel, NULL))
 292       break;
 293
 294     /* Send the leave notify to channel */
 295     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
 296                                        FALSE, TRUE, buffer->data,
 297                                        silc_buffer_len(buffer));
 298
 299     /* Remove the user from channel */
 300     silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
 301     break;
 302
 303   case SILC_NOTIFY_TYPE_SIGNOFF:
 304     /*
 305      * Distribute the notify to local clients on the channel
 306      */
 307     SILC_LOG_DEBUG(("SIGNOFF notify"));
 308
 309     /* Get client ID */
 310     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 311       goto out;
 312
 313     /* Get client entry */
 314     client = silc_idlist_find_client_by_id(server->global_list,
 315                                            SILC_ID_GET_ID(id), TRUE, &cache);
 316     if (!client) {
 317       client = silc_idlist_find_client_by_id(server->local_list,
 318                                              SILC_ID_GET_ID(id), TRUE, &cache);
 319       if (!client)
 320         goto out;
 321     }
 322
 323     /* Get signoff message */
 324     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 325     if (tmp_len > 128)
 326       tmp_len = 128;
 327
 328     /* Update statistics */
 329     SILC_VERIFY(server->stat.clients > 0);
 330     server->stat.clients--;
 331     if (server->stat.cell_clients)
 332       server->stat.cell_clients--;
 333     SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
 334     SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
 335     silc_schedule_task_del_by_context(server->schedule, client);
 336
 337     /* Remove client's public key from repository, this will free it too. */
 338     if (client->data.public_key) {
 339       silc_skr_del_public_key(server->repository, client->data.public_key,
 340                               client);
 341       client->data.public_key = NULL;
 342     }
 343
 344     /* Remove the client from all channels. */
 345     silc_server_remove_from_channels(server, NULL, client, TRUE,
 346                                      tmp, FALSE, FALSE);
 347
 348     /* Check if anyone is watching this nickname */
 349     if (server->server_type == SILC_ROUTER)
 350       silc_server_check_watcher_list(server, client, NULL,
 351                                      SILC_NOTIFY_TYPE_SIGNOFF);
 352
 353     /* Remove this client from watcher list if it is */
 354     silc_server_del_from_watcher_list(server, client);
 355
 356     client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
 357     client->mode = 0;
 358     client->router = NULL;
 359     client->connection = NULL;
 360     client->data.created = silc_time();
 361     silc_dlist_del(server->expired_clients, client);
 362     silc_dlist_add(server->expired_clients, client);
 363     break;
 364
 365   case SILC_NOTIFY_TYPE_TOPIC_SET:
 366     /*
 367      * Distribute the notify to local clients on the channel
 368      */
 369
 370     SILC_LOG_DEBUG(("TOPIC SET notify"));
 371
 372     /* Get client ID */
 373     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 374       goto out;
 375
 376     /* Get client entry */
 377     if (id.type == SILC_ID_CLIENT) {
 378       client = silc_idlist_find_client_by_id(server->global_list,
 379                                              SILC_ID_GET_ID(id), TRUE, &cache);
 380       if (!client) {
 381         client = silc_idlist_find_client_by_id(server->local_list,
 382                                                SILC_ID_GET_ID(id),
 383                                                TRUE, &cache);
 384         if (!client)
 385           goto out;
 386       }
 387     }
 388
 389     /* Get the topic */
 390     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 391     if (!tmp)
 392       goto out;
 393
 394     if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
 395                         packet->dst_id_type, &channel_id,
 396                         sizeof(channel_id)))
 397       goto out;
 398
 399     /* Get channel entry */
 400     channel = silc_idlist_find_channel_by_id(server->global_list,
 401                                              &channel_id, NULL);
 402     if (!channel) {
 403       channel = silc_idlist_find_channel_by_id(server->local_list,
 404                                                &channel_id, NULL);
 405       if (!channel) {
 406         SILC_LOG_DEBUG(("Notify for unknown channel %s",
 407                         silc_id_render(&channel_id, SILC_ID_CHANNEL)));
 408         goto out;
 409       }
 410     }
 411
 412     if (channel->topic && !strcmp(channel->topic, tmp)) {
 413       SILC_LOG_DEBUG(("Topic is already set and same"));
 414       goto out;
 415     }
 416
 417     if (client) {
 418       /* Get user's channel entry and check that topic set is allowed. */
 419       if (!silc_server_client_on_channel(client, channel, &chl))
 420         goto out;
 421       if (channel->mode & SILC_CHANNEL_MODE_TOPIC &&
 422           !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
 423           !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
 424         SILC_LOG_DEBUG(("Topic change is not allowed"));
 425         goto out;
 426       }
 427     }
 428
 429     /* Change the topic */
 430     silc_free(channel->topic);
 431     channel->topic = strdup(tmp);
 432
 433     /* Send the same notify to the channel */
 434     silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
 435                                        FALSE, TRUE, buffer->data,
 436                                        silc_buffer_len(buffer));
 437     break;
 438
 439   case SILC_NOTIFY_TYPE_NICK_CHANGE:
 440     {
 441       /*
 442        * Distribute the notify to local clients on the channel
 443        */
 444       char *nickname;
 445       SilcUInt32 nickname_len;
 446
 447       SILC_LOG_DEBUG(("NICK CHANGE notify"));
 448
 449       /* Get old client ID */
 450       if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 451         goto out;
 452
 453       /* Get new client ID */
 454       if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
 455         goto out;
 456
 457       SILC_LOG_DEBUG(("Old Client ID id(%s)",
 458                       silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CLIENT)));
 459       SILC_LOG_DEBUG(("New Client ID id(%s)",
 460                       silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CLIENT)));
 461
 462       /* From protocol version 1.1 we also get the new nickname */
 463       nickname = silc_argument_get_arg_type(args, 3, &nickname_len);;
 464
 465       /* Replace the Client ID */
 466       client = silc_idlist_replace_client_id(server,
 467                                              server->global_list,
 468                                              SILC_ID_GET_ID(id),
 469                                              SILC_ID_GET_ID(id2), nickname);
 470       if (!client)
 471         client = silc_idlist_replace_client_id(server,
 472                                                server->local_list,
 473                                                SILC_ID_GET_ID(id),
 474                                                SILC_ID_GET_ID(id2), nickname);
 475
 476       if (client) {
 477         /* Send the NICK_CHANGE notify type to local clients on the channels
 478            this client is joined to. */
 479         tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
 480         tmp2 = silc_argument_get_arg_type(args, 2, &tmp2_len);
 481         silc_server_send_notify_on_channels(server, client, client,
 482                                             SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
 483                                             tmp, tmp_len, tmp2, tmp2_len,
 484                                             nickname, nickname ?
 485                                             nickname_len : 0);
 486       }
 487
 488       break;
 489     }
 490
 491   case SILC_NOTIFY_TYPE_CMODE_CHANGE:
 492     /*
 493      * Distribute the notify to local clients on the channel
 494      */
 495
 496     SILC_LOG_DEBUG(("CMODE CHANGE notify"));
 497
 498     /* Get client ID */
 499     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 500       goto out;
 501
 502     /* Get client entry */
 503     if (id.type == SILC_ID_CLIENT) {
 504       client = silc_idlist_find_client_by_id(server->global_list,
 505                                              SILC_ID_GET_ID(id), TRUE, &cache);
 506       if (!client) {
 507         client = silc_idlist_find_client_by_id(server->local_list,
 508                                                SILC_ID_GET_ID(id),
 509                                                TRUE, &cache);
 510         if (!client)
 511           goto out;
 512       }
 513     }
 514
 515     if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
 516                         packet->dst_id_type, &channel_id,
 517                         sizeof(channel_id)))
 518       goto out;
 519
 520     /* Get channel entry */
 521     channel = silc_idlist_find_channel_by_id(server->global_list,
 522                                              &channel_id, NULL);
 523     if (!channel) {
 524       channel = silc_idlist_find_channel_by_id(server->local_list,
 525                                                &channel_id, NULL);
 526       if (!channel) {
 527         SILC_LOG_DEBUG(("Notify for unknown channel %s",
 528                         silc_id_render(&channel_id, SILC_ID_CHANNEL)));
 529         goto out;
 530       }
 531     }
 532
 533     /* Get the mode */
 534     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 535     if (!tmp)
 536       goto out;
 537     SILC_GET32_MSB(mode, tmp);
 538
 539     /* Check if mode changed */
 540     if (channel->mode == mode) {
 541       SILC_LOG_DEBUG(("Mode is changed already"));
 542
 543       /* If this mode change has founder mode then we'll enforce the
 544          change so that the server gets the real founder public key */
 545       if (server->server_type != SILC_SERVER &&
 546           sock != SILC_PRIMARY_ROUTE(server) &&
 547           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && channel->founder_key) {
 548         SILC_LOG_DEBUG(("Sending founder public key to server"));
 549         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 550                                       channel->mode, server->id,
 551                                       SILC_ID_SERVER, channel->cipher,
 552                                       channel->hmac_name,
 553                                       channel->passphrase,
 554                                       channel->founder_key, NULL);
 555       }
 556
 557       /* If we received same mode from our primary check whether founder
 558          mode and key in the notify is set.  We update the founder key
 559          here since we may have wrong one */
 560       if (server->server_type != SILC_ROUTER &&
 561           sock == SILC_PRIMARY_ROUTE(server) &&
 562           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 563         SILC_LOG_DEBUG(("Founder public key received from router"));
 564         tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
 565         if (!tmp)
 566           break;
 567
 568         if (channel->founder_key)
 569           silc_pkcs_public_key_free(channel->founder_key);
 570         channel->founder_key = NULL;
 571         silc_public_key_payload_decode(tmp, tmp_len,
 572                                        &channel->founder_key);
 573       }
 574
 575       /* Check also for channel public key list */
 576       if (server->server_type == SILC_SERVER &&
 577           sock == SILC_PRIMARY_ROUTE(server) &&
 578           mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
 579         SilcBuffer chpklist;
 580         SilcBuffer sidp;
 581         unsigned char mask[4], ulimit[4];
 582
 583         SILC_LOG_DEBUG(("Channel public key list received from router"));
 584         tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
 585         if (!tmp)
 586           break;
 587
 588         /* Set the router's list, and send the notify to channel too so that
 589            channel gets the list */
 590         silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
 591         chpklist = silc_server_get_channel_pk_list(server, channel,
 592                                                    FALSE, FALSE);
 593         if (!chpklist)
 594           break;
 595         sidp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
 596         SILC_PUT32_MSB(channel->mode, mask);
 597         if (channel->mode & SILC_CHANNEL_MODE_ULIMIT)
 598           SILC_PUT32_MSB(channel->user_limit, ulimit);
 599         silc_server_send_notify_to_channel(server, NULL, channel, FALSE, TRUE,
 600                                            SILC_NOTIFY_TYPE_CMODE_CHANGE, 8,
 601                                            sidp->data, silc_buffer_len(sidp),
 602                                            mask, 4,
 603                                            channel->cipher,
 604                                            channel->cipher ?
 605                                            strlen(channel->cipher) : 0,
 606                                            channel->hmac_name,
 607                                            channel->hmac_name ?
 608                                            strlen(channel->hmac_name) : 0,
 609                                            channel->passphrase,
 610                                            channel->passphrase ?
 611                                            strlen(channel->passphrase) : 0,
 612                                            NULL, 0,
 613                                            chpklist->data,
 614                                            silc_buffer_len(chpklist),
 615                                            (channel->mode &
 616                                             SILC_CHANNEL_MODE_ULIMIT ?
 617                                             ulimit : NULL),
 618                                            (channel->mode &
 619                                             SILC_CHANNEL_MODE_ULIMIT ?
 620                                             sizeof(ulimit) : 0));
 621         silc_buffer_free(sidp);
 622         silc_buffer_free(chpklist);
 623         goto out;
 624       }
 625
 626       break;
 627     }
 628
 629     /* Get user's channel entry and check that mode change is allowed */
 630     if (client) {
 631       if (!silc_server_client_on_channel(client, channel, &chl))
 632         goto out;
 633       if (!silc_server_check_cmode_rights(server, channel, chl, mode)) {
 634         SILC_LOG_DEBUG(("CMODE change is not allowed"));
 635         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 636                                       channel->mode, server->id,
 637                                       SILC_ID_SERVER, channel->cipher,
 638                                       channel->hmac_name,
 639                                       channel->passphrase,
 640                                       channel->founder_key, NULL);
 641         goto out;
 642       }
 643     } else {
 644       /* Assure that server is not removing founder mode from us */
 645       if (server->server_type == SILC_ROUTER &&
 646           sock != SILC_PRIMARY_ROUTE(server) &&
 647           channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH &&
 648           !(mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
 649         SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 650         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 651                                       channel->mode, server->id,
 652                                       SILC_ID_SERVER, channel->cipher,
 653                                       channel->hmac_name,
 654                                       channel->passphrase,
 655                                       channel->founder_key, NULL);
 656         goto out;
 657       }
 658
 659       /* If server is adding founder mode, check whether there is founder
 660          on channel already and is not from this server */
 661       if (server->server_type == SILC_ROUTER &&
 662           sock != SILC_PRIMARY_ROUTE(server) &&
 663           mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 664         silc_hash_table_list(channel->user_list, &htl);
 665         while (silc_hash_table_get(&htl, NULL, (void *)&chl))
 666           if (chl->mode & SILC_CHANNEL_UMODE_CHANFO &&
 667               chl->client->router != (SilcServerEntry)idata) {
 668             SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 669             silc_server_send_notify_cmode(server, sock, FALSE, channel,
 670                                           channel->mode, server->id,
 671                                           SILC_ID_SERVER, channel->cipher,
 672                                           channel->hmac_name,
 673                                           channel->passphrase,
 674                                           channel->founder_key, NULL);
 675             silc_hash_table_list_reset(&htl);
 676             goto out;
 677           }
 678         silc_hash_table_list_reset(&htl);
 679       }
 680     }
 681
 682     /* If the channel had private keys set and the mode was removed then
 683        we must re-generate and re-distribute a new channel key */
 684     if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY &&
 685         !(mode & SILC_CHANNEL_MODE_PRIVKEY)) {
 686       /* Re-generate channel key */
 687       if (!silc_server_create_channel_key(server, channel, 0))
 688         goto out;
 689
 690       /* Send the channel key. This sends it to our local clients and if
 691          we are normal server to our router as well. */
 692       silc_server_send_channel_key(server, NULL, channel,
 693                                    server->server_type == SILC_ROUTER ?
 694                                    FALSE : !server->standalone);
 695     }
 696
 697     /* Get the hmac */
 698     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 699     if (tmp) {
 700       unsigned char hash[SILC_HASH_MAXLEN];
 701
 702       if (channel->hmac)
 703         silc_hmac_free(channel->hmac);
 704       if (!silc_hmac_alloc(tmp, NULL, &channel->hmac))
 705         goto out;
 706
 707       /* Set the HMAC key out of current channel key. The client must do
 708          this locally. */
 709       silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key,
 710                      channel->key_len / 8, hash);
 711       silc_hmac_set_key(channel->hmac, hash,
 712                         silc_hash_len(silc_hmac_get_hash(channel->hmac)));
 713       memset(hash, 0, sizeof(hash));
 714     }
 715
 716     /* Get the passphrase */
 717     tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
 718     if (tmp) {
 719       silc_free(channel->passphrase);
 720       channel->passphrase = silc_memdup(tmp, tmp_len);
 721     }
 722
 723     /* Get founder public key */
 724     tmp = silc_argument_get_arg_type(args, 6, &tmp_len);
 725     if (tmp && mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) {
 726       if (channel->founder_key)
 727         silc_pkcs_public_key_free(channel->founder_key);
 728       channel->founder_key = NULL;
 729       SILC_LOG_DEBUG(("Founder public key received"));
 730       if (!silc_public_key_payload_decode(tmp, tmp_len,
 731                                           &channel->founder_key)) {
 732         SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 733         mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
 734         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 735                                       mode, server->id, SILC_ID_SERVER,
 736                                       channel->cipher,
 737                                       channel->hmac_name,
 738                                       channel->passphrase, NULL, NULL);
 739         if (channel->founder_key)
 740           silc_pkcs_public_key_free(channel->founder_key);
 741         channel->founder_key = NULL;
 742       }
 743     }
 744
 745     if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH && !channel->founder_key &&
 746         server->server_type == SILC_ROUTER) {
 747       SILC_LOG_DEBUG(("Enforcing sender to change channel mode"));
 748       mode &= ~SILC_CHANNEL_MODE_FOUNDER_AUTH;
 749       silc_server_send_notify_cmode(server, sock, FALSE, channel,
 750                                     mode, server->id, SILC_ID_SERVER,
 751                                     channel->cipher,
 752                                     channel->hmac_name,
 753                                     channel->passphrase, NULL, NULL);
 754     }
 755
 756     /* Process channel public key(s). */
 757     tmp = silc_argument_get_arg_type(args, 7, &tmp_len);
 758     if (tmp && mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) {
 759       SilcStatus ret;
 760       SILC_LOG_DEBUG(("Channel public key list received from router"));
 761
 762       ret =
 763         silc_server_set_channel_pk_list(server, sock, channel, tmp, tmp_len);
 764
 765       /* If list was set already we will enforce the same list to server. */
 766       if (ret == SILC_STATUS_ERR_OPERATION_ALLOWED) {
 767         SilcBuffer chpklist = silc_server_get_channel_pk_list(server, channel,
 768                                                               TRUE, FALSE);
 769         silc_server_send_notify_cmode(server, sock, FALSE, channel,
 770                                       mode, server->id, SILC_ID_SERVER,
 771                                       channel->cipher,
 772                                       channel->hmac_name,
 773                                       channel->passphrase, NULL,
 774                                       chpklist);
 775         silc_buffer_free(chpklist);
 776       }
 777     }
 778
 779     /* Get the user limit */
 780     tmp = silc_argument_get_arg_type(args, 8, &tmp_len);
 781     if (tmp && tmp_len == 4 && mode & SILC_CHANNEL_MODE_ULIMIT)
 782       SILC_GET32_MSB(channel->user_limit, tmp);
 783
 784     /* Send the same notify to the channel */
 785     silc_server_packet_send_to_channel(server, NULL, channel, packet->type,
 786                                        FALSE, TRUE, buffer->data,
 787                                        silc_buffer_len(buffer));
 788
 789     /* Change mode */
 790     channel->mode = mode;
 791
 792     /* Cleanup if some modes are removed */
 793
 794     if (!(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH) &&
 795         channel->founder_key) {
 796       silc_pkcs_public_key_free(channel->founder_key);
 797       channel->founder_key = NULL;
 798     }
 799
 800     if (!(channel->mode & SILC_CHANNEL_MODE_CHANNEL_AUTH) &&
 801         channel->channel_pubkeys) {
 802       silc_hash_table_free(channel->channel_pubkeys);
 803       channel->channel_pubkeys = NULL;
 804     }
 805
 806     break;
 807
 808   case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
 809     {
 810       /*
 811        * Distribute the notify to local clients on the channel
 812        */
 813       SilcChannelClientEntry chl2 = NULL;
 814       SilcBool notify_sent = FALSE;
 815
 816       SILC_LOG_DEBUG(("CUMODE CHANGE notify"));
 817
 818       /* Get client ID */
 819       if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
 820         goto out;
 821
 822       /* Get client entry */
 823       if (id.type == SILC_ID_CLIENT) {
 824         client = silc_idlist_find_client_by_id(server->global_list,
 825                                                SILC_ID_GET_ID(id),
 826                                                TRUE, &cache);
 827         if (!client) {
 828           client = silc_idlist_find_client_by_id(server->local_list,
 829                                                  SILC_ID_GET_ID(id),
 830                                                  TRUE, &cache);
 831           if (!client)
 832             goto out;
 833         }
 834       }
 835
 836       if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
 837                           packet->dst_id_type, &channel_id,
 838                           sizeof(channel_id)))
 839         goto out;
 840
 841       /* Get channel entry */
 842       channel = silc_idlist_find_channel_by_id(server->global_list,
 843                                                &channel_id, NULL);
 844       if (!channel) {
 845         channel = silc_idlist_find_channel_by_id(server->local_list,
 846                                                  &channel_id, NULL);
 847         if (!channel) {
 848           SILC_LOG_DEBUG(("Notify for unknown channel %s",
 849                           silc_id_render(&channel_id, SILC_ID_CHANNEL)));
 850           goto out;
 851         }
 852       }
 853
 854       /* Get the mode */
 855       tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
 856       if (!tmp)
 857         goto out;
 858
 859       SILC_GET32_MSB(mode, tmp);
 860
 861       /* Get target client */
 862       if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
 863         goto out;
 864
 865       /* Get client entry */
 866       client2 = silc_idlist_find_client_by_id(server->global_list,
 867                                               SILC_ID_GET_ID(id), TRUE, NULL);
 868       if (!client2) {
 869         client2 = silc_idlist_find_client_by_id(server->local_list,
 870                                                 SILC_ID_GET_ID(id),
 871                                                 TRUE, NULL);
 872         if (!client2)
 873           goto out;
 874       }
 875
 876       if (client) {
 877         /* Check that sender is on channel */
 878         if (!silc_server_client_on_channel(client, channel, &chl))
 879           goto out;
 880
 881         if (client != client2 && server->server_type == SILC_ROUTER) {
 882           /* Sender must be operator */
 883           if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
 884               !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
 885             SILC_LOG_DEBUG(("CUMODE change is not allowed"));
 886             goto out;
 887           }
 888
 889           if (!silc_server_client_on_channel(client2, channel, &chl))
 890             goto out;
 891
 892           /* If target is founder mode change is not allowed. */
 893           if (chl->mode & SILC_CHANNEL_UMODE_CHANFO) {
 894             SILC_LOG_DEBUG(("CUMODE change is not allowed"));
 895             goto out;
 896           }
 897         }
 898       }
 899
 900       /* Get target channel user entry */
 901       if (!silc_server_client_on_channel(client2, channel, &chl))
 902         goto out;
 903
 904       if (server->server_type == SILC_SERVER && chl->mode == mode) {
 905         SILC_LOG_DEBUG(("Mode is changed already"));
 906         break;
 907       }
 908
 909       /* Check whether to give founder rights to this user or not.  The
 910          problem here is that we get only the public key of the client,
 911          but no authentication data.  We must assume that server has
 912          already authenticated the user (and thus we must trust the
 913          server). */
 914       if (mode & SILC_CHANNEL_UMODE_CHANFO &&
 915           !(chl->mode & SILC_CHANNEL_UMODE_CHANFO) &&
 916           server->server_type == SILC_ROUTER &&
 917           sock != SILC_PRIMARY_ROUTE(server)) {
 918         SilcPublicKey founder_key = NULL;
 919
 920         /* If channel doesn't have founder auth mode then it's impossible
 921            that someone would be getting founder rights with CUMODE command.
 922            In that case there already either is founder or there isn't
 923            founder at all on the channel (valid only when 'client' is
 924            valid). */
 925         if (client && !(channel->mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)) {
 926           /* Force the mode to not have founder mode */
 927           chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 928           silc_server_force_cumode_change(server, sock, channel, chl, mode);
 929           notify_sent = TRUE;
 930           break;
 931         }
 932
 933         /* Get the founder of the channel and if found then this client
 934            cannot be the founder since there already is one. */
 935         silc_hash_table_list(channel->user_list, &htl);
 936         while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
 937           if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
 938             SILC_LOG_DEBUG(("Founder already on channel"));
 939             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 940             silc_server_force_cumode_change(server, sock, channel,
 941                                             chl, mode);
 942             notify_sent = TRUE;
 943             break;
 944           }
 945         silc_hash_table_list_reset(&htl);
 946         if (!(mode & SILC_CHANNEL_UMODE_CHANFO))
 947           break;
 948
 949         /* Founder not found on the channel.  Since the founder auth mode
 950            is set on the channel now check whether this is the client that
 951            originally set the mode. */
 952
 953         if (channel->founder_key) {
 954           /* Get public key that must be present in notify */
 955           tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
 956           if (!tmp || !silc_public_key_payload_decode(tmp, tmp_len,
 957                                                       &founder_key)) {
 958             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 959             SILC_LOG_DEBUG(("Founder public key not present"));
 960             silc_server_force_cumode_change(server, sock, channel, chl, mode);
 961             notify_sent = TRUE;
 962             break;
 963           }
 964
 965           /* Now match the public key we have cached and public key sent.
 966              They must match. */
 967           if (!silc_pkcs_public_key_compare(channel->founder_key,
 968                                             founder_key)) {
 969             chl->mode = mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 970             SILC_LOG_DEBUG(("Founder public key mismatch"));
 971             silc_server_force_cumode_change(server, sock, channel, chl, mode);
 972             notify_sent = TRUE;
 973             break;
 974           }
 975         }
 976
 977         /* There cannot be anyone else as founder on the channel now.  This
 978            client is definitely the founder due to this 'authentication'.
 979            We trust the server did the actual signature verification
 980            earlier (bad, yes). */
 981         silc_hash_table_list(channel->user_list, &htl);
 982         while (silc_hash_table_get(&htl, NULL, (void *)&chl2))
 983           if (chl2->mode & SILC_CHANNEL_UMODE_CHANFO) {
 984             chl2->mode &= ~SILC_CHANNEL_UMODE_CHANFO;
 985             SILC_LOG_DEBUG(("Removing old founder rights, new authenticated"));
 986             silc_server_force_cumode_change(server, NULL, channel, chl2,
 987                                             chl2->mode);
 988             break;
 989           }
 990         silc_hash_table_list_reset(&htl);
 991
 992         if (founder_key)
 993           silc_pkcs_public_key_free(founder_key);
 994       }
 995
 996       if (server->server_type != SILC_SERVER && chl->mode == mode) {
 997         SILC_LOG_DEBUG(("Mode is changed already"));
 998         break;
 999       }
1000
1001       SILC_LOG_DEBUG(("Changing %s channel user mode",
1002                       chl->client->nickname ? chl->client->nickname :
1003                       (unsigned char *)""));
1004
1005       /* Change the mode */
1006       chl->mode = mode;
1007
1008       /* Send the same notify to the channel */
1009       if (!notify_sent)
1010         silc_server_packet_send_to_channel(server, sock, channel,
1011                                            packet->type,
1012                                            FALSE, TRUE, buffer->data,
1013                                            silc_buffer_len(buffer));
1014
1015       break;
1016     }
1017
1018   case SILC_NOTIFY_TYPE_INVITE:
1019
1020     if (packet->dst_id_type == SILC_ID_CLIENT)
1021       goto out;
1022
1023     SILC_LOG_DEBUG(("INVITE notify"));
1024
1025     /* Get Channel ID */
1026     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1027       goto out;
1028
1029     /* Get channel entry */
1030     channel = silc_idlist_find_channel_by_id(server->global_list,
1031                                              SILC_ID_GET_ID(id), NULL);
1032     if (!channel) {
1033       channel = silc_idlist_find_channel_by_id(server->local_list,
1034                                                SILC_ID_GET_ID(id), NULL);
1035       if (!channel) {
1036         SILC_LOG_DEBUG(("Notify for unknown channel %s",
1037                         silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1038         goto out;
1039       }
1040     }
1041
1042     /* Get the invite action */
1043     tmp = silc_argument_get_arg_type(args, 4, &tmp_len);
1044     if (tmp && tmp_len == 1) {
1045       SilcUInt8 action = (SilcUInt8)tmp[0];
1046       SilcUInt16 iargc = 0;
1047       SilcArgumentPayload iargs;
1048
1049       /* Get invite list */
1050       tmp = silc_argument_get_arg_type(args, 5, &tmp_len);
1051       if (!tmp || tmp_len < 2)
1052         goto out;
1053
1054       /* Parse the arguments to see they are constructed correctly */
1055       SILC_GET16_MSB(iargc, tmp);
1056       iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1057       if (!iargs)
1058         goto out;
1059
1060       if (!channel->invite_list)
1061         channel->invite_list =
1062           silc_hash_table_alloc(0, silc_hash_ptr,
1063                                 NULL, NULL, NULL,
1064                                 silc_server_inviteban_destruct, channel, TRUE);
1065
1066       /* Proces the invite action */
1067       if (!silc_server_inviteban_process(server, channel->invite_list, action,
1068                                          iargs))
1069         goto out;
1070       silc_argument_payload_free(iargs);
1071
1072       /* If we are router we must send this notify to our local servers on
1073          the channel.  Normal server does nothing.  The notify is not
1074          sent to clients. */
1075       if (server->server_type == SILC_ROUTER)
1076         silc_server_packet_send_to_channel(server, sock, channel,
1077                                            packet->type, FALSE, FALSE,
1078                                            buffer->data,
1079                                            silc_buffer_len(buffer));
1080     }
1081
1082     break;
1083
1084   case SILC_NOTIFY_TYPE_CHANNEL_CHANGE:
1085     /*
1086      * Distribute to the local clients on the channel and change the
1087      * channel ID.
1088      */
1089
1090     SILC_LOG_DEBUG(("CHANNEL CHANGE"));
1091
1092     if (idata->conn_type != SILC_CONN_ROUTER)
1093       break;
1094
1095     /* Get the old Channel ID */
1096     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1097       goto out;
1098
1099     /* Get the channel entry */
1100     channel = silc_idlist_find_channel_by_id(server->local_list,
1101                                              SILC_ID_GET_ID(id), NULL);
1102     if (!channel) {
1103       channel = silc_idlist_find_channel_by_id(server->global_list,
1104                                                SILC_ID_GET_ID(id), NULL);
1105       if (!channel) {
1106         SILC_LOG_DEBUG(("Notify for unknown channel %s",
1107                         silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1108         goto out;
1109       }
1110     }
1111
1112     /* Send the notify to the channel */
1113     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1114                                        FALSE, TRUE, buffer->data,
1115                                        silc_buffer_len(buffer));
1116
1117     /* Get the new Channel ID */
1118     if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id2, NULL))
1119       goto out;
1120
1121     SILC_LOG_DEBUG(("Old Channel ID id(%s)",
1122                     silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1123     SILC_LOG_DEBUG(("New Channel ID id(%s)",
1124                     silc_id_render(SILC_ID_GET_ID(id2), SILC_ID_CHANNEL)));
1125
1126     /* Replace the Channel ID */
1127     ret = TRUE;
1128     if (!silc_idlist_replace_channel_id(server->local_list,
1129                                         SILC_ID_GET_ID(id),
1130                                         SILC_ID_GET_ID(id2)))
1131       if (!silc_idlist_replace_channel_id(server->global_list,
1132                                           SILC_ID_GET_ID(id),
1133                                           SILC_ID_GET_ID(id2)))
1134         ret = FALSE;
1135
1136     if (ret) {
1137       SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
1138
1139       /* Re-announce this channel which ID was changed. */
1140       silc_server_send_new_channel(server, sock, FALSE, channel->channel_name,
1141                                    channel->id,
1142                                    silc_id_get_len(channel->id,
1143                                                    SILC_ID_CHANNEL),
1144                                    channel->mode);
1145
1146       /* Re-announce our clients on the channel as the ID has changed now */
1147       silc_server_announce_get_channel_users(server, channel, &modes, &users,
1148                                              &users_modes);
1149       if (users) {
1150         silc_buffer_push(users, users->data - users->head);
1151         silc_server_packet_send(server, sock,
1152                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1153                                 users->data, silc_buffer_len(users));
1154         silc_buffer_free(users);
1155       }
1156       if (modes) {
1157         silc_buffer_push(modes, modes->data - modes->head);
1158         silc_server_packet_send_dest(server, sock,
1159                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1160                                      channel->id, SILC_ID_CHANNEL,
1161                                      modes->data, silc_buffer_len(modes));
1162         silc_buffer_free(modes);
1163       }
1164       if (users_modes) {
1165         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
1166         silc_server_packet_send_dest(server, sock,
1167                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
1168                                      channel->id, SILC_ID_CHANNEL,
1169                                      users_modes->data,
1170                                      silc_buffer_len(users_modes));
1171         silc_buffer_free(users_modes);
1172       }
1173
1174       /* Re-announce channel's topic */
1175       if (channel->topic) {
1176         silc_server_send_notify_topic_set(server, sock,
1177                                           server->server_type == SILC_ROUTER ?
1178                                           TRUE : FALSE, channel,
1179                                           server->id, SILC_ID_SERVER,
1180                                           channel->topic);
1181       }
1182     }
1183
1184     break;
1185
1186   case SILC_NOTIFY_TYPE_SERVER_SIGNOFF:
1187     /*
1188      * Remove the server entry and all clients that this server owns.
1189      */
1190
1191     SILC_LOG_DEBUG(("SERVER SIGNOFF notify"));
1192
1193     /* Backup router shouldn't accept SERVER_SIGNOFF's from normal routers
1194        when the backup isn't acting as primary router. */
1195     if (idata->conn_type == SILC_CONN_SERVER &&
1196         server->backup_router && server->server_type == SILC_BACKUP_ROUTER)
1197       return;
1198
1199     /* Get Server ID */
1200     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1201       goto out;
1202
1203     /* If the ID is mine, this notify is not allowed. */
1204     if (SILC_ID_SERVER_COMPARE(SILC_ID_GET_ID(id), server->id)) {
1205       SILC_LOG_DEBUG(("Ignoring my own ID for SERVER_SIGNOFF"));
1206       break;
1207     }
1208
1209     /* Get server entry */
1210     server_entry = silc_idlist_find_server_by_id(server->global_list,
1211                                                  SILC_ID_GET_ID(id),
1212                                                  TRUE, NULL);
1213     local = FALSE;
1214     if (!server_entry) {
1215       server_entry = silc_idlist_find_server_by_id(server->local_list,
1216                                                    SILC_ID_GET_ID(id),
1217                                                    TRUE, NULL);
1218       local = TRUE;
1219       if (!server_entry) {
1220         /* If we are normal server then we might not have the server. Check
1221            whether router was kind enough to send the list of all clients
1222            that actually was to be removed. Remove them if the list is
1223            available. */
1224         if (server->server_type != SILC_ROUTER &&
1225             silc_argument_get_arg_num(args) > 1) {
1226           int i;
1227
1228           for (i = 1; i < silc_argument_get_arg_num(args); i++) {
1229             /* Get Client ID */
1230             if (!silc_argument_get_decoded(args, i + 1, SILC_ARGUMENT_ID,
1231                                            &id2, NULL))
1232               continue;
1233
1234             /* Get client entry */
1235             client = silc_idlist_find_client_by_id(server->global_list,
1236                                                    SILC_ID_GET_ID(id2),
1237                                                    TRUE, &cache);
1238             local = FALSE;
1239             if (!client) {
1240               client = silc_idlist_find_client_by_id(server->local_list,
1241                                                      SILC_ID_GET_ID(id2),
1242                                                      TRUE, &cache);
1243               local = TRUE;
1244               if (!client)
1245                 continue;
1246             }
1247
1248             /* Update statistics */
1249             SILC_VERIFY(server->stat.clients > 0);
1250             server->stat.clients--;
1251             if (server->stat.cell_clients)
1252               server->stat.cell_clients--;
1253             SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1254             SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1255
1256             /* Remove the client from all channels. */
1257             silc_server_remove_from_channels(server, NULL, client,
1258                                              TRUE, NULL, FALSE, FALSE);
1259
1260             /* Check if anyone is watching this nickname */
1261             if (server->server_type == SILC_ROUTER)
1262               silc_server_check_watcher_list(server, client, NULL,
1263                                              SILC_NOTIFY_TYPE_SERVER_SIGNOFF);
1264
1265             /* Remove this client from watcher list if it is */
1266             if (local)
1267               silc_server_del_from_watcher_list(server, client);
1268
1269             /* Remove the client */
1270             silc_dlist_del(server->expired_clients, client);
1271             silc_idlist_del_data(client);
1272             silc_idlist_del_client(local ? server->local_list :
1273                                    server->global_list, client);
1274           }
1275         }
1276
1277         goto out;
1278       }
1279     }
1280
1281     /* For local entrys SERVER_SIGNOFF is processed only on backup router.
1282        It is possible that router sends server signoff for a server.  If
1283        backup router has it as local connection it will be closed. */
1284     if (SILC_IS_LOCAL(server_entry)) {
1285       if (server->server_type == SILC_BACKUP_ROUTER) {
1286         sock = server_entry->connection;
1287         SILC_LOG_DEBUG(("Closing connection after SERVER_SIGNOFF"));
1288         silc_server_free_sock_user_data(server, sock, NULL);
1289         silc_server_close_connection(server, sock);
1290       }
1291
1292       break;
1293     }
1294
1295     /* Remove all servers that are originated from this server, and
1296        remove the clients of those servers too. */
1297     silc_server_remove_servers_by_server(server, server_entry, TRUE);
1298
1299     /* Remove the clients that this server owns as they will become
1300        invalid now too. */
1301     silc_server_remove_clients_by_server(server, server_entry->router,
1302                                          server_entry, TRUE);
1303     silc_server_backup_del(server, server_entry);
1304
1305     /* Remove the server entry */
1306     silc_idlist_del_server(local ? server->local_list :
1307                            server->global_list, server_entry);
1308
1309     /* Update statistics */
1310     if (server->server_type == SILC_ROUTER)
1311       server->stat.servers--;
1312
1313     break;
1314
1315   case SILC_NOTIFY_TYPE_KICKED:
1316     /*
1317      * Distribute the notify to local clients on the channel
1318      */
1319
1320     SILC_LOG_DEBUG(("KICKED notify"));
1321
1322     if (!silc_id_str2id(packet->dst_id, packet->dst_id_len,
1323                         packet->dst_id_type, &channel_id,
1324                         sizeof(channel_id)))
1325       goto out;
1326
1327     /* Get channel entry */
1328     channel = silc_idlist_find_channel_by_id(server->global_list,
1329                                              &channel_id, NULL);
1330     if (!channel) {
1331       channel = silc_idlist_find_channel_by_id(server->local_list,
1332                                                &channel_id, NULL);
1333       if (!channel) {
1334         SILC_LOG_DEBUG(("Notify for unknown channel %s",
1335                         silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1336         goto out;
1337       }
1338     }
1339
1340     /* Get client ID */
1341     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1342       goto out;
1343
1344     /* If the the client is not in local list we check global list */
1345     client = silc_idlist_find_client_by_id(server->global_list,
1346                                            SILC_ID_GET_ID(id), TRUE, NULL);
1347     if (!client) {
1348       client = silc_idlist_find_client_by_id(server->local_list,
1349                                              SILC_ID_GET_ID(id), TRUE, NULL);
1350       if (!client)
1351         goto out;
1352     }
1353
1354     /* If target is founder they cannot be kicked */
1355     if (!silc_server_client_on_channel(client, channel, &chl))
1356       goto out;
1357     if (chl->mode & SILC_CHANNEL_UMODE_CHANFO)
1358       goto out;
1359
1360     /* Get the kicker's Client ID */
1361     if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1362       goto out;
1363
1364     /* If the the client is not in local list we check global list */
1365     client2 = silc_idlist_find_client_by_id(server->global_list,
1366                                             SILC_ID_GET_ID(id), TRUE, NULL);
1367     if (!client2) {
1368       client2 = silc_idlist_find_client_by_id(server->local_list,
1369                                               SILC_ID_GET_ID(id), TRUE, NULL);
1370       if (!client2)
1371         goto out;
1372     }
1373
1374     /* Kicker must be operator on channel */
1375     if (!silc_server_client_on_channel(client2, channel, &chl))
1376       goto out;
1377     if (!(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
1378         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
1379       SILC_LOG_DEBUG(("Kicking is not allowed"));
1380       goto out;
1381     }
1382
1383     /* Send to channel */
1384     silc_server_packet_send_to_channel(server, sock, channel, packet->type,
1385                                        FALSE, TRUE, buffer->data,
1386                                        silc_buffer_len(buffer));
1387
1388     /* Remove the client from channel's invite list */
1389     if (channel->invite_list && silc_hash_table_count(channel->invite_list)) {
1390       SilcBuffer ab;
1391       SilcArgumentPayload iargs;
1392       tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1393       ab = silc_argument_payload_encode_one(NULL, tmp, tmp_len, 3);
1394       iargs = silc_argument_payload_parse(ab->data, silc_buffer_len(ab), 1);
1395       silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
1396       silc_buffer_free(ab);
1397       silc_argument_payload_free(iargs);
1398     }
1399
1400     /* Remove the client from channel */
1401     silc_server_remove_from_one_channel(server, sock, channel, client, FALSE);
1402
1403     break;
1404
1405   case SILC_NOTIFY_TYPE_KILLED:
1406     {
1407       /*
1408        * Distribute the notify to local clients on channels
1409        */
1410       unsigned char *comment;
1411       SilcUInt32 comment_len;
1412
1413       SILC_LOG_DEBUG(("KILLED notify"));
1414
1415       /* Get client ID */
1416       if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1417         goto out;
1418
1419       /* If the the client is not in local list we check global list */
1420       client = silc_idlist_find_client_by_id(server->global_list,
1421                                              SILC_ID_GET_ID(id), TRUE, &cache);
1422       if (!client) {
1423         client = silc_idlist_find_client_by_id(server->local_list,
1424                                                SILC_ID_GET_ID(id),
1425                                                TRUE, &cache);
1426         if (!client)
1427           goto out;
1428       }
1429
1430       /* If the client is one of ours, then close the connection to the
1431          client now. This removes the client from all channels as well. */
1432       if (packet->dst_id_type == SILC_ID_CLIENT && client->connection) {
1433         sock = client->connection;
1434         silc_server_free_client_data(server, NULL, client, FALSE, NULL);
1435         silc_server_close_connection(server, sock);
1436         break;
1437       }
1438
1439       /* Get comment */
1440       comment = silc_argument_get_arg_type(args, 2, &comment_len);
1441       if (comment_len > 128)
1442         comment_len = 127;
1443
1444       /* Get the killer's Client ID */
1445       if (!silc_argument_get_decoded(args, 3, SILC_ARGUMENT_ID, &id, NULL))
1446         goto out;
1447
1448       if (id.type == SILC_ID_CLIENT) {
1449         /* If the the client is not in local list we check global list */
1450         client2 = silc_idlist_find_client_by_id(server->global_list,
1451                                                 SILC_ID_GET_ID(id),
1452                                                 TRUE, NULL);
1453         if (!client2) {
1454           client2 = silc_idlist_find_client_by_id(server->local_list,
1455                                                   SILC_ID_GET_ID(id),
1456                                                   TRUE, NULL);
1457           if (!client2)
1458             goto out;
1459         }
1460
1461         /* Killer must be router operator */
1462         if (server->server_type != SILC_SERVER &&
1463             !(client2->mode & SILC_UMODE_ROUTER_OPERATOR)) {
1464           SILC_LOG_DEBUG(("Killing is not allowed"));
1465           goto out;
1466         }
1467       }
1468
1469       /* Send the notify to local clients on the channels except to the
1470          client who is killed. */
1471       tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1472       tmp2 = silc_argument_get_arg_type(args, 3, &tmp2_len);
1473       silc_server_send_notify_on_channels(server, client, client,
1474                                           SILC_NOTIFY_TYPE_KILLED, 3,
1475                                           tmp, tmp_len, comment, comment_len,
1476                                           tmp2, tmp2_len);
1477
1478       /* Remove the client from all channels */
1479       silc_server_remove_from_channels(server, NULL, client, FALSE, NULL,
1480                                        FALSE, TRUE);
1481
1482       /* Check if anyone is watching this nickname */
1483       if (server->server_type == SILC_ROUTER)
1484         silc_server_check_watcher_list(server, client, NULL,
1485                                        SILC_NOTIFY_TYPE_KILLED);
1486
1487       /* Remove client's public key from repository, this will free it too. */
1488       if (client->data.public_key) {
1489         silc_skr_del_public_key(server->repository, client->data.public_key,
1490                                 client);
1491         client->data.public_key = NULL;
1492       }
1493
1494       /* Update statistics */
1495       SILC_VERIFY(server->stat.clients > 0);
1496       server->stat.clients--;
1497       if (server->stat.cell_clients)
1498         server->stat.cell_clients--;
1499       SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
1500       SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
1501
1502       if (SILC_IS_LOCAL(client)) {
1503         if (!client->local_detached)
1504           server->stat.my_clients--;
1505         silc_schedule_task_del_by_context(server->schedule, client);
1506         silc_idlist_del_data(client);
1507         client->mode = 0;
1508       }
1509
1510       client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
1511       client->mode = 0;
1512       client->router = NULL;
1513       client->connection = NULL;
1514       client->data.created = silc_time();
1515       silc_dlist_del(server->expired_clients, client);
1516       silc_dlist_add(server->expired_clients, client);
1517       break;
1518     }
1519
1520   case SILC_NOTIFY_TYPE_UMODE_CHANGE:
1521     /*
1522      * Save the mode of the client.
1523      */
1524
1525     SILC_LOG_DEBUG(("UMODE_CHANGE notify"));
1526
1527     /* Get client ID */
1528     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1529       goto out;
1530
1531     /* Get client entry */
1532     client = silc_idlist_find_client_by_id(server->global_list,
1533                                            SILC_ID_GET_ID(id), TRUE, NULL);
1534     if (!client) {
1535       client = silc_idlist_find_client_by_id(server->local_list,
1536                                              SILC_ID_GET_ID(id), TRUE, NULL);
1537       if (!client)
1538         goto out;
1539     }
1540
1541     /* Get the mode */
1542     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1543     if (!tmp)
1544       goto out;
1545     SILC_GET32_MSB(mode, tmp);
1546
1547     /* Remove internal resumed flag if client is marked detached now */
1548     if (mode & SILC_UMODE_DETACHED)
1549       client->data.status &= ~SILC_IDLIST_STATUS_RESUMED;
1550
1551     /* Update statistics */
1552     if (server->server_type == SILC_ROUTER) {
1553       if (mode & SILC_UMODE_GONE) {
1554         if (!(client->mode & SILC_UMODE_GONE))
1555           server->stat.aways++;
1556       } else {
1557         if (client->mode & SILC_UMODE_GONE)
1558           server->stat.aways--;
1559       }
1560       if (mode & SILC_UMODE_DETACHED) {
1561         if (!(client->mode & SILC_UMODE_DETACHED))
1562           server->stat.detached++;
1563       } else {
1564         if (client->mode & SILC_UMODE_DETACHED)
1565           server->stat.detached--;
1566       }
1567     }
1568     SILC_UMODE_STATS_UPDATE(server, SILC_UMODE_SERVER_OPERATOR);
1569     SILC_UMODE_STATS_UPDATE(router, SILC_UMODE_ROUTER_OPERATOR);
1570
1571     /* Change the mode */
1572     client->mode = mode;
1573
1574     /* Check if anyone is watching this nickname */
1575     if (server->server_type == SILC_ROUTER)
1576       silc_server_check_watcher_list(server, client, NULL,
1577                                      SILC_NOTIFY_TYPE_UMODE_CHANGE);
1578
1579     break;
1580
1581   case SILC_NOTIFY_TYPE_BAN:
1582     /*
1583      * Save the ban
1584      */
1585
1586     SILC_LOG_DEBUG(("BAN notify"));
1587
1588     /* Get Channel ID */
1589     if (!silc_argument_get_decoded(args, 1, SILC_ARGUMENT_ID, &id, NULL))
1590       goto out;
1591
1592     /* Get channel entry */
1593     channel = silc_idlist_find_channel_by_id(server->global_list,
1594                                              SILC_ID_GET_ID(id), NULL);
1595     if (!channel) {
1596       channel = silc_idlist_find_channel_by_id(server->local_list,
1597                                                SILC_ID_GET_ID(id), NULL);
1598       if (!channel) {
1599         SILC_LOG_DEBUG(("Notify for unknown channel %s",
1600                         silc_id_render(SILC_ID_GET_ID(id), SILC_ID_CHANNEL)));
1601         goto out;
1602       }
1603     }
1604
1605     /* Get the ban action */
1606     tmp = silc_argument_get_arg_type(args, 2, &tmp_len);
1607     if (tmp && tmp_len == 1) {
1608       SilcUInt8 action = (SilcUInt8)tmp[0];
1609       SilcUInt16 iargc = 0;
1610       SilcArgumentPayload iargs;
1611
1612       /* Get ban list */
1613       tmp = silc_argument_get_arg_type(args, 3, &tmp_len);
1614       if (!tmp || tmp_len < 2)
1615         goto out;
1616
1617       /* Parse the arguments to see they are constructed correctly */
1618       SILC_GET16_MSB(iargc, tmp);
1619       iargs = silc_argument_payload_parse(tmp + 2, tmp_len - 2, iargc);
1620       if (!iargs)
1621         goto out;
1622
1623       if (!channel->ban_list)
1624         channel->ban_list =
1625           silc_hash_table_alloc(0, silc_hash_ptr,
1626                                 NULL, NULL, NULL,
1627                                 silc_server_inviteban_destruct, channel, TRUE);
1628
1629       /* Proces the ban action */
1630       if (!silc_server_inviteban_process(server, channel->ban_list, action,
1631                                          iargs))
1632         goto out;
1633       silc_argument_payload_free(iargs);
1634
1635       /* If we are router we must send this notify to our local servers on
1636          the channel.  Normal server does nothing.  The notify is not
1637          sent to clients. */
1638       if (server->server_type == SILC_ROUTER)
1639         silc_server_packet_send_to_channel(server, sock, channel,
1640                                            packet->type, FALSE, FALSE,
1641                                            buffer->data,
1642                                            silc_buffer_len(buffer));
1643     }
1644     break;
1645
1646   case SILC_NOTIFY_TYPE_ERROR:
1647     {
1648       /*
1649        * Error notify
1650        */
1651       SilcStatus error;
1652
1653       tmp = silc_argument_get_arg_type(args, 1, &tmp_len);
1654       if (!tmp && tmp_len != 1)
1655         goto out;
1656       error = (SilcStatus)tmp[0];
1657
1658       SILC_LOG_DEBUG(("ERROR notify (%d)", error));
1659
1660       if (error == SILC_STATUS_ERR_NO_SUCH_CLIENT_ID &&
1661           idata->conn_type == SILC_CONN_ROUTER) {
1662         if (!silc_argument_get_decoded(args, 2, SILC_ARGUMENT_ID, &id, NULL))
1663           goto out;
1664
1665         SILC_LOG_DEBUG(("Received invalid client ID notification, deleting "
1666                         "the entry from cache"));
1667
1668         client = silc_idlist_find_client_by_id(server->global_list,
1669                                                SILC_ID_GET_ID(id),
1670                                                FALSE, NULL);
1671         if (!client)
1672           goto out;
1673
1674         silc_server_remove_from_channels(server, NULL, client, TRUE,
1675                                          NULL, TRUE, FALSE);
1676         silc_dlist_del(server->expired_clients, client);
1677         silc_idlist_del_data(client);
1678         silc_idlist_del_client(server->global_list, client);
1679       }
1680     }
1681     break;
1682
1683     /* Ignore rest of the notify types for now */
1684   case SILC_NOTIFY_TYPE_NONE:
1685   case SILC_NOTIFY_TYPE_MOTD:
1686     break;
1687
1688   default:
1689     SILC_LOG_DEBUG(("Unsupported notify %d", type));
1690     break;
1691   }
1692
1693  out:
1694   silc_notify_payload_free(payload);
1695 }
1696
1697 void silc_server_notify(SilcServer server,
1698                         SilcPacketStream sock,
1699                         SilcPacket packet)
1700 {
1701   silc_server_notify_process(server, sock, packet, &packet->buffer);
1702   silc_packet_free(packet);
1703 }
1704
1705 void silc_server_notify_list(SilcServer server,
1706                              SilcPacketStream sock,
1707                              SilcPacket packet)
1708 {
1709   SilcIDListData idata = silc_packet_get_context(sock);
1710   SilcUInt16 len;
1711   SilcBuffer buffer;
1712
1713   SILC_LOG_DEBUG(("Processing Notify List"));
1714
1715   if (idata->conn_type == SILC_CONN_CLIENT ||
1716       packet->src_id_type != SILC_ID_SERVER)
1717     return;
1718
1719   buffer = silc_buffer_alloc(1024);
1720   if (!buffer)
1721     return;
1722
1723   while (silc_buffer_len(&packet->buffer)) {
1724     SILC_GET16_MSB(len, packet->buffer.data + 2);
1725     if (len > silc_buffer_len(&packet->buffer))
1726       break;
1727
1728     if (len > silc_buffer_truelen(buffer)) {
1729       silc_buffer_free(buffer);
1730       buffer = silc_buffer_alloc(1024 + len);
1731     }
1732
1733     silc_buffer_pull_tail(buffer, len);
1734     silc_buffer_put(buffer, packet->buffer.data, len);
1735
1736     /* Process the Notify */
1737     silc_server_notify_process(server, sock, packet, buffer);
1738
1739     silc_buffer_push_tail(buffer, len);
1740     silc_buffer_pull(&packet->buffer, len);
1741   }
1742
1743   silc_packet_free(packet);
1744   silc_buffer_free(buffer);
1745 }
1746
1747 /* Received private message. This resolves the destination of the message
1748    and sends the packet. This is used by both server and router.  If the
1749    destination is our locally connected client this sends the packet to
1750    the client. This may also send the message for further routing if
1751    the destination is not in our server (or router). */
1752
1753 void silc_server_private_message(SilcServer server,
1754                                  SilcPacketStream sock,
1755                                  SilcPacket packet)
1756 {
1757   SilcPacketStream dst_sock;
1758   SilcIDListData idata;
1759   SilcClientEntry client;
1760   SilcClientID client_id;
1761
1762   SILC_LOG_DEBUG(("Start"));
1763
1764   if (packet->src_id_type != SILC_ID_CLIENT ||
1765       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id)
1766     goto out;
1767
1768   /* Get the route to the client */
1769   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1770                                           packet->dst_id_len, NULL,
1771                                           &idata, &client);
1772   if (!dst_sock) {
1773     SilcBuffer idp;
1774     unsigned char error;
1775
1776     if (client && client->mode & SILC_UMODE_DETACHED) {
1777       SILC_LOG_DEBUG(("Client is detached, discarding packet"));
1778       goto out;
1779     }
1780
1781     /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1782        does not exist or is invalid. */
1783     idp = silc_id_payload_encode_data(packet->dst_id,
1784                                       packet->dst_id_len,
1785                                       packet->dst_id_type);
1786     if (!idp)
1787       goto out;
1788
1789     error = SILC_STATUS_ERR_NO_SUCH_CLIENT_ID;
1790     if (packet->src_id_type == SILC_ID_CLIENT) {
1791       silc_id_str2id(packet->src_id, packet->src_id_len,
1792                      packet->src_id_type, &client_id, sizeof(client_id));
1793       silc_server_send_notify_dest(server, sock, FALSE,
1794                                    &client_id, SILC_ID_CLIENT,
1795                                    SILC_NOTIFY_TYPE_ERROR, 2,
1796                                    &error, 1,
1797                                    idp->data, silc_buffer_len(idp));
1798     } else {
1799       silc_server_send_notify(server, sock, FALSE,
1800                               SILC_NOTIFY_TYPE_ERROR, 2,
1801                               &error, 1,
1802                               idp->data, silc_buffer_len(idp));
1803     }
1804
1805     silc_buffer_free(idp);
1806     goto out;
1807   }
1808
1809   /* Check whether destination client wishes to receive private messages */
1810   if (client && !(packet->flags & SILC_PACKET_FLAG_PRIVMSG_KEY) &&
1811       client->mode & SILC_UMODE_BLOCK_PRIVMSG) {
1812     SILC_LOG_DEBUG(("Client blocks private messages, discarding packet"));
1813     goto out;
1814   }
1815
1816   /* Send the private message */
1817   silc_server_packet_route(server, dst_sock, packet);
1818
1819  out:
1820   silc_packet_free(packet);
1821 }
1822
1823 /* Received private message key packet.. This packet is never for us. It is to
1824    the client in the packet's destination ID. Sending of this sort of packet
1825    equals sending private message, ie. it is sent point to point from
1826    one client to another. */
1827
1828 void silc_server_private_message_key(SilcServer server,
1829                                      SilcPacketStream sock,
1830                                      SilcPacket packet)
1831 {
1832   SilcPacketStream dst_sock;
1833   SilcIDListData idata;
1834
1835   SILC_LOG_DEBUG(("Start"));
1836
1837   if (packet->src_id_type != SILC_ID_CLIENT ||
1838       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
1839     silc_packet_free(packet);
1840     return;
1841   }
1842
1843   /* Get the route to the client */
1844   dst_sock = silc_server_get_client_route(server, packet->dst_id,
1845                                           packet->dst_id_len, NULL,
1846                                           &idata, NULL);
1847   if (!dst_sock) {
1848     silc_packet_free(packet);
1849     return;
1850   }
1851
1852   /* Relay the packet */
1853   silc_server_packet_route(server, dst_sock, packet);
1854
1855   silc_packet_free(packet);
1856 }
1857
1858 /* Processes incoming command reply packet. The command reply packet may
1859    be destined to one of our clients or it may directly for us. We will
1860    call the command reply routine after processing the packet. */
1861
1862 void silc_server_command_reply(SilcServer server,
1863                                SilcPacketStream sock,
1864                                SilcPacket packet)
1865 {
1866   SilcBuffer buffer = &packet->buffer;
1867   SilcClientEntry client = NULL;
1868   SilcClientID id;
1869
1870   SILC_LOG_DEBUG(("Start"));
1871
1872   if (packet->dst_id_type == SILC_ID_CHANNEL) {
1873     silc_packet_free(packet);
1874     return;
1875   }
1876
1877   if (packet->dst_id_type == SILC_ID_CLIENT) {
1878     /* Destination must be one of ours */
1879     if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CLIENT,
1880                         &id, sizeof(id))) {
1881       silc_packet_free(packet);
1882       return;
1883     }
1884     client = silc_idlist_find_client_by_id(server->local_list, &id,
1885                                            TRUE, NULL);
1886     if (!client) {
1887       SILC_LOG_ERROR(("Cannot process command reply to unknown client"));
1888       silc_packet_free(packet);
1889       return;
1890     }
1891   }
1892
1893   if (packet->dst_id_type == SILC_ID_SERVER) {
1894     /* For now this must be for us */
1895     if (memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
1896       SILC_LOG_ERROR(("Cannot process command reply to unknown server"));
1897       silc_packet_free(packet);
1898       return;
1899     }
1900   }
1901
1902   /* Execute command reply locally for the command */
1903   silc_server_command_reply_process(server, sock, buffer);
1904
1905   /* Relay the packet to the client */
1906   if (packet->dst_id_type == SILC_ID_CLIENT && client)
1907     silc_server_packet_route(server, client->connection, packet);
1908
1909   silc_packet_free(packet);
1910 }
1911
1912 /* Process received channel message. The message can be originated from
1913    client or server. */
1914
1915 void silc_server_channel_message(SilcServer server,
1916                                  SilcPacketStream sock,
1917                                  SilcPacket packet)
1918 {
1919   SilcChannelEntry channel = NULL;
1920   SilcChannelID id;
1921   SilcClientID cid;
1922   SilcID sid;
1923   SilcClientEntry sender_entry = NULL;
1924   SilcIDListData idata;
1925   SilcChannelClientEntry chl;
1926   SilcBool local = TRUE;
1927
1928   SILC_LOG_DEBUG(("Processing channel message"));
1929
1930   /* Sanity checks */
1931   if (packet->dst_id_type != SILC_ID_CHANNEL) {
1932     SILC_LOG_DEBUG(("Received bad message for channel, dropped"));
1933     goto out;
1934   }
1935
1936   /* Find channel entry */
1937   if (!silc_id_str2id(packet->dst_id, packet->dst_id_len, SILC_ID_CHANNEL,
1938                       &id, sizeof(id)))
1939     goto out;
1940   channel = silc_idlist_find_channel_by_id(server->local_list, &id, NULL);
1941   if (!channel) {
1942     channel = silc_idlist_find_channel_by_id(server->global_list, &id, NULL);
1943     if (!channel) {
1944       SilcBuffer idp;
1945       unsigned char error;
1946
1947       /* Send SILC_NOTIFY_TYPE_ERROR to indicate that such destination ID
1948          does not exist or is invalid. */
1949       idp = silc_id_payload_encode_data(packet->dst_id,
1950                                         packet->dst_id_len,
1951                                         packet->dst_id_type);
1952       if (!idp)
1953         goto out;
1954
1955       error = SILC_STATUS_ERR_NO_SUCH_CHANNEL_ID;
1956       if (packet->src_id_type == SILC_ID_CLIENT) {
1957         silc_id_str2id(packet->src_id, packet->src_id_len,
1958                        packet->src_id_type, &cid, sizeof(cid));
1959         silc_server_send_notify_dest(server, sock, FALSE,
1960                                      &cid, SILC_ID_CLIENT,
1961                                      SILC_NOTIFY_TYPE_ERROR, 2,
1962                                      &error, 1, idp->data,
1963                                      silc_buffer_len(idp));
1964       } else {
1965         silc_server_send_notify(server, sock, FALSE,
1966                                 SILC_NOTIFY_TYPE_ERROR, 2,
1967                                 &error, 1, idp->data, silc_buffer_len(idp));
1968       }
1969
1970       silc_buffer_free(idp);
1971       goto out;
1972     }
1973   }
1974
1975   /* See that this client is on the channel. If the original sender is
1976      not client (as it can be server as well) we don't do the check. */
1977   if (!silc_id_str2id2(packet->src_id, packet->src_id_len,
1978                        packet->src_id_type, &sid))
1979     goto out;
1980   if (sid.type == SILC_ID_CLIENT) {
1981     sender_entry = silc_idlist_find_client_by_id(server->local_list,
1982                                                  SILC_ID_GET_ID(sid),
1983                                                  TRUE, NULL);
1984     if (!sender_entry) {
1985       local = FALSE;
1986       sender_entry = silc_idlist_find_client_by_id(server->global_list,
1987                                                    SILC_ID_GET_ID(sid),
1988                                                    TRUE, NULL);
1989     }
1990     if (!sender_entry || !silc_server_client_on_channel(sender_entry,
1991                                                         channel, &chl)) {
1992       SILC_LOG_DEBUG(("Client not on channel"));
1993       goto out;
1994     }
1995
1996     /* If channel is moderated check that client is allowed to send
1997        messages. */
1998     if (channel->mode & SILC_CHANNEL_MODE_SILENCE_USERS &&
1999         !(chl->mode & SILC_CHANNEL_UMODE_CHANOP) &&
2000         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2001       SILC_LOG_DEBUG(("Channel is silenced from normal users"));
2002       goto out;
2003     }
2004     if (channel->mode & SILC_CHANNEL_MODE_SILENCE_OPERS &&
2005         chl->mode & SILC_CHANNEL_UMODE_CHANOP &&
2006         !(chl->mode & SILC_CHANNEL_UMODE_CHANFO)) {
2007       SILC_LOG_DEBUG(("Channel is silenced from operators"));
2008       goto out;
2009     }
2010     if (chl->mode & SILC_CHANNEL_UMODE_QUIET) {
2011       SILC_LOG_DEBUG(("Sender is quieted on the channel"));
2012       goto out;
2013     }
2014
2015     /* If the packet is coming from router, but the client entry is local
2016        entry to us then some router is rerouting this to us and it is not
2017        allowed. When the client is local to us it means that we've routed
2018        this packet to network, and now someone is routing it back to us. */
2019     idata = silc_packet_get_context(sock);
2020     if (server->server_type == SILC_ROUTER &&
2021         idata->conn_type == SILC_CONN_ROUTER && local) {
2022       SILC_LOG_DEBUG(("Channel message rerouted to the sender, drop it"));
2023       goto out;
2024     }
2025   }
2026
2027   /* Distribute the packet to our local clients. This will send the
2028      packet for further routing as well, if needed. */
2029   silc_server_packet_relay_to_channel(server, sock, channel,
2030                                       SILC_ID_GET_ID(sid), sid.type,
2031                                       sender_entry, packet->buffer.data,
2032                                       silc_buffer_len(&packet->buffer));
2033
2034  out:
2035   silc_packet_free(packet);
2036 }
2037
2038 /* Received channel key packet. We distribute the key to all of our locally
2039    connected clients on the channel. */
2040
2041 void silc_server_channel_key(SilcServer server,
2042                              SilcPacketStream sock,
2043                              SilcPacket packet)
2044 {
2045   SilcBuffer buffer = &packet->buffer;
2046   SilcIDListData idata = silc_packet_get_context(sock);
2047   SilcChannelEntry channel;
2048
2049   if (packet->src_id_type != SILC_ID_SERVER ||
2050       (server->server_type == SILC_ROUTER && !server->backup_router &&
2051        idata->conn_type == SILC_CONN_ROUTER)) {
2052     silc_packet_free(packet);
2053     return;
2054   }
2055
2056   /* Save the channel key */
2057   channel = silc_server_save_channel_key(server, buffer, NULL);
2058   if (!channel) {
2059     SILC_LOG_ERROR(("Bad channel key from %s", idata->sconn->remote_host));
2060     silc_packet_free(packet);
2061     return;
2062   }
2063
2064   /* Distribute the key to everybody who is on the channel. If we are router
2065      we will also send it to locally connected servers. */
2066   silc_server_send_channel_key(server, sock, channel, FALSE);
2067
2068   if (server->server_type != SILC_BACKUP_ROUTER)
2069     /* Distribute to local cell backup routers. */
2070     silc_server_backup_send(server, (SilcServerEntry)idata,
2071                             SILC_PACKET_CHANNEL_KEY, 0,
2072                             buffer->data, silc_buffer_len(buffer),
2073                             FALSE, TRUE);
2074
2075   silc_packet_free(packet);
2076 }
2077
2078 /* Received New Client packet and processes it.  Creates Client ID for the
2079    client. Client becomes registered after calling this functions. */
2080
2081 SilcClientEntry silc_server_new_client(SilcServer server,
2082                                        SilcPacketStream sock,
2083                                        SilcPacket packet)
2084 {
2085   SilcBuffer buffer = &packet->buffer;
2086   SilcIDListData idata = silc_packet_get_context(sock);
2087   SilcClientEntry client;
2088   SilcClientID *client_id;
2089   char *username = NULL, *realname = NULL;
2090   SilcUInt16 username_len, nickname_len;
2091   SilcUInt32 id_len, tmp_len;
2092   int ret;
2093   char *host, *nickname = NULL, *nicknamec;
2094   const char *hostname, *ip;
2095
2096   SILC_LOG_DEBUG(("Creating new client"));
2097
2098   if (idata->conn_type != SILC_CONN_CLIENT) {
2099     silc_packet_free(packet);
2100     return NULL;
2101   }
2102
2103   /* Take client entry */
2104   client = (SilcClientEntry)idata;
2105   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2106                               NULL, &hostname, &ip, NULL);
2107
2108   SILC_LOG_DEBUG(("%s %s", ip, hostname));
2109
2110   /* Make sure this client hasn't registered already */
2111   if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2112     silc_packet_free(packet);
2113     return NULL;
2114   }
2115
2116   /* Parse incoming packet */
2117   ret = silc_buffer_unformat(buffer,
2118                              SILC_STR_ADVANCE,
2119                              SILC_STR_UI16_NSTRING_ALLOC(&username,
2120                                                          &username_len),
2121                              SILC_STR_UI16_STRING_ALLOC(&realname),
2122                              SILC_STR_END);
2123   if (ret == -1) {
2124     silc_free(username);
2125     silc_free(realname);
2126     SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2127                     "connection", hostname, ip));
2128     silc_server_disconnect_remote(server, sock,
2129                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2130                                   NULL);
2131     silc_server_free_sock_user_data(server, sock, NULL);
2132     silc_packet_free(packet);
2133     return NULL;
2134   }
2135
2136   if (!username) {
2137     silc_free(username);
2138     silc_free(realname);
2139     SILC_LOG_ERROR(("Client %s (%s) did not send its username, closing "
2140                     "connection", hostname, ip));
2141     silc_server_disconnect_remote(server, sock,
2142                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2143                                   NULL);
2144     silc_server_free_sock_user_data(server, sock, NULL);
2145     silc_packet_free(packet);
2146     return NULL;
2147   }
2148
2149   if (username_len > 128) {
2150     username_len = 128;
2151     username[username_len - 1] = '\0';
2152   }
2153
2154   /* Take nickname from NEW_CLIENT packet, if present */
2155   if (silc_buffer_unformat(buffer,
2156                            SILC_STR_UI16_NSTRING_ALLOC(&nickname,
2157                                                        &nickname_len),
2158                            SILC_STR_END) >= 0) {
2159     if (nickname_len > 128) {
2160       nickname_len = 128;
2161       nickname[nickname_len - 1] = '\0';
2162     }
2163   }
2164
2165   /* Nickname is initially same as username, if not present in NEW_CLIENT */
2166   if (!nickname) {
2167     nickname = strdup(username);
2168     nickname_len = strlen(nickname);
2169   }
2170
2171   /* Check for valid username string */
2172   nicknamec = silc_identifier_check(nickname, nickname_len,
2173                                     SILC_STRING_UTF8, 128, &tmp_len);
2174   if (!nicknamec) {
2175     silc_free(username);
2176     silc_free(realname);
2177     silc_free(nickname);
2178     SILC_LOG_ERROR(("Client %s (%s) sent bad username string '%s', closing "
2179                     "connection", hostname, ip, username));
2180     silc_server_disconnect_remote(server, sock,
2181                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2182                                   NULL);
2183     silc_server_free_sock_user_data(server, sock, NULL);
2184     silc_packet_free(packet);
2185     return NULL;
2186   }
2187
2188   /* Make sanity checks for the hostname of the client. If the hostname
2189      is provided in the `username' check that it is the same than the
2190      resolved hostname, or if not resolved the hostname that appears in
2191      the client's public key. If the hostname is not present then put
2192      it from the resolved name or from the public key. */
2193   if (strchr(username, '@')) {
2194     SilcSILCPublicKey silc_pubkey;
2195     int tlen = strcspn(username, "@");
2196     char *phostname = NULL;
2197
2198     host = silc_memdup(username + tlen + 1, strlen(username) - tlen - 1);
2199
2200     if (strcmp(hostname, ip) && strcmp(hostname, host)) {
2201       silc_free(nickname);
2202       silc_free(username);
2203       silc_free(host);
2204       silc_free(realname);
2205       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2206                       "connection", hostname, ip));
2207       silc_server_disconnect_remote(server, sock,
2208                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2209                                     NULL);
2210       silc_server_free_sock_user_data(server, sock, NULL);
2211       silc_packet_free(packet);
2212       return NULL;
2213     }
2214
2215     silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC,
2216                                         client->data.public_key);
2217     phostname = strdup(silc_pubkey->identifier.host);
2218     if (!strcmp(hostname, ip) && phostname && strcmp(phostname, host)) {
2219       silc_free(nickname);
2220       silc_free(username);
2221       silc_free(host);
2222       silc_free(phostname);
2223       silc_free(realname);
2224       SILC_LOG_ERROR(("Client %s (%s) sent incomplete information, closing "
2225                       "connection", hostname, ip));
2226       silc_server_disconnect_remote(server, sock,
2227                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2228                                     NULL);
2229       silc_server_free_sock_user_data(server, sock, NULL);
2230       silc_packet_free(packet);
2231       return NULL;
2232     }
2233
2234     silc_free(phostname);
2235   } else {
2236     /* The hostname is not present, add it. */
2237     char *newusername;
2238     newusername = silc_calloc(strlen(username) + strlen(hostname) + 2,
2239                               sizeof(*newusername));
2240     strncat(newusername, username, strlen(username));
2241     strncat(newusername, "@", 1);
2242     strncat(newusername, hostname, strlen(hostname));
2243     silc_free(username);
2244     username = newusername;
2245   }
2246
2247   SILC_LOG_DEBUG(("%s %s", ip, hostname));
2248
2249   /* Create Client ID */
2250   if (!silc_id_create_client_id(server, server->id, server->rng,
2251                                 server->md5hash, nicknamec,
2252                                 strlen(nicknamec), &client_id)) {
2253     silc_server_disconnect_remote(server, sock,
2254                                   SILC_STATUS_ERR_BAD_NICKNAME, NULL);
2255     silc_server_free_sock_user_data(server, sock, NULL);
2256     silc_packet_free(packet);
2257     return NULL;
2258   }
2259
2260   /* If client marked as anonymous, scramble the username and hostname */
2261   if (client->mode & SILC_UMODE_ANONYMOUS) {
2262     char *scramble;
2263
2264     if (strlen(username) >= 2) {
2265       username[0] = silc_rng_get_byte_fast(server->rng);
2266       username[1] = silc_rng_get_byte_fast(server->rng);
2267     }
2268
2269     scramble = silc_hash_babbleprint(server->sha1hash, username,
2270                                      strlen(username));
2271     scramble[5] = '@';
2272     scramble[11] = '.';
2273     memcpy(&scramble[16], ".silc", 5);
2274     scramble[21] = '\0';
2275     silc_free(username);
2276     username = scramble;
2277   }
2278
2279   /* Update client entry */
2280   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2281   client->nickname = nickname;
2282   client->username = username;
2283   client->userinfo = realname ? realname : strdup(username);
2284   client->id = client_id;
2285   id_len = silc_id_get_len(client_id, SILC_ID_CLIENT);
2286   silc_idcache_update_by_context(server->local_list->clients, client,
2287                                  client_id, nicknamec, TRUE);
2288
2289   /* Notify our router about new client on the SILC network */
2290   silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2291                           SILC_BROADCAST(server), client->id,
2292                           SILC_ID_CLIENT, id_len);
2293
2294   /* Distribute to backup routers */
2295   if (server->server_type == SILC_ROUTER) {
2296     SilcBuffer idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
2297     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0,
2298                             idp->data, silc_buffer_len(idp), FALSE, TRUE);
2299     silc_buffer_free(idp);
2300   }
2301
2302   /* Send the new client ID to the client. */
2303   silc_server_send_new_id(server, sock, FALSE, client->id, SILC_ID_CLIENT,
2304                           silc_id_get_len(client->id, SILC_ID_CLIENT));
2305
2306   /* Send some nice info to the client */
2307   silc_server_send_connect_notifys(server, sock, client);
2308
2309   /* Check if anyone is watching this nickname */
2310   if (server->server_type == SILC_ROUTER)
2311     silc_server_check_watcher_list(server, client, NULL, 0);
2312
2313   silc_packet_free(packet);
2314   return client;
2315 }
2316
2317 /* Create new server. This processes received New Server packet and
2318    saves the received Server ID. The server is our locally connected
2319    server thus we save all the information and save it to local list.
2320    This funtion can be used by both normal server and router server.
2321    If normal server uses this it means that its router has connected
2322    to the server. If router uses this it means that one of the cell's
2323    servers is connected to the router. */
2324
2325 SilcServerEntry silc_server_new_server(SilcServer server,
2326                                        SilcPacketStream sock,
2327                                        SilcPacket packet)
2328 {
2329   SilcBuffer buffer = &packet->buffer;
2330   SilcIDListData idata = silc_packet_get_context(sock);
2331   SilcServerEntry new_server, server_entry;
2332   SilcServerID server_id;
2333   unsigned char *server_name, *server_namec, *id_string;
2334   SilcUInt16 id_len, name_len;
2335   int ret;
2336   SilcBool local = TRUE;
2337   const char *hostname, *ip;
2338
2339   SILC_LOG_DEBUG(("Creating new server"));
2340
2341   if (idata->conn_type != SILC_CONN_SERVER &&
2342       idata->conn_type != SILC_CONN_ROUTER) {
2343     silc_packet_free(packet);
2344     return NULL;
2345   }
2346
2347   /* Take server entry */
2348   new_server = (SilcServerEntry)idata;
2349   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2350                               NULL, &hostname, &ip, NULL);
2351
2352   /* Statistics */
2353   if (server->server_type == SILC_ROUTER)
2354     server->stat.cell_servers++;
2355
2356   /* Remove the old cache entry */
2357   if (!silc_idcache_del_by_context(server->local_list->servers, new_server,
2358                                    NULL)) {
2359     if (!silc_idcache_del_by_context(server->global_list->servers,
2360                                      new_server, NULL)) {
2361       SILC_LOG_INFO(("Unauthenticated %s attempted to register to "
2362                      "network", (idata->conn_type == SILC_CONN_SERVER ?
2363                                  "server" : "router")));
2364       silc_server_disconnect_remote(server, sock,
2365                                     SILC_STATUS_ERR_NOT_AUTHENTICATED, NULL);
2366       silc_server_free_sock_user_data(server, sock, NULL);
2367       return NULL;
2368     }
2369     local = FALSE;
2370   }
2371
2372   /* Make sure this server hasn't registered already */
2373   if (idata->status & SILC_IDLIST_STATUS_REGISTERED) {
2374     silc_server_disconnect_remote(server, sock,
2375                                   SILC_STATUS_ERR_OPERATION_ALLOWED,
2376                                   "Too many registrations");
2377     silc_server_free_sock_user_data(server, sock, NULL);
2378     return NULL;
2379   }
2380
2381   /* Parse the incoming packet */
2382   ret = silc_buffer_unformat(buffer,
2383                              SILC_STR_UI16_NSTRING_ALLOC(&id_string, &id_len),
2384                              SILC_STR_UI16_NSTRING_ALLOC(&server_name,
2385                                                          &name_len),
2386                              SILC_STR_END);
2387   if (ret == -1) {
2388     silc_free(id_string);
2389     silc_free(server_name);
2390     silc_server_disconnect_remote(server, sock,
2391                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2392                                   NULL);
2393     silc_server_free_sock_user_data(server, sock, NULL);
2394     return NULL;
2395   }
2396
2397   if (id_len > silc_buffer_len(buffer)) {
2398     silc_free(id_string);
2399     silc_free(server_name);
2400     silc_server_disconnect_remote(server, sock,
2401                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2402                                   NULL);
2403     silc_server_free_sock_user_data(server, sock, NULL);
2404     return NULL;
2405   }
2406
2407   if (name_len > 256) {
2408     server_name[256] = '\0';
2409     name_len = 256;
2410   }
2411
2412   /* Get Server ID */
2413   if (!silc_id_str2id(id_string, id_len, SILC_ID_SERVER, &server_id,
2414                       sizeof(server_id))) {
2415     silc_free(id_string);
2416     silc_free(server_name);
2417     silc_server_disconnect_remote(server, sock,
2418                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
2419                                   NULL);
2420     silc_server_free_sock_user_data(server, sock, NULL);
2421     return NULL;
2422   }
2423   silc_free(id_string);
2424
2425   /* Check for valid server ID */
2426   if (!silc_id_is_valid_server_id(server, &server_id, sock)) {
2427     SILC_LOG_INFO(("Invalid server ID sent by %s (%s)",
2428                    ip, hostname));
2429     silc_server_disconnect_remote(server, sock,
2430                                   SILC_STATUS_ERR_BAD_SERVER_ID, NULL);
2431     silc_server_free_sock_user_data(server, sock, NULL);
2432     silc_free(server_name);
2433     return NULL;
2434   }
2435
2436   /* Check that we do not have this ID already */
2437   server_entry = silc_idlist_find_server_by_id(server->local_list,
2438                                                &server_id, TRUE, NULL);
2439   if (server_entry) {
2440     if (SILC_IS_LOCAL(server_entry)) {
2441       SILC_LOG_ERROR(("Too many registrations from %s (%s)",
2442                       ip, hostname));
2443       silc_server_disconnect_remote(server, sock,
2444                                     SILC_STATUS_ERR_OPERATION_ALLOWED,
2445                                     "Too many registrations");
2446       silc_server_free_sock_user_data(server, sock, NULL);
2447       return NULL;
2448     } else {
2449       silc_idcache_del_by_context(server->local_list->servers, server_entry,
2450                                   NULL);
2451     }
2452   } else {
2453     server_entry = silc_idlist_find_server_by_id(server->global_list,
2454                                                  &server_id, TRUE, NULL);
2455     if (server_entry) {
2456       if (SILC_IS_LOCAL(server_entry)) {
2457         SILC_LOG_ERROR(("Too many registrations from %s (%s)",
2458                         ip, hostname));
2459         silc_server_disconnect_remote(server, sock,
2460                                       SILC_STATUS_ERR_OPERATION_ALLOWED,
2461                                       "Too many registrations");
2462         silc_server_free_sock_user_data(server, sock, NULL);
2463         return NULL;
2464       } else {
2465         silc_idcache_del_by_context(server->global_list->servers,
2466                                     server_entry, NULL);
2467       }
2468     }
2469   }
2470
2471   /* Check server name */
2472   server_namec = silc_identifier_check(server_name, strlen(server_name),
2473                                        SILC_STRING_UTF8, 256, NULL);
2474   if (!server_namec) {
2475     SILC_LOG_ERROR(("Malformed server name from %s (%s)",
2476                     ip, hostname));
2477     silc_server_disconnect_remote(server, sock,
2478                                   SILC_STATUS_ERR_OPERATION_ALLOWED,
2479                                   "Malfromed server name");
2480     silc_server_free_sock_user_data(server, sock, NULL);
2481     return NULL;
2482   }
2483
2484   /* Update server entry */
2485   idata->status |= SILC_IDLIST_STATUS_REGISTERED;
2486   new_server->server_name = server_name;
2487   new_server->id = silc_id_dup(&server_id, SILC_ID_SERVER);
2488
2489   SILC_LOG_DEBUG(("New server id(%s)",
2490                   silc_id_render(&server_id, SILC_ID_SERVER)));
2491
2492   /* Add again the entry to the ID cache. */
2493   silc_idcache_add(local ? server->local_list->servers :
2494                    server->global_list->servers, server_namec,
2495                    new_server->id, new_server);
2496
2497   /* Distribute the information about new server in the SILC network
2498      to our router. If we are normal server we won't send anything
2499      since this connection must be our router connection. */
2500   if (server->server_type == SILC_ROUTER && !server->standalone &&
2501       SILC_PRIMARY_ROUTE(server) != sock)
2502     silc_server_send_new_id(server, SILC_PRIMARY_ROUTE(server),
2503                             TRUE, new_server->id, SILC_ID_SERVER,
2504                             silc_id_get_len(&server_id, SILC_ID_SERVER));
2505
2506   if (server->server_type == SILC_ROUTER) {
2507     /* Distribute to backup routers */
2508     SilcBuffer idp = silc_id_payload_encode(new_server->id, SILC_ID_SERVER);
2509     silc_server_backup_send(server, NULL, SILC_PACKET_NEW_ID, 0, idp->data,
2510                             silc_buffer_len(idp), FALSE, TRUE);
2511     silc_buffer_free(idp);
2512   }
2513
2514   /* Check whether this router connection has been replaced by an
2515      backup router. If it has been then we'll disable the server and will
2516      ignore everything it will send until the backup router resuming
2517      protocol has been completed. */
2518   if (idata->conn_type == SILC_CONN_ROUTER &&
2519       silc_server_backup_replaced_get(server, &server_id, NULL)) {
2520     /* Send packet to the router indicating that it cannot use this
2521        connection as it has been replaced by backup router. */
2522     SILC_LOG_DEBUG(("Remote router has been replaced by backup router, "
2523                     "disabling its connection"));
2524
2525     silc_server_backup_send_replaced(server, sock);
2526
2527     /* Mark the router disabled. The data sent earlier will go but nothing
2528        after this goes to this connection. */
2529     idata->status |= SILC_IDLIST_STATUS_DISABLED;
2530   } else {
2531     /* If it is router announce our stuff to it. */
2532     if (idata->conn_type == SILC_CONN_ROUTER &&
2533         server->server_type == SILC_ROUTER) {
2534       silc_server_announce_servers(server, FALSE, 0, sock);
2535       silc_server_announce_clients(server, 0, sock);
2536       silc_server_announce_channels(server, 0, sock);
2537     }
2538
2539     /* Announce our information to backup router */
2540     if (new_server->server_type == SILC_BACKUP_ROUTER &&
2541         idata->conn_type == SILC_CONN_SERVER &&
2542         server->server_type == SILC_ROUTER) {
2543       silc_server_announce_servers(server, TRUE, 0, sock);
2544       silc_server_announce_clients(server, 0, sock);
2545       silc_server_announce_channels(server, 0, sock);
2546     }
2547
2548     /* If backup router, mark it as one of ours.  This server is considered
2549        to be backup router after this setting. */
2550     if (new_server->server_type == SILC_BACKUP_ROUTER) {
2551       SilcServerConfigRouter *backup;
2552       backup = silc_server_config_find_backup_conn(server, (char *)ip);
2553       if (!backup)
2554         backup = silc_server_config_find_backup_conn(server, (char *)hostname);
2555       if (backup) {
2556         /* Add as our backup router */
2557         silc_server_backup_add(server, new_server, backup->backup_replace_ip,
2558                                backup->backup_replace_port,
2559                                backup->backup_local);
2560       }
2561     }
2562
2563     /* By default the servers connected to backup router are disabled
2564        until backup router has become the primary */
2565     if (server->server_type == SILC_BACKUP_ROUTER &&
2566         idata->conn_type == SILC_CONN_SERVER)
2567       idata->status |= SILC_IDLIST_STATUS_DISABLED;
2568   }
2569
2570   return new_server;
2571 }
2572
2573 /* Processes incoming New ID packet. New ID Payload is used to distribute
2574    information about newly registered clients and servers. */
2575
2576 static void silc_server_new_id_real(SilcServer server,
2577                                     SilcPacketStream sock,
2578                                     SilcPacket packet,
2579                                     SilcBuffer buffer,
2580                                     SilcBool broadcast)
2581 {
2582   SilcIDListData idata = silc_packet_get_context(sock);
2583   SilcIDList id_list;
2584   SilcServerEntry router, server_entry;
2585   SilcPacketStream router_sock;
2586   SilcIDPayload idp;
2587   SilcIdType id_type;
2588   SilcServerID sender_id;
2589   const char *hostname, *ip;
2590
2591   SILC_LOG_DEBUG(("Processing new ID"));
2592
2593   if (idata->conn_type == SILC_CONN_CLIENT ||
2594       server->server_type == SILC_SERVER ||
2595       packet->src_id_type != SILC_ID_SERVER)
2596     return;
2597
2598   idp = silc_id_payload_parse(buffer->data, silc_buffer_len(buffer));
2599   if (!idp)
2600     return;
2601
2602   id_type = silc_id_payload_get_type(idp);
2603
2604   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
2605                               NULL, &hostname, &ip, NULL);
2606
2607   /* Normal server cannot have other normal server connections */
2608   server_entry = (SilcServerEntry)idata;
2609   if (id_type == SILC_ID_SERVER && idata->conn_type == SILC_CONN_SERVER &&
2610       server_entry->server_type == SILC_SERVER)
2611     goto out;
2612
2613   /* If the packet is coming from server then use the sender as the
2614      origin of the the packet. If it came from router then check the real
2615      sender of the packet and use that as the origin. */
2616   if (idata->conn_type == SILC_CONN_SERVER) {
2617     id_list = server->local_list;
2618     router_sock = sock;
2619     router = server_entry;
2620
2621     /* If the sender is backup router and ID is server (and we are not
2622        backup router) then switch the entry to global list. */
2623     if (server_entry->server_type == SILC_BACKUP_ROUTER &&
2624         id_type == SILC_ID_SERVER &&
2625         server->id_entry->server_type != SILC_BACKUP_ROUTER) {
2626       id_list = server->global_list;
2627       router_sock = server->router ? SILC_PRIMARY_ROUTE(server) : sock;
2628     }
2629   } else {
2630     silc_id_str2id(packet->src_id, packet->src_id_len,
2631                    packet->src_id_type, &sender_id, sizeof(sender_id));
2632     router = silc_idlist_find_server_by_id(server->global_list,
2633                                            &sender_id, TRUE, NULL);
2634     if (!router)
2635       router = silc_idlist_find_server_by_id(server->local_list,
2636                                              &sender_id, TRUE, NULL);
2637     router_sock = sock;
2638     id_list = server->global_list;
2639   }
2640
2641   if (!router)
2642     goto out;
2643
2644   switch(id_type) {
2645   case SILC_ID_CLIENT:
2646     {
2647       SilcClientEntry entry;
2648       SilcClientID id;
2649
2650       if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
2651         goto out;
2652
2653       /* Check that we do not have this client already */
2654       entry = silc_idlist_find_client_by_id(server->global_list,
2655                                             &id, server->server_type,
2656                                             NULL);
2657       if (!entry)
2658         entry = silc_idlist_find_client_by_id(server->local_list,
2659                                               &id, server->server_type,
2660                                               NULL);
2661       if (entry) {
2662         SILC_LOG_DEBUG(("Ignoring client that we already have"));
2663         goto out;
2664       }
2665
2666       SILC_LOG_DEBUG(("New client id(%s) from [%s] %s",
2667                       silc_id_render(&id, SILC_ID_CLIENT),
2668                       idata->conn_type == SILC_CONN_SERVER ?
2669                       "Server" : "Router", hostname));
2670
2671       /* As a router we keep information of all global information in our
2672          global list. Cell wide information however is kept in the local
2673          list. */
2674       entry = silc_idlist_add_client(id_list, NULL, NULL, NULL,
2675                                      silc_id_dup(&id, SILC_ID_CLIENT),
2676                                      router, NULL);
2677       if (!entry) {
2678         SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
2679
2680         /* Inform the sender that the ID is not usable */
2681         silc_server_send_notify_signoff(server, sock, FALSE, &id, NULL);
2682         goto out;
2683       }
2684       entry->nickname = NULL;
2685       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2686
2687       if (idata->conn_type == SILC_CONN_SERVER)
2688         server->stat.cell_clients++;
2689       server->stat.clients++;
2690
2691       /* Check if anyone is watching this nickname */
2692       if (server->server_type == SILC_ROUTER && id_list == server->local_list)
2693         silc_server_check_watcher_list(server, entry, NULL, 0);
2694
2695       if (server->server_type == SILC_ROUTER) {
2696         /* Add the client's public key to repository or get the key with
2697            GETKEY command. */
2698         if (entry->data.public_key) {
2699           if (!silc_server_get_public_key_by_client(server, entry, NULL))
2700             silc_skr_add_public_key_simple(server->repository,
2701                                            entry->data.public_key,
2702                                            SILC_SKR_USAGE_IDENTIFICATION,
2703                                            entry, NULL);
2704         } else {
2705           silc_server_send_command(server, router_sock,
2706                                    SILC_COMMAND_GETKEY, ++server->cmd_ident,
2707                                    1, 1, buffer->data,
2708                                    silc_buffer_len(buffer));
2709         }
2710       }
2711     }
2712     break;
2713
2714   case SILC_ID_SERVER:
2715     {
2716       SilcServerEntry entry;
2717       SilcServerID id;
2718
2719       if (!silc_id_payload_get_id(idp, &id, sizeof(id)))
2720         goto out;
2721
2722       /* If the ID is mine, ignore it. */
2723       if (SILC_ID_SERVER_COMPARE(&id, server->id)) {
2724         SILC_LOG_DEBUG(("Ignoring my own ID as new ID"));
2725         break;
2726       }
2727
2728       /* If the ID is the sender's ID, ignore it (we have it already) */
2729       if (SILC_ID_SERVER_COMPARE(&id, router->id)) {
2730         SILC_LOG_DEBUG(("Ignoring sender's own ID"));
2731         break;
2732       }
2733
2734       /* Check that we do not have this server already */
2735       entry = silc_idlist_find_server_by_id(server->global_list,
2736                                             &id, server->server_type,
2737                                             NULL);
2738       if (!entry)
2739         entry = silc_idlist_find_server_by_id(server->local_list,
2740                                               &id, server->server_type,
2741                                               NULL);
2742       if (entry) {
2743         SILC_LOG_DEBUG(("Ignoring server that we already have"));
2744         goto out;
2745       }
2746
2747       SILC_LOG_DEBUG(("New server id(%s) from [%s] %s",
2748                       silc_id_render(&id, SILC_ID_SERVER),
2749                       idata->conn_type == SILC_CONN_SERVER ?
2750                       "Server" : "Router", hostname));
2751
2752       /* As a router we keep information of all global information in our
2753          global list. Cell wide information however is kept in the local
2754          list. */
2755       entry = silc_idlist_add_server(id_list, NULL, 0,
2756                                      silc_id_dup(&id, SILC_ID_SERVER), router,
2757                                      router_sock);
2758       if (!entry) {
2759         SILC_LOG_ERROR(("Could not add new server to the ID Cache"));
2760         goto out;
2761       }
2762       entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
2763
2764       if (idata->conn_type == SILC_CONN_SERVER)
2765         server->stat.cell_servers++;
2766       server->stat.servers++;
2767     }
2768     break;
2769
2770   case SILC_ID_CHANNEL:
2771     SILC_LOG_ERROR(("Channel cannot be registered with NEW_ID packet"));
2772     goto out;
2773     break;
2774
2775   default:
2776     goto out;
2777     break;
2778   }
2779
2780   /* If the sender of this packet is server and we are router we need to
2781      broadcast this packet to other routers in the network. */
2782   if (broadcast && server->server_type == SILC_ROUTER &&
2783       idata->conn_type == SILC_CONN_SERVER &&
2784       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2785     SILC_LOG_DEBUG(("Broadcasting received New ID packet"));
2786     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2787                             packet->type,
2788                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2789                             buffer->data, silc_buffer_len(buffer));
2790     silc_server_backup_send(server, (SilcServerEntry)idata,
2791                             packet->type, packet->flags,
2792                             packet->buffer.data,
2793                             silc_buffer_len(&packet->buffer),
2794                             FALSE, TRUE);
2795   }
2796
2797  out:
2798   silc_id_payload_free(idp);
2799 }
2800
2801
2802 /* Processes incoming New ID packet. New ID Payload is used to distribute
2803    information about newly registered clients and servers. */
2804
2805 void silc_server_new_id(SilcServer server, SilcPacketStream sock,
2806                         SilcPacket packet)
2807 {
2808   silc_server_new_id_real(server, sock, packet, &packet->buffer, TRUE);
2809   silc_packet_free(packet);
2810 }
2811
2812 /* Receoved New Id List packet, list of New ID payloads inside one
2813    packet. Process the New ID payloads one by one. */
2814
2815 void silc_server_new_id_list(SilcServer server, SilcPacketStream sock,
2816                              SilcPacket packet)
2817 {
2818   SilcIDListData idata = silc_packet_get_context(sock);
2819   SilcBuffer idp;
2820   SilcUInt16 id_len;
2821
2822   SILC_LOG_DEBUG(("Processing New ID List"));
2823
2824   if (idata->conn_type == SILC_CONN_CLIENT ||
2825       packet->src_id_type != SILC_ID_SERVER) {
2826     silc_packet_free(packet);
2827     return;
2828   }
2829
2830   /* If the sender of this packet is server and we are router we need to
2831      broadcast this packet to other routers in the network. Broadcast
2832      this list packet instead of multiple New ID packets. */
2833   if (server->server_type == SILC_ROUTER &&
2834       idata->conn_type == SILC_CONN_SERVER &&
2835       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
2836     SILC_LOG_DEBUG(("Broadcasting received New ID List packet"));
2837     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
2838                             packet->type,
2839                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
2840                             packet->buffer.data,
2841                             silc_buffer_len(&packet->buffer));
2842     silc_server_backup_send(server, (SilcServerEntry)idata,
2843                             packet->type, packet->flags,
2844                             packet->buffer.data,
2845                             silc_buffer_len(&packet->buffer),
2846                             FALSE, TRUE);
2847   }
2848
2849   idp = silc_buffer_alloc(256);
2850   if (!idp) {
2851     silc_packet_free(packet);
2852     return;
2853   }
2854
2855   while (silc_buffer_len(&packet->buffer)) {
2856     SILC_GET16_MSB(id_len, packet->buffer.data + 2);
2857     if ((id_len > silc_buffer_len(&packet->buffer)) ||
2858         (id_len > silc_buffer_truelen(idp)))
2859       break;
2860
2861     silc_buffer_pull_tail(idp, 4 + id_len);
2862     silc_buffer_put(idp, packet->buffer.data, 4 + id_len);
2863
2864     /* Process the New ID */
2865     silc_server_new_id_real(server, sock, packet, idp, FALSE);
2866
2867     silc_buffer_push_tail(idp, 4 + id_len);
2868     silc_buffer_pull(&packet->buffer, 4 + id_len);
2869   }
2870
2871   silc_buffer_free(idp);
2872   silc_packet_free(packet);
2873 }
2874
2875 /* Received New Channel packet. Information about new channels in the
2876    network are distributed using this packet. Save the information about
2877    the new channel. This usually comes from router but also normal server
2878    can send this to notify channels it has when it connects to us. */
2879
2880 static void silc_server_new_channel_process(SilcServer server,
2881                                             SilcPacketStream sock,
2882                                             SilcPacket packet,
2883                                             SilcBuffer buffer)
2884 {
2885   SilcIDListData idata = silc_packet_get_context(sock);
2886   SilcChannelPayload payload;
2887   SilcChannelID channel_id;
2888   char *channel_name, *channel_namec = NULL;
2889   SilcUInt32 name_len;
2890   unsigned char *id, cid[32];
2891   SilcUInt32 id_len, cipher_len;
2892   SilcServerEntry server_entry;
2893   SilcChannelEntry channel;
2894   const char *cipher;
2895
2896   if (idata->conn_type == SILC_CONN_CLIENT ||
2897       packet->src_id_type != SILC_ID_SERVER ||
2898       server->server_type == SILC_SERVER)
2899     return;
2900
2901   /* Parse the channel payload */
2902   payload = silc_channel_payload_parse(buffer->data, silc_buffer_len(buffer));
2903   if (!payload)
2904     return;
2905
2906   /* Get the channel ID */
2907   if (!silc_channel_get_id_parse(payload, &channel_id)) {
2908     silc_channel_payload_free(payload);
2909     return;
2910   }
2911
2912   channel_name = silc_channel_get_name(payload, &name_len);
2913   if (name_len > 256) {
2914     channel_name[256] = '\0';
2915     name_len = 256;
2916   }
2917
2918   /* Check channel name */
2919   channel_namec = silc_channel_name_check(channel_name, strlen(channel_name),
2920                                           SILC_STRING_UTF8, 256, NULL);
2921   if (!channel_namec)
2922     return;
2923
2924   id = silc_channel_get_id(payload, &id_len);
2925
2926   server_entry = (SilcServerEntry)idata;
2927
2928   if (idata->conn_type == SILC_CONN_ROUTER) {
2929     /* Add the channel to global list as it is coming from router. It
2930        cannot be our own channel as it is coming from router. */
2931
2932     /* Check that we don't already have this channel */
2933     channel = silc_idlist_find_channel_by_name(server->local_list,
2934                                                channel_namec, NULL);
2935     if (!channel)
2936       channel = silc_idlist_find_channel_by_name(server->global_list,
2937                                                  channel_namec, NULL);
2938     if (!channel) {
2939       SILC_LOG_DEBUG(("New channel id(%s) from [Router] %s",
2940                       silc_id_render(&channel_id, SILC_ID_CHANNEL),
2941                       idata->sconn->remote_host));
2942
2943       channel =
2944         silc_idlist_add_channel(server->global_list, strdup(channel_name),
2945                                 0, silc_id_dup(&channel_id, SILC_ID_CHANNEL),
2946                                 (SilcServerEntry)idata, NULL, NULL, NULL);
2947       if (!channel) {
2948         silc_channel_payload_free(payload);
2949         return;
2950       }
2951       channel->disabled = TRUE;    /* Disabled until someone JOINs */
2952
2953       server->stat.channels++;
2954       if (server->server_type == SILC_ROUTER)
2955         channel->users_resolved = TRUE;
2956     }
2957   } else {
2958     /* The channel is coming from our server, thus it is in our cell
2959        we will add it to our local list. */
2960     SilcBuffer chk;
2961
2962     SILC_LOG_DEBUG(("Channel id(%s) from [Server] %s",
2963                     silc_id_render(&channel_id, SILC_ID_CHANNEL),
2964                     idata->sconn->remote_host));
2965
2966     /* Check that we don't already have this channel */
2967     channel = silc_idlist_find_channel_by_name(server->local_list,
2968                                                channel_namec, NULL);
2969     if (!channel)
2970       channel = silc_idlist_find_channel_by_name(server->global_list,
2971                                                  channel_namec, NULL);
2972
2973     /* If the channel does not exist, then create it. This creates a new
2974        key to the channel as well that we will send to the server. */
2975     if (!channel) {
2976       SILC_LOG_DEBUG(("Channel is new to us"));
2977
2978       /* The protocol says that the Channel ID's IP address must be based
2979          on the router's IP address.  Check whether the ID is based in our
2980          IP and if it is not then create a new ID and enforce the server
2981          to switch the ID. */
2982       if (server_entry->server_type != SILC_BACKUP_ROUTER &&
2983           !SILC_ID_COMPARE(&channel_id, server->id, server->id->ip.data_len)) {
2984         SilcChannelID *tmp;
2985         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
2986         if (silc_id_create_channel_id(server, server->id, server->rng, &tmp)) {
2987           silc_server_send_notify_channel_change(server, sock, FALSE,
2988                                                  &channel_id, tmp);
2989           silc_channel_payload_free(payload);
2990           silc_free(tmp);
2991         }
2992
2993         /* Wait that server re-announces this channel */
2994         return;
2995       }
2996
2997       /* Create the channel with the provided Channel ID */
2998       channel =
2999         silc_server_create_new_channel_with_id(
3000                                      server, NULL, NULL,
3001                                      channel_name,
3002                                      silc_id_dup(&channel_id, SILC_ID_CHANNEL),
3003                                      FALSE);
3004       if (!channel) {
3005         silc_channel_payload_free(payload);
3006         return;
3007       }
3008       channel->disabled = TRUE;    /* Disabled until someone JOINs */
3009
3010 #if 0 /* We assume that CMODE_CHANGE notify is sent to us after this. */
3011
3012       /* XXX Dunno if this is supposed to be set in any server type.  If set
3013          here the CMODE_CHANGE that may follow sets mode that we already
3014          have, and we may loose data from the CMODE_CHANGE notify. */
3015       if (server_entry->server_type != SILC_BACKUP_ROUTER)
3016         channel->mode = silc_channel_get_mode(payload);
3017 #endif
3018
3019       /* Send the new channel key to the server */
3020       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3021                      &id_len);
3022       cipher = silc_cipher_get_name(channel->send_key);
3023       cipher_len = strlen(cipher);
3024       chk = silc_channel_key_payload_encode(id_len, cid,
3025                                             cipher_len, cipher,
3026                                             channel->key_len / 8,
3027                                             channel->key);
3028       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3029                               chk->data, silc_buffer_len(chk));
3030       silc_buffer_free(chk);
3031     } else {
3032       /* The channel exist by that name, check whether the ID's match.
3033          If they don't then we'll force the server to use the ID we have.
3034          We also create a new key for the channel. */
3035       SilcBuffer modes = NULL, users = NULL, users_modes = NULL;
3036
3037       SILC_LOG_DEBUG(("Channel already exists"));
3038
3039       if (!SILC_ID_CHANNEL_COMPARE(&channel_id, channel->id)) {
3040         /* They don't match, send CHANNEL_CHANGE notify to the server to
3041            force the ID change. */
3042         SILC_LOG_DEBUG(("Forcing the server to change Channel ID"));
3043         silc_server_send_notify_channel_change(server, sock, FALSE,
3044                                                &channel_id, channel->id);
3045         silc_channel_payload_free(payload);
3046
3047         /* Wait that server re-announces this channel */
3048         return;
3049       }
3050
3051 #if 0 /* We will announce our CMODE anyway for this channel, so no need
3052          to check it (implicit enforce). */
3053
3054       /* If the mode is different from what we have then enforce the
3055          mode change. */
3056       mode = silc_channel_get_mode(payload);
3057       if (channel->mode != mode) {
3058         SILC_LOG_DEBUG(("Forcing the server to change channel mode"));
3059         silc_server_send_notify_cmode(server, sock, FALSE, channel,
3060                                       channel->mode, server->id,
3061                                       SILC_ID_SERVER, channel->cipher,
3062                                       channel->hmac_name,
3063                                       channel->passphrase,
3064                                       channel->founder_key);
3065       }
3066 #endif
3067
3068       /* Create new key for the channel and send it to the server and
3069          everybody else possibly on the channel. */
3070       if (!(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3071
3072         if (silc_hash_table_count(channel->user_list)) {
3073           if (!silc_server_create_channel_key(server, channel, 0)) {
3074             silc_channel_payload_free(payload);
3075             return;
3076           }
3077
3078           /* Send to the channel */
3079           silc_server_send_channel_key(server, sock, channel, FALSE);
3080         }
3081
3082         /* Send to the server */
3083         silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3084                        &id_len);
3085         cipher = silc_cipher_get_name(channel->send_key);
3086         cipher_len = strlen(cipher);
3087         chk = silc_channel_key_payload_encode(id_len, cid,
3088                                               cipher_len, cipher,
3089                                               channel->key_len / 8,
3090                                               channel->key);
3091         silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3092                                 chk->data, silc_buffer_len(chk));
3093         silc_buffer_free(chk);
3094       }
3095
3096       /* Since the channel is coming from server and we also know about it
3097          then send the JOIN notify to the server so that it see's our
3098          users on the channel "joining" the channel. */
3099       silc_server_announce_get_channel_users(server, channel, &modes, &users,
3100                                              &users_modes);
3101       if (users) {
3102         silc_buffer_push(users, users->data - users->head);
3103         silc_server_packet_send(server, sock,
3104                                 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3105                                 users->data, silc_buffer_len(users));
3106         silc_buffer_free(users);
3107       }
3108       if (modes) {
3109         silc_buffer_push(modes, modes->data - modes->head);
3110         silc_server_packet_send_dest(server, sock,
3111                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3112                                      channel->id, SILC_ID_CHANNEL,
3113                                      modes->data, silc_buffer_len(modes));
3114         silc_buffer_free(modes);
3115       }
3116       if (users_modes) {
3117         silc_buffer_push(users_modes, users_modes->data - users_modes->head);
3118         silc_server_packet_send_dest(server, sock,
3119                                      SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
3120                                      channel->id, SILC_ID_CHANNEL,
3121                                      users_modes->data,
3122                                      silc_buffer_len(users_modes));
3123         silc_buffer_free(users_modes);
3124       }
3125       if (channel->topic) {
3126         silc_server_send_notify_topic_set(server, sock,
3127                                           server->server_type == SILC_ROUTER ?
3128                                           TRUE : FALSE, channel,
3129                                           server->id, SILC_ID_SERVER,
3130                                           channel->topic);
3131       }
3132     }
3133   }
3134
3135   /* If the sender of this packet is server and we are router we need to
3136      broadcast this packet to other routers in the network. Broadcast
3137      this list packet instead of multiple New Channel packets. */
3138   if (server->server_type == SILC_ROUTER &&
3139       idata->conn_type == SILC_CONN_SERVER &&
3140       !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3141     SILC_LOG_DEBUG(("Broadcasting received New Channel packet"));
3142     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3143                             packet->type,
3144                             packet->flags | SILC_PACKET_FLAG_BROADCAST,
3145                             buffer->data, silc_buffer_len(buffer));
3146     silc_server_backup_send(server, (SilcServerEntry)idata,
3147                             packet->type, packet->flags,
3148                             buffer->data, silc_buffer_len(buffer),
3149                             FALSE, TRUE);
3150   }
3151
3152   silc_free(channel_namec);
3153   silc_channel_payload_free(payload);
3154 }
3155
3156 /* Received New Channel packet. Information about new channels in the
3157    network are distributed using this packet. Save the information about
3158    the new channel. This usually comes from router but also normal server
3159    can send this to notify channels it has when it connects to us. */
3160
3161 void silc_server_new_channel(SilcServer server,
3162                              SilcPacketStream sock,
3163                              SilcPacket packet)
3164 {
3165   silc_server_new_channel_process(server, sock, packet, &packet->buffer);
3166   silc_packet_free(packet);
3167 }
3168
3169 /* Received New Channel List packet, list of New Channel List payloads inside
3170    one packet. Process the New Channel payloads one by one. */
3171
3172 void silc_server_new_channel_list(SilcServer server,
3173                                   SilcPacketStream sock,
3174                                   SilcPacket packet)
3175 {
3176   SilcIDListData idata = silc_packet_get_context(sock);
3177   SilcBuffer buffer;
3178   SilcUInt16 len1, len2;
3179
3180   SILC_LOG_DEBUG(("Processing New Channel List"));
3181
3182   if (idata->conn_type == SILC_CONN_CLIENT ||
3183       packet->src_id_type != SILC_ID_SERVER ||
3184       server->server_type == SILC_SERVER) {
3185     silc_packet_free(packet);
3186     return;
3187   }
3188
3189   buffer = silc_buffer_alloc(512);
3190   if (!buffer) {
3191     silc_packet_free(packet);
3192     return;
3193   }
3194
3195   while (silc_buffer_len(&packet->buffer)) {
3196     SILC_GET16_MSB(len1, packet->buffer.data);
3197     if ((len1 > silc_buffer_len(&packet->buffer)) ||
3198         (len1 > silc_buffer_truelen(buffer)))
3199       break;
3200
3201     SILC_GET16_MSB(len2, packet->buffer.data + 2 + len1);
3202     if ((len2 > silc_buffer_len(&packet->buffer)) ||
3203         (len2 > silc_buffer_truelen(buffer)))
3204       break;
3205
3206     silc_buffer_pull_tail(buffer, 8 + len1 + len2);
3207     silc_buffer_put(buffer, packet->buffer.data, 8 + len1 + len2);
3208
3209     /* Process the New Channel */
3210     silc_server_new_channel_process(server, sock, packet, buffer);
3211
3212     silc_buffer_push_tail(buffer, 8 + len1 + len2);
3213     silc_buffer_pull(&packet->buffer, 8 + len1 + len2);
3214   }
3215
3216   silc_buffer_free(buffer);
3217   silc_packet_free(packet);
3218 }
3219
3220 /* Received key agreement packet. This packet is never for us. It is to
3221    the client in the packet's destination ID. Sending of this sort of packet
3222    equals sending private message, ie. it is sent point to point from
3223    one client to another. */
3224
3225 void silc_server_key_agreement(SilcServer server,
3226                                SilcPacketStream sock,
3227                                SilcPacket packet)
3228 {
3229   SilcPacketStream dst_sock;
3230   SilcIDListData idata;
3231
3232   SILC_LOG_DEBUG(("Start"));
3233
3234   if (packet->src_id_type != SILC_ID_CLIENT ||
3235       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
3236     silc_packet_free(packet);
3237     return;
3238   }
3239
3240   /* Get the route to the client */
3241   dst_sock = silc_server_get_client_route(server, packet->dst_id,
3242                                           packet->dst_id_len, NULL,
3243                                           &idata, NULL);
3244   if (!dst_sock) {
3245     silc_packet_free(packet);
3246     return;
3247   }
3248
3249   /* Relay the packet */
3250   silc_server_packet_route(server, dst_sock, packet);
3251   silc_packet_free(packet);
3252 }
3253
3254 /* Received connection auth request packet that is used during connection
3255    phase to resolve the mandatory authentication method.  This packet can
3256    actually be received at anytime but usually it is used only during
3257    the connection authentication phase. Now, protocol says that this packet
3258    can come from client or server, however, we support only this coming
3259    from client and expect that server always knows what authentication
3260    method to use. */
3261
3262 void silc_server_connection_auth_request(SilcServer server,
3263                                          SilcPacketStream sock,
3264                                          SilcPacket packet)
3265 {
3266   SilcServerConfigClient *client = NULL;
3267   SilcUInt16 conn_type;
3268   int ret;
3269   SilcAuthMethod auth_meth = SILC_AUTH_NONE;
3270   const char *hostname, *ip;
3271
3272   if (packet->src_id_type && packet->src_id_type != SILC_ID_CLIENT) {
3273     SILC_LOG_DEBUG(("Request not from client"));
3274     silc_packet_free(packet);
3275     return;
3276   }
3277
3278   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3279                               NULL, &hostname, &ip, NULL);
3280
3281   /* Parse the payload */
3282   ret = silc_buffer_unformat(&packet->buffer,
3283                              SILC_STR_UI_SHORT(&conn_type),
3284                              SILC_STR_UI_SHORT(NULL),
3285                              SILC_STR_END);
3286   if (ret == -1 || conn_type != SILC_CONN_CLIENT) {
3287     silc_packet_free(packet);
3288     return;
3289   }
3290
3291   /* Get the authentication method for the client */
3292   auth_meth = SILC_AUTH_NONE;
3293   client = silc_server_config_find_client(server, (char *)ip);
3294   if (!client)
3295     client = silc_server_config_find_client(server, (char *)hostname);
3296   if (client) {
3297     if (client->passphrase) {
3298       if (client->publickeys && !server->config->prefer_passphrase_auth)
3299         auth_meth = SILC_AUTH_PUBLIC_KEY;
3300       else
3301         auth_meth = SILC_AUTH_PASSWORD;
3302     } else if (client->publickeys)
3303       auth_meth = SILC_AUTH_PUBLIC_KEY;
3304   }
3305
3306   SILC_LOG_DEBUG(("Authentication method is [%s]",
3307                   (auth_meth == SILC_AUTH_NONE ? "None" :
3308                    auth_meth == SILC_AUTH_PASSWORD ? "Passphrase" :
3309                    "Digital signatures")));
3310
3311   /* Send it back to the client */
3312   silc_server_send_connection_auth_request(server, sock, conn_type, auth_meth);
3313   silc_packet_free(packet);
3314 }
3315
3316 /* Received file transger packet. This packet is never for us. It is to
3317    the client in the packet's destination ID. Sending of this sort of packet
3318    equals sending private message, ie. it is sent point to point from
3319    one client to another. */
3320
3321 void silc_server_ftp(SilcServer server,
3322                      SilcPacketStream sock,
3323                      SilcPacket packet)
3324 {
3325   SilcPacketStream dst_sock;
3326   SilcIDListData idata;
3327
3328   SILC_LOG_DEBUG(("Start"));
3329
3330   if (packet->src_id_type != SILC_ID_CLIENT ||
3331       packet->dst_id_type != SILC_ID_CLIENT || !packet->dst_id) {
3332     silc_packet_free(packet);
3333     return;
3334   }
3335
3336   /* Get the route to the client */
3337   dst_sock = silc_server_get_client_route(server, packet->dst_id,
3338                                           packet->dst_id_len, NULL,
3339                                           &idata, NULL);
3340   if (!dst_sock) {
3341     silc_packet_free(packet);
3342     return;
3343   }
3344
3345   /* Relay the packet */
3346   silc_server_packet_route(server, dst_sock, packet);
3347   silc_packet_free(packet);
3348 }
3349
3350 typedef struct {
3351   SilcServer server;
3352   SilcPacketStream sock;
3353   SilcPacket packet;
3354   SilcClientID client_id;
3355 } *SilcServerResumeResolve;
3356
3357 SILC_SERVER_CMD_FUNC(resume_resolve)
3358 {
3359   SilcServerResumeResolve r = (SilcServerResumeResolve)context;
3360   SilcServer server = r->server;
3361   SilcPacketStream sock = r->sock;
3362   SilcServerCommandReplyContext reply = context2;
3363   SilcClientEntry client;
3364   const char *hostname, *ip;
3365
3366   SILC_LOG_DEBUG(("Start"));
3367
3368   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3369                               NULL, &hostname, &ip, NULL);
3370
3371   if (!reply || !silc_command_get_status(reply->payload, NULL, NULL)) {
3372     SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3373                     "closing connection", hostname, ip));
3374     silc_server_disconnect_remote(server, sock,
3375                                   SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3376                                   "Resuming not possible");
3377     silc_server_free_sock_user_data(server, sock, NULL);
3378     goto out;
3379   }
3380
3381   if (reply && silc_command_get(reply->payload) == SILC_COMMAND_WHOIS) {
3382     /* Get entry to the client, and resolve it if we don't have it. */
3383     client = silc_idlist_find_client_by_id(server->local_list,
3384                                            &r->client_id, TRUE, NULL);
3385     if (!client) {
3386       client = silc_idlist_find_client_by_id(server->global_list,
3387                                              &r->client_id, TRUE, NULL);
3388       if (!client) {
3389         SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3390                         "closing connection", hostname, ip));
3391         silc_server_disconnect_remote(server, sock,
3392                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3393                                       "Resuming not possible");
3394         silc_server_free_sock_user_data(server, sock, NULL);
3395         goto out;
3396       }
3397     }
3398
3399     if (!(client->mode & SILC_UMODE_DETACHED)) {
3400       SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3401                       "closing connection", hostname, ip));
3402       silc_server_disconnect_remote(server, sock,
3403                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3404                                     "Resuming not possible");
3405       silc_server_free_sock_user_data(server, sock, NULL);
3406       goto out;
3407     }
3408
3409     client->data.status |= SILC_IDLIST_STATUS_RESUME_RES;
3410   }
3411
3412   /* Reprocess the packet */
3413   silc_server_resume_client(server, sock, r->packet);
3414
3415  out:
3416   silc_packet_stream_unref(r->sock);
3417   silc_free(r);
3418 }
3419
3420 /* Received client resuming packet.  This is used to resume detached
3421    client session.  It can be sent by the client who wishes to resume
3422    but this is also sent by servers and routers to notify other routers
3423    that the client is not detached anymore. */
3424
3425 void silc_server_resume_client(SilcServer server,
3426                                SilcPacketStream sock,
3427                                SilcPacket packet)
3428 {
3429   SilcBuffer buffer = &packet->buffer, buf;
3430   SilcIDListData idata = silc_packet_get_context(sock);
3431   SilcIDCacheEntry id_cache = NULL;
3432   SilcClientEntry detached_client;
3433   SilcClientID client_id;
3434   unsigned char *id_string, *auth = NULL, *nicknamec = NULL;
3435   unsigned char cid[32];
3436   SilcUInt32 cid_len;
3437   SilcUInt16 id_len, auth_len = 0;
3438   SilcBool resolved, local, nick_change = FALSE, resolve = FALSE;
3439   SilcChannelEntry channel;
3440   SilcHashTableList htl;
3441   SilcChannelClientEntry chl;
3442   SilcServerResumeResolve r;
3443   SilcPublicKey public_key;
3444   const char *cipher, *hostname, *ip;
3445
3446   SILC_LOG_DEBUG(("Resuming client"));
3447
3448   silc_socket_stream_get_info(silc_packet_stream_get_stream(sock),
3449                               NULL, &hostname, &ip, NULL);
3450
3451   if (silc_buffer_unformat(buffer,
3452                            SILC_STR_UI16_NSTRING(&id_string, &id_len),
3453                            SILC_STR_END) < 0) {
3454     if (idata->conn_type == SILC_CONN_CLIENT) {
3455       SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3456                       "closing connection", hostname, ip));
3457       silc_server_disconnect_remote(server, sock,
3458                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3459                                     "Resuming not possible");
3460       silc_server_free_sock_user_data(server, sock, NULL);
3461     }
3462     goto out;
3463   }
3464
3465   silc_id_str2id(id_string, id_len, SILC_ID_CLIENT, &client_id,
3466                  sizeof(client_id));
3467
3468   if (idata->conn_type == SILC_CONN_CLIENT) {
3469     /* Client send this and is attempting to resume to old client session */
3470     SilcClientEntry client;
3471     SilcBuffer keyp;
3472
3473     silc_buffer_pull(buffer, 2 + id_len);
3474     auth = buffer->data;
3475     auth_len = silc_buffer_len(buffer);
3476     silc_buffer_push(buffer, 2 + id_len);
3477
3478     if (auth_len < 128) {
3479       SILC_LOG_ERROR(("Client %s (%s) sent incomplete resume information, "
3480                       "closing connection", hostname, ip));
3481       silc_server_disconnect_remote(server, sock,
3482                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3483                                     "Resuming not possible");
3484       silc_server_free_sock_user_data(server, sock, NULL);
3485       goto out;
3486     }
3487
3488     /* Take client entry of this connection */
3489     client = (SilcClientEntry)idata;
3490
3491     /* Get entry to the client, and resolve it if we don't have it. */
3492     detached_client = silc_server_query_client(server, &client_id, FALSE,
3493                                                &resolved);
3494     if (!detached_client) {
3495       if (resolved) {
3496         /* The client info is being resolved. Reprocess this packet after
3497            receiving the reply to the query. */
3498         SILC_LOG_DEBUG(("Resolving client"));
3499         r = silc_calloc(1, sizeof(*r));
3500         if (!r)
3501           goto out;
3502         silc_packet_stream_ref(sock);
3503         r->server = server;
3504         r->sock = sock;
3505         r->packet = packet;
3506         r->client_id = client_id;
3507         silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3508                                     server->cmd_ident,
3509                                     silc_server_command_resume_resolve, r);
3510         return;
3511       } else {
3512         SILC_LOG_ERROR(("Client %s (%s) tried to resume unknown client, "
3513                         "closing connection", hostname, ip));
3514         silc_server_disconnect_remote(server, sock,
3515                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3516                                       "Resuming not possible");
3517         silc_server_free_sock_user_data(server, sock, NULL);
3518         goto out;
3519       }
3520     }
3521
3522     if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED) {
3523       SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
3524                       "closing connection", hostname, ip));
3525       silc_server_disconnect_remote(server, sock,
3526                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3527                                     "Resuming not possible");
3528       silc_server_free_sock_user_data(server, sock, NULL);
3529       goto out;
3530     }
3531
3532     if (detached_client->resuming_client &&
3533         detached_client->resuming_client != client) {
3534       SILC_LOG_ERROR(("Client %s (%s) tried to attach more than once, "
3535                       "closing connection", hostname, ip));
3536       silc_server_disconnect_remote(server, sock,
3537                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3538                                     "Resuming not possible");
3539       silc_server_free_sock_user_data(server, sock, NULL);
3540       goto out;
3541     }
3542
3543     if (!detached_client->resuming_client)
3544       detached_client->resuming_client = client;
3545
3546     if (!(detached_client->mode & SILC_UMODE_DETACHED))
3547       resolve = TRUE;
3548     if (!silc_hash_table_count(detached_client->channels) &&
3549         detached_client->router)
3550       resolve = TRUE;
3551     if (!detached_client->nickname)
3552       resolve = TRUE;
3553     if (detached_client->data.status & SILC_IDLIST_STATUS_RESUME_RES)
3554       resolve = FALSE;
3555
3556     if (resolve) {
3557       if (server->server_type == SILC_SERVER && !server->standalone) {
3558         /* The client info is being resolved. Reprocess this packet after
3559            receiving the reply to the query. */
3560         SILC_LOG_DEBUG(("Resolving client info"));
3561         silc_server_query_client(server, &client_id, TRUE, NULL);
3562         r = silc_calloc(1, sizeof(*r));
3563         if (!r)
3564           return;
3565         silc_packet_stream_ref(sock);
3566         r->server = server;
3567         r->sock = sock;
3568         r->packet = packet;
3569         r->client_id = client_id;
3570         silc_server_command_pending(server, SILC_COMMAND_WHOIS,
3571                                     server->cmd_ident,
3572                                     silc_server_command_resume_resolve, r);
3573         return;
3574       }
3575       if (server->server_type == SILC_SERVER) {
3576         SILC_LOG_ERROR(("Client %s (%s) tried to resume un-detached client, "
3577                         "closing connection", hostname, ip));
3578         silc_server_disconnect_remote(server, sock,
3579                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3580                                       "Resuming not possible");
3581         silc_server_free_sock_user_data(server, sock, NULL);
3582         goto out;
3583       }
3584     }
3585
3586     /* Check that we have the public key of the client, if not then we must
3587        resolve it first. */
3588     if (!detached_client->data.public_key) {
3589       if (server->server_type == SILC_SERVER && server->standalone) {
3590         SILC_LOG_ERROR(("Detached client's public key not present, "
3591                         "closing connection"));
3592         silc_server_disconnect_remote(server, sock,
3593                                       SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3594                                       "Resuming not possible");
3595         silc_server_free_sock_user_data(server, sock, NULL);
3596         goto out;
3597       } else {
3598         /* We must retrieve the detached client's public key by sending
3599            GETKEY command. Reprocess this packet after receiving the key */
3600         SilcBuffer idp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
3601         SilcPacketStream dest_sock =
3602           silc_server_get_client_route(server, NULL, 0, &client_id,
3603                                        NULL, NULL);
3604
3605         SILC_LOG_DEBUG(("Resolving client public key"));
3606
3607         silc_server_send_command(server, dest_sock ? dest_sock :
3608                                  SILC_PRIMARY_ROUTE(server),
3609                                  SILC_COMMAND_GETKEY, ++server->cmd_ident,
3610                                  1, 1, idp->data, silc_buffer_len(idp));
3611
3612         r = silc_calloc(1, sizeof(*r));
3613         if (!r)
3614           return;
3615         silc_packet_stream_ref(sock);
3616         r->server = server;
3617         r->sock = sock;
3618         r->packet = packet;
3619         r->client_id = client_id;
3620         silc_server_command_pending(server, SILC_COMMAND_GETKEY,
3621                                     server->cmd_ident,
3622                                     silc_server_command_resume_resolve, r);
3623
3624         silc_buffer_free(idp);
3625         return;
3626       }
3627     } else if (!silc_pkcs_public_key_compare(detached_client->data.public_key,
3628                                              idata->public_key)) {
3629       /* We require that the connection and resuming authentication data
3630          must be using same key pair. */
3631       SILC_LOG_ERROR(("Resuming attempted with wrong public key, "
3632                       "closing connection"));
3633       silc_server_disconnect_remote(server, sock,
3634                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3635                                     "Resuming not possible");
3636       silc_server_free_sock_user_data(server, sock, NULL);
3637       goto out;
3638     }
3639
3640     /* Verify the authentication payload.  This has to be successful in
3641        order to allow the resuming */
3642     if (!idata->hash ||
3643         !silc_auth_verify_data(auth, auth_len, SILC_AUTH_PUBLIC_KEY,
3644                                detached_client->data.public_key, 0,
3645                                idata->hash, detached_client->id,
3646                                SILC_ID_CLIENT)) {
3647       SILC_LOG_ERROR(("Client %s (%s) resume authentication failed, "
3648                       "closing connection", hostname, ip));
3649       silc_server_disconnect_remote(server, sock,
3650                                     SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
3651                                     "Resuming not possible");
3652       silc_server_free_sock_user_data(server, sock, NULL);
3653       goto out;
3654     }
3655
3656     /* Check nickname */
3657     nicknamec = silc_identifier_check(detached_client->nickname,
3658                                       strlen(detached_client->nickname),
3659                                       SILC_STRING_UTF8, 128, NULL);
3660     if (!nicknamec) {
3661       silc_server_disconnect_remote(server, sock,
3662                                     SILC_STATUS_ERR_BAD_NICKNAME,
3663                                     "Malformed nickname, cannot resume");
3664       silc_server_free_sock_user_data(server, sock, NULL);
3665       goto out;
3666     }
3667
3668     /* If the ID is not based in our ID then change it */
3669     if (!SILC_ID_COMPARE(detached_client->id, server->id,
3670                          server->id->ip.data_len)) {
3671       SilcClientID *new_id;
3672       if (!silc_id_create_client_id(server, server->id, server->rng,
3673                                     server->md5hash, nicknamec,
3674                                     strlen(nicknamec), &new_id)) {
3675         silc_server_disconnect_remote(server, sock,
3676                                       SILC_STATUS_ERR_BAD_NICKNAME,
3677                                       "Resuming not possible");
3678         silc_server_free_sock_user_data(server, sock, NULL);
3679         goto out;
3680       }
3681       nick_change = TRUE;
3682       client_id = *new_id;
3683       silc_free(new_id);
3684     }
3685
3686     /* Now resume the client to the network */
3687
3688     silc_schedule_task_del_by_context(server->schedule, detached_client);
3689     silc_packet_set_context(sock, detached_client);
3690     detached_client->connection = sock;
3691
3692     if (detached_client->data.public_key) {
3693       /* Delete the detached client's public key from repository */
3694       silc_skr_del_public_key(server->repository,
3695                               detached_client->data.public_key,
3696                               detached_client);
3697       detached_client->data.public_key = NULL;
3698     }
3699
3700     if (idata->public_key) {
3701       /* Delete the resuming client's public key from repository.  It will
3702          be added later again. */
3703       public_key = silc_pkcs_public_key_copy(idata->public_key);
3704       silc_skr_del_public_key(server->repository, idata->public_key, idata);
3705       idata->public_key = public_key;
3706     }
3707
3708     /* Take new keys and stuff into use in the old entry */
3709     silc_idlist_del_data(detached_client);
3710     silc_idlist_add_data(detached_client, idata);
3711     idata->public_key = NULL;
3712
3713     if (detached_client->data.public_key) {
3714       /* Add the resumed client's public key back to repository. */
3715       if (!silc_server_get_public_key_by_client(server, detached_client, NULL))
3716         silc_skr_add_public_key_simple(server->repository,
3717                                        detached_client->data.public_key,
3718                                        SILC_SKR_USAGE_IDENTIFICATION,
3719                                        detached_client, NULL);
3720     }
3721
3722     detached_client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
3723     detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3724     detached_client->data.status |= SILC_IDLIST_STATUS_LOCAL;
3725     detached_client->data.status &= ~SILC_IDLIST_STATUS_RESUME_RES;
3726     detached_client->mode &= ~SILC_UMODE_DETACHED;
3727     server->stat.my_detached--;
3728     silc_dlist_del(server->expired_clients, detached_client);
3729
3730     /* We are finished - reset resuming client */
3731     detached_client->resuming_client = NULL;
3732
3733     /* Check if anyone is watching this client */
3734     if (server->server_type == SILC_ROUTER)
3735       silc_server_check_watcher_list(server, detached_client, NULL,
3736                                      SILC_NOTIFY_TYPE_UMODE_CHANGE);
3737
3738     /* Delete this current client entry since we're resuming to old one.
3739        We decrement clients/cell_clients as we are getting rid of the
3740        current client and replacing it with the detached one.  We keep the
3741        server user count as-is (incremented by the current client entry) as
3742        we decremented the count already during detach, thus we'd be undoing
3743        that operation. */
3744     detached_client->local_detached = FALSE;
3745     SILC_VERIFY(server->stat.clients > 0);
3746     server->stat.clients--;
3747     if (server->stat.cell_clients)
3748       server->stat.cell_clients--;
3749     silc_server_remove_from_channels(server, NULL, client, FALSE,
3750                                      NULL, FALSE, FALSE);
3751     silc_server_del_from_watcher_list(server, client);
3752     silc_dlist_del(server->expired_clients, client);
3753     if (!silc_idlist_del_client(server->local_list, client))
3754       silc_idlist_del_client(server->global_list, client);
3755     client = detached_client;
3756     silc_free(client->servername);
3757     client->servername = strdup(server->server_name);
3758
3759     /* Send the RESUME_CLIENT packet to our primary router so that others
3760        know this client isn't detached anymore. */
3761     buf = silc_buffer_alloc_size(2 + id_len);
3762     silc_buffer_format(buf,
3763                        SILC_STR_UI_SHORT(id_len),
3764                        SILC_STR_UI_XNSTRING(id_string, id_len),
3765                        SILC_STR_END);
3766
3767     /* Send to primary router */
3768     silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3769                             SILC_PACKET_RESUME_CLIENT, 0,
3770                             buf->data, silc_buffer_len(buf));
3771     silc_server_backup_send(server, client->router,
3772                             SILC_PACKET_RESUME_CLIENT, 0,
3773                             buf->data, silc_buffer_len(buf), TRUE, TRUE);
3774
3775     /* As router we must deliver this packet directly to the original
3776        server whom this client was earlier. */
3777     if (server->server_type == SILC_ROUTER && client->router &&
3778         client->router->server_type != SILC_ROUTER)
3779       silc_server_packet_send(server, client->router->connection,
3780                               SILC_PACKET_RESUME_CLIENT, 0,
3781                               buf->data, silc_buffer_len(buf));
3782     silc_buffer_free(buf);
3783     client->router = NULL;
3784
3785     if (nick_change) {
3786       /* Notify about Client ID change, nickname doesn't actually change. */
3787       silc_server_send_notify_nick_change(server, SILC_PRIMARY_ROUTE(server),
3788                                           SILC_BROADCAST(server),
3789                                           client->id, &client_id,
3790                                           client->nickname);
3791     }
3792
3793     /* Resolve users on those channels that client has joined but we
3794        haven't resolved user list yet. */
3795     if (server->server_type == SILC_SERVER && !server->standalone) {
3796       silc_hash_table_list(client->channels, &htl);
3797       while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3798         channel = chl->channel;
3799         SILC_LOG_DEBUG(("Resolving users for %s channel",
3800                         channel->channel_name));
3801         if (channel->disabled || !channel->users_resolved) {
3802           silc_server_send_command(server, SILC_PRIMARY_ROUTE(server),
3803                                    SILC_COMMAND_USERS, ++server->cmd_ident,
3804                                    1, 2, channel->channel_name,
3805                                    strlen(channel->channel_name));
3806         }
3807       }
3808       silc_hash_table_list_reset(&htl);
3809     }
3810
3811     /* Send the new client ID to the client. After this client may start
3812        receiving other packets, and may start sending packets too. */
3813     silc_server_send_new_id(server, sock, FALSE, &client_id, SILC_ID_CLIENT,
3814                             silc_id_get_len(&client_id, SILC_ID_CLIENT));
3815
3816     if (nick_change) {
3817       /* Send NICK change notify to channels as well. */
3818       SilcBuffer oidp, nidp;
3819       oidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3820       nidp = silc_id_payload_encode(&client_id, SILC_ID_CLIENT);
3821       silc_server_send_notify_on_channels(server, NULL, client,
3822                                           SILC_NOTIFY_TYPE_NICK_CHANGE, 3,
3823                                           oidp->data, silc_buffer_len(oidp),
3824                                           nidp->data, silc_buffer_len(nidp),
3825                                           client->nickname,
3826                                           strlen(client->nickname));
3827       silc_buffer_free(oidp);
3828       silc_buffer_free(nidp);
3829     }
3830
3831     /* Update entry */
3832     if (!silc_idcache_update_by_context(server->local_list->clients, client,
3833                                         &client_id, NULL, FALSE))
3834       silc_idcache_update_by_context(server->global_list->clients, client,
3835                                      &client_id, NULL, FALSE);
3836
3837     /* Move entry to local list if it is in global list */
3838     if (silc_idcache_find_by_context(server->global_list->clients, client,
3839                                      &id_cache))
3840       silc_idcache_move(server->global_list->clients,
3841                         server->local_list->clients, id_cache);
3842
3843     /* Send some nice info to the client */
3844     silc_server_send_connect_notifys(server, sock, client);
3845
3846     /* Send all channel keys of channels the client has joined */
3847     silc_hash_table_list(client->channels, &htl);
3848     while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3849       SilcBool created = FALSE;
3850       channel = chl->channel;
3851
3852       if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY)
3853         continue;
3854
3855       /* If we don't have channel key, then create one */
3856       if (!channel->send_key) {
3857         if (!silc_server_create_channel_key(server, channel, 0))
3858           continue;
3859         created = TRUE;
3860       }
3861
3862       silc_id_id2str(channel->id, SILC_ID_CHANNEL, cid, sizeof(cid),
3863                      &cid_len);
3864       cipher = silc_cipher_get_name(channel->send_key);
3865       keyp =
3866         silc_channel_key_payload_encode(cid_len, cid,
3867                                         strlen(cipher), cipher,
3868                                         channel->key_len / 8, channel->key);
3869
3870       /* Send the channel key to the client */
3871       silc_server_packet_send(server, sock, SILC_PACKET_CHANNEL_KEY, 0,
3872                               keyp->data, silc_buffer_len(keyp));
3873
3874       /* Distribute the channel key to channel */
3875       if (created) {
3876         silc_server_send_channel_key(server, NULL, channel,
3877                                      server->server_type == SILC_ROUTER ?
3878                                      FALSE : !server->standalone);
3879         silc_server_backup_send(server, NULL, SILC_PACKET_CHANNEL_KEY, 0,
3880                                 keyp->data, silc_buffer_len(keyp),
3881                                 FALSE, TRUE);
3882       }
3883
3884       silc_buffer_free(keyp);
3885     }
3886     silc_hash_table_list_reset(&htl);
3887
3888   } else if (idata->conn_type != SILC_CONN_CLIENT) {
3889     /* Server or router sent this to us to notify that that a client has
3890        been resumed. */
3891     SilcServerEntry server_entry;
3892     SilcServerID server_id;
3893
3894     /* Get entry to the client, and resolve it if we don't have it. */
3895     detached_client = silc_idlist_find_client_by_id(server->local_list,
3896                                                     &client_id, TRUE,
3897                                                     &id_cache);
3898     if (!detached_client) {
3899       detached_client = silc_idlist_find_client_by_id(server->global_list,
3900                                                       &client_id, TRUE,
3901                                                       &id_cache);
3902       if (!detached_client) {
3903         SILC_LOG_DEBUG(("Resuming client is unknown"));
3904         goto out;
3905       }
3906     }
3907
3908     /* Check that the client has not been resumed already because it is
3909        protocol error to attempt to resume more than once.  The client
3910        will be killed if this protocol error occurs. */
3911     if (detached_client->data.status & SILC_IDLIST_STATUS_RESUMED &&
3912         !(detached_client->mode & SILC_UMODE_DETACHED)) {
3913       /* The client is clearly attempting to resume more than once and
3914          perhaps playing around by resuming from several different places
3915          at the same time. */
3916       SILC_LOG_DEBUG(("Attempting to re-resume client, killing both"));
3917       silc_server_kill_client(server, detached_client, NULL,
3918                               server->id, SILC_ID_SERVER);
3919       goto out;
3920     }
3921
3922     /* Check whether client is detached at all */
3923     if (!(detached_client->mode & SILC_UMODE_DETACHED)) {
3924       SILC_LOG_DEBUG(("Client is not detached"));
3925       goto out;
3926     }
3927
3928     /* Check nickname */
3929     if (detached_client->nickname) {
3930       nicknamec = silc_identifier_check(detached_client->nickname,
3931                                         strlen(detached_client->nickname),
3932                                         SILC_STRING_UTF8, 128, NULL);
3933       if (!nicknamec)
3934         goto out;
3935     }
3936
3937     SILC_LOG_DEBUG(("Resuming detached client"));
3938
3939     /* If the sender of this packet is server and we are router we need to
3940        broadcast this packet to other routers in the network. */
3941     if (server->server_type == SILC_ROUTER &&
3942         idata->conn_type == SILC_CONN_SERVER &&
3943         !(packet->flags & SILC_PACKET_FLAG_BROADCAST)) {
3944       SILC_LOG_DEBUG(("Broadcasting received Resume Client packet"));
3945       silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
3946                               packet->type,
3947                               packet->flags | SILC_PACKET_FLAG_BROADCAST,
3948                               buffer->data, silc_buffer_len(buffer));
3949       silc_server_backup_send(server, (SilcServerEntry)idata,
3950                               packet->type, packet->flags,
3951                               packet->buffer.data,
3952                               silc_buffer_len(&packet->buffer),
3953                               FALSE, TRUE);
3954     }
3955
3956     /* If the client has a locally-connected previous owner, then we
3957        will need to notify them that the resume has completed.  Note
3958        that if the previous owner was a router, this case is already
3959        handled above by the broadcast, so we shouldn't attempt to
3960        send another notification in that case.   Additionally, if
3961        the previous owner was the server that sent the packet, then
3962        we'll not send the notification as it will have already done
3963        the necessary work locally. */
3964     if (server->server_type == SILC_ROUTER &&
3965         idata->conn_type == SILC_CONN_SERVER &&
3966         detached_client->router &&
3967         SILC_IS_LOCAL(detached_client->router) &&
3968         detached_client->router->server_type != SILC_ROUTER)
3969       silc_server_packet_send(server, detached_client->router->connection,
3970                               SILC_PACKET_RESUME_CLIENT, 0,
3971                               buffer->data, silc_buffer_len(buffer));
3972
3973     /* Client is detached, and now it is resumed.  Remove the detached
3974        mode and mark that it is resumed. */
3975
3976     if (detached_client->data.public_key) {
3977       /* Delete the detached client's public key from repository */
3978       silc_skr_del_public_key(server->repository,
3979                               detached_client->data.public_key,
3980                               detached_client);
3981       detached_client->data.public_key = NULL;
3982     }
3983
3984     silc_idlist_del_data(detached_client);
3985     detached_client->mode &= ~SILC_UMODE_DETACHED;
3986     detached_client->data.status |= SILC_IDLIST_STATUS_RESUMED;
3987     detached_client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3988     silc_dlist_del(server->expired_clients, detached_client);
3989
3990     /* Check if anyone is watching this client */
3991     if (server->server_type == SILC_ROUTER)
3992       silc_server_check_watcher_list(server, detached_client, NULL,
3993                                      SILC_NOTIFY_TYPE_UMODE_CHANGE);
3994
3995     silc_schedule_task_del_by_context(server->schedule, detached_client);
3996
3997     /* Get the new owner of the resumed client */
3998     if (!silc_id_str2id(packet->src_id, packet->src_id_len,
3999                         packet->src_id_type, &server_id, sizeof(server_id)))
4000       goto out;
4001
4002     /* Get server entry */
4003     server_entry = silc_idlist_find_server_by_id(server->global_list,
4004                                                  &server_id, TRUE, NULL);
4005     local = FALSE;
4006     if (!server_entry) {
4007       server_entry = silc_idlist_find_server_by_id(server->local_list,
4008                                                    &server_id, TRUE, NULL);
4009       local = TRUE;
4010       if (!server_entry)
4011         goto out;
4012     }
4013
4014     if (server->server_type == SILC_ROUTER &&
4015         idata->conn_type == SILC_CONN_ROUTER &&
4016         server_entry->server_type == SILC_ROUTER)
4017       local = FALSE;
4018
4019     /* Move entry to correct list */
4020     if (local && server->server_type == SILC_ROUTER) {
4021       if (silc_idcache_find_by_context(server->global_list->clients,
4022                                        detached_client, &id_cache))
4023         silc_idcache_move(server->global_list->clients,
4024                           server->local_list->clients, id_cache);
4025     } else {
4026       if (silc_idcache_find_by_context(server->local_list->clients,
4027                                        detached_client, &id_cache))
4028         silc_idcache_move(server->local_list->clients,
4029                           server->global_list->clients, id_cache);
4030       }
4031
4032     /* We don't own this client anymore, if we ever did, as we were just
4033      * told that someone else resumed it.  Thus, it is most definitely no
4034      * a detached client.*/
4035     detached_client->local_detached = FALSE;
4036     /* Change the owner of the client */
4037     detached_client->router = server_entry;
4038
4039     /* Update channel information regarding global clients on channel. */
4040     if (server->server_type != SILC_ROUTER) {
4041       silc_hash_table_list(detached_client->channels, &htl);
4042       while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4043         chl->channel->global_users =
4044           silc_server_channel_has_global(chl->channel);
4045       silc_hash_table_list_reset(&htl);
4046     }
4047   }
4048
4049  out:
4050   silc_packet_free(packet);
4051 }