5 Author: Pekka Riikonen <priikone@silcnet.org>
7 Copyright (C) 1997 - 2002 Pekka Riikonen
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; version 2 of the License.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
20 * This is the actual SILC server than handles everything relating to
21 * servicing the SILC connections. This is also a SILC router as a router
22 * is also normal server.
26 #include "serverincludes.h"
27 #include "server_internal.h"
29 /* Static prototypes */
30 SILC_TASK_CALLBACK(silc_server_rehash_close_connection);
31 SILC_TASK_CALLBACK(silc_server_connect_to_router_retry);
32 SILC_TASK_CALLBACK(silc_server_connect_router);
33 SILC_TASK_CALLBACK(silc_server_connect_to_router_second);
34 SILC_TASK_CALLBACK(silc_server_connect_to_router_final);
35 SILC_TASK_CALLBACK(silc_server_accept_new_connection);
36 SILC_TASK_CALLBACK(silc_server_accept_new_connection_second);
37 SILC_TASK_CALLBACK(silc_server_accept_new_connection_final);
38 SILC_TASK_CALLBACK(silc_server_packet_process);
39 SILC_TASK_CALLBACK(silc_server_packet_parse_real);
40 SILC_TASK_CALLBACK(silc_server_close_connection_final);
41 SILC_TASK_CALLBACK(silc_server_free_client_data_timeout);
42 SILC_TASK_CALLBACK(silc_server_timeout_remote);
43 SILC_TASK_CALLBACK(silc_server_channel_key_rekey);
44 SILC_TASK_CALLBACK(silc_server_get_stats);
46 /* Allocates a new SILC server object. This has to be done before the server
47 can be used. After allocation one must call silc_server_init to initialize
48 the server. The new allocated server object is returned to the new_server
51 int silc_server_alloc(SilcServer *new_server)
55 SILC_LOG_DEBUG(("Allocating new server object"));
57 server = silc_calloc(1, sizeof(*server));
58 server->server_type = SILC_SERVER;
59 server->standalone = TRUE;
60 server->local_list = silc_calloc(1, sizeof(*server->local_list));
61 server->global_list = silc_calloc(1, sizeof(*server->global_list));
62 server->pending_commands = silc_dlist_init();
64 server->sim = silc_dlist_init();
72 /* Free's the SILC server object. This is called at the very end before
75 void silc_server_free(SilcServer server)
78 SilcIDCacheEntry cache;
86 silc_dlist_start(server->sim);
87 while ((sim = silc_dlist_get(server->sim)) != SILC_LIST_END) {
88 silc_dlist_del(server->sim, sim);
92 silc_dlist_uninit(server->sim);
96 silc_server_backup_free(server);
97 silc_server_config_unref(&server->config_ref);
99 silc_rng_free(server->rng);
101 silc_pkcs_free(server->pkcs);
102 if (server->public_key)
103 silc_pkcs_public_key_free(server->public_key);
104 if (server->private_key)
105 silc_pkcs_private_key_free(server->private_key);
106 if (server->pending_commands)
107 silc_dlist_uninit(server->pending_commands);
108 if (server->id_entry)
109 silc_idlist_del_server(server->local_list, server->id_entry);
111 /* Delete all channels */
113 if (silc_idcache_get_all(server->local_list->channels, &list) &&
114 silc_idcache_list_first(list, &cache)) {
115 silc_idlist_del_channel(server->local_list, cache->context);
116 while (silc_idcache_list_next(list, &cache))
117 silc_idlist_del_channel(server->local_list, cache->context);
120 silc_idcache_list_free(list);
122 if (silc_idcache_get_all(server->global_list->channels, &list) &&
123 silc_idcache_list_first(list, &cache)) {
124 silc_idlist_del_channel(server->global_list, cache->context);
125 while (silc_idcache_list_next(list, &cache))
126 silc_idlist_del_channel(server->global_list, cache->context);
129 silc_idcache_list_free(list);
131 /* Delete all clients */
133 if (silc_idcache_get_all(server->local_list->clients, &list) &&
134 silc_idcache_list_first(list, &cache)) {
135 silc_idlist_del_client(server->local_list, cache->context);
136 while (silc_idcache_list_next(list, &cache))
137 silc_idlist_del_client(server->local_list, cache->context);
140 silc_idcache_list_free(list);
142 if (silc_idcache_get_all(server->global_list->clients, &list) &&
143 silc_idcache_list_first(list, &cache)) {
144 silc_idlist_del_client(server->global_list, cache->context);
145 while (silc_idcache_list_next(list, &cache))
146 silc_idlist_del_client(server->global_list, cache->context);
149 silc_idcache_list_free(list);
151 /* Delete all servers */
153 if (silc_idcache_get_all(server->local_list->servers, &list) &&
154 silc_idcache_list_first(list, &cache)) {
155 silc_idlist_del_server(server->local_list, cache->context);
156 while (silc_idcache_list_next(list, &cache))
157 silc_idlist_del_server(server->local_list, cache->context);
160 silc_idcache_list_free(list);
162 if (silc_idcache_get_all(server->global_list->servers, &list) &&
163 silc_idcache_list_first(list, &cache)) {
164 silc_idlist_del_server(server->global_list, cache->context);
165 while (silc_idcache_list_next(list, &cache))
166 silc_idlist_del_server(server->global_list, cache->context);
169 silc_idcache_list_free(list);
171 silc_idcache_free(server->local_list->clients);
172 silc_idcache_free(server->local_list->servers);
173 silc_idcache_free(server->local_list->channels);
174 silc_idcache_free(server->global_list->clients);
175 silc_idcache_free(server->global_list->servers);
176 silc_idcache_free(server->global_list->channels);
177 silc_hash_table_free(server->watcher_list);
179 silc_hash_free(server->md5hash);
180 silc_hash_free(server->sha1hash);
181 silc_hmac_unregister_all();
182 silc_hash_unregister_all();
183 silc_cipher_unregister_all();
184 silc_pkcs_unregister_all();
186 silc_free(server->local_list);
187 silc_free(server->global_list);
188 silc_free(server->server_name);
189 silc_free(server->id_string);
190 silc_free(server->purge_i);
191 silc_free(server->purge_g);
195 /* Creates a new server listener. */
197 static bool silc_server_listen(SilcServer server, const char *server_ip,
198 SilcUInt16 port, int *sock)
200 *sock = silc_net_create_server(port, server_ip);
202 SILC_SERVER_LOG_ERROR(("Could not create server listener: %s on %hu",
209 /* Adds a secondary listener. */
211 bool silc_server_init_secondary(SilcServer server)
213 int sock = 0, sock_list[server->config->param.connections_max];
214 SilcSocketConnection newsocket = NULL;
215 SilcServerConfigServerInfoInterface *interface;
217 for (interface = server->config->server_info->secondary; interface;
218 interface = interface->next, sock++) {
220 if (!silc_server_listen(server,
221 interface->server_ip, interface->port, &sock_list[sock]))
224 /* Set socket to non-blocking mode */
225 silc_net_set_socket_nonblock(sock_list[sock]);
227 /* Add ourselves also to the socket table. The entry allocated above
228 is sent as argument for fast referencing in the future. */
229 silc_socket_alloc(sock_list[sock],
230 SILC_SOCKET_TYPE_SERVER, NULL, &newsocket);
231 server->sockets[sock_list[sock]] = newsocket;
232 SILC_SET_LISTENER(newsocket);
234 /* Perform name and address lookups to resolve the listenning address
236 if (!silc_net_check_local_by_sock(sock_list[sock], &newsocket->hostname,
238 if ((server->config->require_reverse_lookup && !newsocket->hostname) ||
240 SILC_LOG_ERROR(("IP/DNS lookup failed for local host %s",
241 newsocket->hostname ? newsocket->hostname :
242 newsocket->ip ? newsocket->ip : ""));
243 server->stat.conn_failures++;
246 if (!newsocket->hostname)
247 newsocket->hostname = strdup(newsocket->ip);
249 newsocket->port = silc_net_get_local_port(sock);
251 newsocket->user_data = (void *)server->id_entry;
252 silc_schedule_task_add(server->schedule, sock_list[sock],
253 silc_server_accept_new_connection,
254 (void *)server, 0, 0,
256 SILC_TASK_PRI_NORMAL);
262 do silc_net_close_server(sock_list[sock--]); while (sock >= 0);
266 /* Initializes the entire SILC server. This is called always before running
267 the server. This is called only once at the initialization of the program.
268 This binds the server to its listenning port. After this function returns
269 one should call silc_server_run to start the server. This returns TRUE
270 when everything is ok to run the server. Configuration file must be
271 read and parsed before calling this. */
273 bool silc_server_init(SilcServer server)
277 SilcServerEntry id_entry;
278 SilcIDListPurge purge;
279 SilcSocketConnection newsocket = NULL;
281 SILC_LOG_DEBUG(("Initializing server"));
283 server->starttime = time(NULL);
285 /* Take config object for us */
286 silc_server_config_ref(&server->config_ref, server->config,
289 /* Steal public and private key from the config object */
290 server->public_key = server->config->server_info->public_key;
291 server->private_key = server->config->server_info->private_key;
292 server->config->server_info->public_key = NULL;
293 server->config->server_info->private_key = NULL;
295 /* Register all configured ciphers, PKCS and hash functions. */
296 if (!silc_server_config_register_ciphers(server))
297 silc_cipher_register_default();
298 if (!silc_server_config_register_pkcs(server))
299 silc_pkcs_register_default();
300 if (!silc_server_config_register_hashfuncs(server))
301 silc_hash_register_default();
302 if (!silc_server_config_register_hmacs(server))
303 silc_hmac_register_default();
305 /* Initialize random number generator for the server. */
306 server->rng = silc_rng_alloc();
307 silc_rng_init(server->rng);
308 silc_rng_global_init(server->rng);
310 /* Initialize hash functions for server to use */
311 silc_hash_alloc("md5", &server->md5hash);
312 silc_hash_alloc("sha1", &server->sha1hash);
314 /* Allocate PKCS context for local public and private keys */
315 if (!silc_pkcs_alloc(server->public_key->name, &server->pkcs))
317 silc_pkcs_public_key_set(server->pkcs, server->public_key);
318 silc_pkcs_private_key_set(server->pkcs, server->private_key);
320 /* Initialize the scheduler */
321 server->schedule = silc_schedule_init(server->config->param.connections_max,
323 if (!server->schedule)
326 /* First, register log files configuration for error output */
327 silc_server_config_setlogfiles(server);
329 /* Initialize ID caches */
330 server->local_list->clients =
331 silc_idcache_alloc(0, SILC_ID_CLIENT, silc_idlist_client_destructor);
332 server->local_list->servers = silc_idcache_alloc(0, SILC_ID_SERVER, NULL);
333 server->local_list->channels = silc_idcache_alloc(0, SILC_ID_CHANNEL, NULL);
335 /* These are allocated for normal server as well as these hold some
336 global information that the server has fetched from its router. For
337 router these are used as they are supposed to be used on router. */
338 server->global_list->clients =
339 silc_idcache_alloc(0, SILC_ID_CLIENT, silc_idlist_client_destructor);
340 server->global_list->servers = silc_idcache_alloc(0, SILC_ID_SERVER, NULL);
341 server->global_list->channels = silc_idcache_alloc(0, SILC_ID_CHANNEL, NULL);
343 /* Init watcher list */
344 server->watcher_list =
345 silc_hash_table_alloc(1, silc_hash_client_id_hash, NULL,
346 silc_hash_data_compare, (void *)CLIENTID_HASH_LEN,
348 if (!server->watcher_list)
351 /* Create a listening server */
352 if (!silc_server_listen(server,
353 server->config->server_info->primary == NULL ? NULL :
354 server->config->server_info->primary->server_ip,
355 server->config->server_info->primary == NULL ? 0 :
356 server->config->server_info->primary->port,
360 /* Set socket to non-blocking mode */
361 silc_net_set_socket_nonblock(sock);
364 /* Allocate the entire socket list that is used in server. Eventually
365 all connections will have entry in this table (it is a table of
366 pointers to the actual object that is allocated individually
368 server->sockets = silc_calloc(server->config->param.connections_max,
369 sizeof(*server->sockets));
370 if (!server->sockets)
373 /* Add ourselves also to the socket table. The entry allocated above
374 is sent as argument for fast referencing in the future. */
375 silc_socket_alloc(sock, SILC_SOCKET_TYPE_SERVER, NULL, &newsocket);
376 server->sockets[sock] = newsocket;
377 SILC_SET_LISTENER(newsocket);
379 /* Perform name and address lookups to resolve the listenning address
381 if (!silc_net_check_local_by_sock(sock, &newsocket->hostname,
383 if ((server->config->require_reverse_lookup && !newsocket->hostname) ||
385 SILC_LOG_ERROR(("IP/DNS lookup failed for local host %s",
386 newsocket->hostname ? newsocket->hostname :
387 newsocket->ip ? newsocket->ip : ""));
388 server->stat.conn_failures++;
391 if (!newsocket->hostname)
392 newsocket->hostname = strdup(newsocket->ip);
394 newsocket->port = silc_net_get_local_port(sock);
396 /* Create a Server ID for the server. */
397 silc_id_create_server_id(newsocket->ip, newsocket->port, server->rng, &id);
402 server->id_string = silc_id_id2str(id, SILC_ID_SERVER);
403 server->id_string_len = silc_id_get_len(id, SILC_ID_SERVER);
404 server->server_name = server->config->server_info->server_name;
405 server->config->server_info->server_name = NULL;
407 /* Add ourselves to the server list. We don't have a router yet
408 beacuse we haven't established a route yet. It will be done later.
409 For now, NULL is sent as router. This allocates new entry to
412 silc_idlist_add_server(server->local_list, strdup(server->server_name),
413 server->server_type, server->id, NULL, NULL);
415 SILC_LOG_ERROR(("Could not add ourselves to cache"));
418 id_entry->data.status |= SILC_IDLIST_STATUS_REGISTERED;
420 /* Put the allocated socket pointer also to the entry allocated above
421 for fast back-referencing to the socket list. */
422 newsocket->user_data = (void *)id_entry;
423 id_entry->connection = (void *)newsocket;
424 server->id_entry = id_entry;
426 /* Register protocols */
427 silc_server_protocols_register();
429 /* Add the first task to the scheduler. This is task that is executed by
430 timeout. It expires as soon as the caller calls silc_server_run. This
431 task performs authentication protocol and key exchange with our
433 silc_server_create_connections(server);
435 /* Add listener task to the scheduler. This task receives new connections
436 to the server. This task remains on the queue until the end of the
438 silc_schedule_task_add(server->schedule, sock,
439 silc_server_accept_new_connection,
440 (void *)server, 0, 0,
442 SILC_TASK_PRI_NORMAL);
444 if (silc_server_init_secondary(server) == FALSE)
447 server->listenning = TRUE;
449 /* If server connections has been configured then we must be router as
450 normal server cannot have server connections, only router connections. */
451 if (server->config->servers) {
452 SilcServerConfigServer *ptr = server->config->servers;
454 server->server_type = SILC_ROUTER;
456 if (ptr->backup_router) {
457 server->server_type = SILC_BACKUP_ROUTER;
458 server->backup_router = TRUE;
459 server->id_entry->server_type = SILC_BACKUP_ROUTER;
466 /* Register the ID Cache purge task. This periodically purges the ID cache
467 and removes the expired cache entries. */
469 /* Clients local list */
470 server->purge_i = purge = silc_calloc(1, sizeof(*purge));
471 purge->cache = server->local_list->clients;
472 purge->timeout = 600;
473 silc_schedule_task_add(server->schedule, 0, silc_idlist_purge,
474 (void *)purge, purge->timeout, 0,
475 SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
477 /* Clients global list */
478 server->purge_g = purge = silc_calloc(1, sizeof(*purge));
479 purge->cache = server->global_list->clients;
480 purge->timeout = 300;
481 silc_schedule_task_add(server->schedule, 0, silc_idlist_purge,
482 (void *)purge, purge->timeout, 0,
483 SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
485 /* If we are normal server we'll retrieve network statisticial information
486 once in a while from the router. */
487 if (server->server_type != SILC_ROUTER)
488 silc_schedule_task_add(server->schedule, 0, silc_server_get_stats,
489 server, 10, 0, SILC_TASK_TIMEOUT,
492 if (server->server_type == SILC_ROUTER)
493 server->stat.routers++;
495 SILC_LOG_DEBUG(("Server initialized"));
497 /* We are done here, return succesfully */
501 silc_server_config_unref(&server->config_ref);
502 silc_net_close_server(sock);
506 /* Task callback to close a socket connection after rehash */
508 SILC_TASK_CALLBACK(silc_server_rehash_close_connection)
510 SilcServer server = context;
511 SilcSocketConnection sock = server->sockets[fd];
516 SILC_LOG_INFO(("Connection %s:%d [%s] is unconfigured",
517 sock->hostname, sock->port,
518 (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
519 sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
520 sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
522 silc_schedule_task_del_by_context(server->schedule, sock);
523 silc_server_disconnect_remote(server, sock,
524 SILC_STATUS_ERR_BANNED_FROM_SERVER,
525 "This connection is removed from "
528 silc_server_free_sock_user_data(server, sock, NULL);
531 /* This function basically reads the config file again and switches the config
532 object pointed by the server object. After that, we have to fix various
533 things such as the server_name and the listening ports.
534 Keep in mind that we no longer have the root privileges at this point. */
536 bool silc_server_rehash(SilcServer server)
538 SilcServerConfig newconfig;
540 SILC_LOG_INFO(("Rehashing server"));
542 /* Reset the logging system */
543 silc_log_quick = TRUE;
544 silc_log_flush_all();
546 /* Start the main rehash phase (read again the config file) */
547 newconfig = silc_server_config_alloc(server->config_file);
549 SILC_LOG_ERROR(("Rehash FAILED."));
553 /* Reinit scheduler if necessary */
554 if (newconfig->param.connections_max > server->config->param.connections_max)
555 if (!silc_schedule_reinit(server->schedule,
556 newconfig->param.connections_max))
559 /* Fix the server_name field */
560 if (strcmp(server->server_name, newconfig->server_info->server_name)) {
561 silc_free(server->server_name);
562 server->server_name = newconfig->server_info->server_name;
563 newconfig->server_info->server_name = NULL;
565 /* Update the idcache list with a fresh pointer */
566 silc_free(server->id_entry->server_name);
567 server->id_entry->server_name = strdup(server->server_name);
568 if (!silc_idcache_del_by_context(server->local_list->servers,
571 if (!silc_idcache_add(server->local_list->servers,
572 server->id_entry->server_name,
573 server->id_entry->id, server->id_entry, 0, NULL))
578 silc_server_config_setlogfiles(server);
580 /* Change new key pair if necessary */
581 if (newconfig->server_info->public_key &&
582 !silc_pkcs_public_key_compare(server->public_key,
583 newconfig->server_info->public_key)) {
584 silc_pkcs_public_key_free(server->public_key);
585 silc_pkcs_private_key_free(server->private_key);
586 server->public_key = newconfig->server_info->public_key;
587 server->private_key = newconfig->server_info->private_key;
588 newconfig->server_info->public_key = NULL;
589 newconfig->server_info->private_key = NULL;
591 /* Allocate PKCS context for local public and private keys */
592 silc_pkcs_free(server->pkcs);
593 if (!silc_pkcs_alloc(server->public_key->name, &server->pkcs))
595 silc_pkcs_public_key_set(server->pkcs, server->public_key);
596 silc_pkcs_private_key_set(server->pkcs, server->private_key);
599 /* Check for unconfigured server and router connections and close
600 connections that were unconfigured. */
602 if (server->config->routers) {
603 SilcServerConfigRouter *ptr;
604 SilcServerConfigRouter *newptr;
607 for (ptr = server->config->routers; ptr; ptr = ptr->next) {
610 /* Check whether new config has this one too */
611 for (newptr = newconfig->routers; newptr; newptr = newptr->next) {
612 if (silc_string_compare(newptr->host, ptr->host) &&
613 newptr->port == ptr->port &&
614 newptr->initiator == ptr->initiator) {
620 if (!found && ptr->host) {
621 /* Remove this connection */
622 SilcSocketConnection sock;
623 sock = silc_server_find_socket_by_host(server, SILC_SOCKET_TYPE_ROUTER,
624 ptr->host, ptr->port);
625 if (sock && !SILC_IS_LISTENER(sock))
626 silc_schedule_task_add(server->schedule, sock->sock,
627 silc_server_rehash_close_connection,
628 server, 0, 1, SILC_TASK_TIMEOUT,
629 SILC_TASK_PRI_NORMAL);
634 if (server->config->servers) {
635 SilcServerConfigServer *ptr;
636 SilcServerConfigServer *newptr;
639 for (ptr = server->config->servers; ptr; ptr = ptr->next) {
642 /* Check whether new config has this one too */
643 for (newptr = newconfig->servers; newptr; newptr = newptr->next) {
644 if (silc_string_compare(newptr->host, ptr->host)) {
650 if (!found && ptr->host) {
651 /* Remove this connection */
652 SilcSocketConnection sock;
653 sock = silc_server_find_socket_by_host(server, SILC_SOCKET_TYPE_SERVER,
655 if (sock && !SILC_IS_LISTENER(sock))
656 silc_schedule_task_add(server->schedule, sock->sock,
657 silc_server_rehash_close_connection,
658 server, 0, 1, SILC_TASK_TIMEOUT,
659 SILC_TASK_PRI_NORMAL);
664 if (server->config->clients) {
665 SilcServerConfigClient *ptr;
666 SilcServerConfigClient *newptr;
669 for (ptr = server->config->clients; ptr; ptr = ptr->next) {
672 /* Check whether new config has this one too */
673 for (newptr = newconfig->clients; newptr; newptr = newptr->next) {
674 if (silc_string_compare(newptr->host, ptr->host)) {
680 if (!found && ptr->host) {
681 /* Remove this connection */
682 SilcSocketConnection sock;
683 sock = silc_server_find_socket_by_host(server, SILC_SOCKET_TYPE_CLIENT,
686 silc_schedule_task_add(server->schedule, sock->sock,
687 silc_server_rehash_close_connection,
688 server, 0, 1, SILC_TASK_TIMEOUT,
689 SILC_TASK_PRI_NORMAL);
694 /* Create connections after rehash */
695 silc_server_create_connections(server);
697 /* Check whether our router status has changed */
698 if (newconfig->servers) {
699 SilcServerConfigServer *ptr = newconfig->servers;
701 server->server_type = SILC_ROUTER;
703 if (ptr->backup_router) {
704 server->server_type = SILC_BACKUP_ROUTER;
705 server->backup_router = TRUE;
706 server->id_entry->server_type = SILC_BACKUP_ROUTER;
713 /* Our old config is gone now. We'll unreference our reference made in
714 silc_server_init and then destroy it since we are destroying it
715 underneath the application (layer which called silc_server_init). */
716 silc_server_config_unref(&server->config_ref);
717 silc_server_config_destroy(server->config);
719 /* Take new config context */
720 server->config = newconfig;
721 silc_server_config_ref(&server->config_ref, server->config, server->config);
723 SILC_LOG_DEBUG(("Server rehashed"));
728 /* The heart of the server. This runs the scheduler thus runs the server.
729 When this returns the server has been stopped and the program will
732 void silc_server_run(SilcServer server)
734 SILC_LOG_INFO(("SILC Server started"));
736 /* Start the scheduler, the heart of the SILC server. When this returns
737 the program will be terminated. */
738 silc_schedule(server->schedule);
741 /* Stops the SILC server. This function is used to shutdown the server.
742 This is usually called after the scheduler has returned. After stopping
743 the server one should call silc_server_free. */
745 void silc_server_stop(SilcServer server)
747 SILC_LOG_INFO(("SILC Server shutting down"));
749 if (server->schedule) {
752 server->server_shutdown = TRUE;
754 /* Close all connections */
755 for (i = 0; i < server->config->param.connections_max; i++) {
756 if (!server->sockets[i])
758 if (!SILC_IS_LISTENER(server->sockets[i])) {
759 SilcSocketConnection sock = server->sockets[i];
760 SilcIDListData idata = sock->user_data;
763 idata->status &= ~SILC_IDLIST_STATUS_DISABLED;
765 silc_schedule_task_del_by_context(server->schedule,
767 silc_server_disconnect_remote(server, server->sockets[i],
769 "Server is shutting down");
771 silc_server_free_sock_user_data(server, sock,
772 "Server is shutting down");
773 silc_socket_free(sock);
775 silc_socket_free(server->sockets[i]);
776 server->sockets[i] = NULL;
780 /* We are not connected to network anymore */
781 server->standalone = TRUE;
783 silc_schedule_stop(server->schedule);
784 silc_schedule_uninit(server->schedule);
785 server->schedule = NULL;
787 silc_free(server->sockets);
788 server->sockets = NULL;
791 silc_server_protocols_unregister();
793 SILC_LOG_DEBUG(("Server stopped"));
796 /* Function that is called when the network connection to a router has
797 been established. This will continue with the key exchange protocol
798 with the remote router. */
800 void silc_server_start_key_exchange(SilcServer server,
801 SilcServerConnection sconn,
804 SilcSocketConnection newsocket;
805 SilcProtocol protocol;
806 SilcServerKEInternalContext *proto_ctx;
807 SilcServerConfigRouter *conn =
808 (SilcServerConfigRouter *) sconn->conn.ref_ptr;
811 /* Cancel any possible retry timeouts */
812 silc_schedule_task_del_by_callback(server->schedule,
813 silc_server_connect_to_router_retry);
815 /* Set socket options */
816 silc_net_set_socket_nonblock(sock);
817 silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
819 /* Create socket connection for the connection. Even though we
820 know that we are connecting to a router we will mark the socket
821 to be unknown connection until we have executed authentication
823 silc_socket_alloc(sock, SILC_SOCKET_TYPE_UNKNOWN, NULL, &newsocket);
824 server->sockets[sock] = newsocket;
825 newsocket->hostname = strdup(sconn->remote_host);
826 newsocket->ip = strdup(sconn->remote_host);
827 newsocket->port = sconn->remote_port;
828 sconn->sock = newsocket;
830 /* Allocate internal protocol context. This is sent as context
832 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
833 proto_ctx->server = (void *)server;
834 proto_ctx->context = (void *)sconn;
835 proto_ctx->sock = newsocket;
836 proto_ctx->rng = server->rng;
837 proto_ctx->responder = FALSE;
839 /* Set Key Exchange flags from configuration, but fall back to global
841 SILC_GET_SKE_FLAGS(conn, proto_ctx);
842 if (server->config->param.key_exchange_pfs)
843 proto_ctx->flags |= SILC_SKE_SP_FLAG_PFS;
845 /* Perform key exchange protocol. silc_server_connect_to_router_second
846 will be called after the protocol is finished. */
847 silc_protocol_alloc(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
848 &protocol, proto_ctx,
849 silc_server_connect_to_router_second);
850 newsocket->protocol = protocol;
852 /* Register a timeout task that will be executed if the protocol
853 is not executed within set limit. */
854 proto_ctx->timeout_task =
855 silc_schedule_task_add(server->schedule, sock,
856 silc_server_timeout_remote,
857 server, server->config->key_exchange_timeout, 0,
861 /* Register the connection for network input and output. This sets
862 that scheduler will listen for incoming packets for this connection
863 and sets that outgoing packets may be sent to this connection as
864 well. However, this doesn't set the scheduler for outgoing traffic,
865 it will be set separately by calling SILC_SET_CONNECTION_FOR_OUTPUT,
866 later when outgoing data is available. */
867 context = (void *)server;
868 SILC_REGISTER_CONNECTION_FOR_IO(sock);
870 /* Run the protocol */
871 silc_protocol_execute(protocol, server->schedule, 0, 0);
874 /* Timeout callback that will be called to retry connecting to remote
875 router. This is used by both normal and router server. This will wait
876 before retrying the connecting. The timeout is generated by exponential
877 backoff algorithm. */
879 SILC_TASK_CALLBACK(silc_server_connect_to_router_retry)
881 SilcServer server = app_context;
882 SilcServerConnection sconn = (SilcServerConnection)context;
883 SilcServerConfigRouter *conn = sconn->conn.ref_ptr;
884 SilcServerConfigConnParams *param =
885 (conn->param ? conn->param : &server->config->param);
887 /* Don't retry if we are shutting down. */
888 if (server->server_shutdown) {
889 silc_server_config_unref(&sconn->conn);
890 silc_free(sconn->remote_host);
891 silc_free(sconn->backup_replace_ip);
896 SILC_LOG_INFO(("Retrying connecting to a router"));
898 /* Calculate next timeout */
899 if (sconn->retry_count >= 1) {
900 sconn->retry_timeout = sconn->retry_timeout * SILC_SERVER_RETRY_MULTIPLIER;
901 if (sconn->retry_timeout > param->reconnect_interval_max)
902 sconn->retry_timeout = param->reconnect_interval_max;
904 sconn->retry_timeout = param->reconnect_interval;
906 sconn->retry_count++;
907 sconn->retry_timeout = sconn->retry_timeout +
908 silc_rng_get_rn32(server->rng) % SILC_SERVER_RETRY_RANDOMIZER;
910 /* If we've reached max retry count, give up. */
911 if ((sconn->retry_count > param->reconnect_count) &&
912 !param->reconnect_keep_trying) {
913 SILC_LOG_ERROR(("Could not connect to router, giving up"));
914 silc_server_config_unref(&sconn->conn);
915 silc_free(sconn->remote_host);
916 silc_free(sconn->backup_replace_ip);
921 SILC_LOG_DEBUG(("Retrying connecting to a router in %d seconds",
922 sconn->retry_timeout));
924 /* We will lookup a fresh pointer later */
925 silc_server_config_unref(&sconn->conn);
927 /* Wait one before retrying */
928 silc_schedule_task_add(server->schedule, 0, silc_server_connect_router,
929 context, sconn->retry_timeout, 0,
930 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
933 /* Generic routine to use connect to a router. */
935 SILC_TASK_CALLBACK(silc_server_connect_router)
937 SilcServer server = app_context;
938 SilcServerConnection sconn = (SilcServerConnection)context;
939 SilcServerConfigRouter *rconn;
942 /* Don't connect if we are shutting down. */
943 if (server->server_shutdown) {
944 silc_free(sconn->remote_host);
945 silc_free(sconn->backup_replace_ip);
950 SILC_LOG_INFO(("Connecting to the %s %s on port %d",
951 (sconn->backup ? "backup router" : "router"),
952 sconn->remote_host, sconn->remote_port));
954 server->router_connect = time(NULL);
955 rconn = silc_server_config_find_router_conn(server, sconn->remote_host,
958 SILC_LOG_INFO(("Unconfigured %s connection %s:%d, cannot connect",
959 (sconn->backup ? "backup router" : "router"),
960 sconn->remote_host, sconn->remote_port));
961 silc_free(sconn->remote_host);
962 silc_free(sconn->backup_replace_ip);
966 silc_server_config_ref(&sconn->conn, server->config, (void *)rconn);
968 /* Connect to remote host */
969 sock = silc_net_create_connection(
970 (!server->config->server_info->primary ? NULL :
971 server->config->server_info->primary->server_ip),
972 sconn->remote_port, sconn->remote_host);
974 SILC_LOG_ERROR(("Could not connect to router %s:%d",
975 sconn->remote_host, sconn->remote_port));
976 if (!sconn->no_reconnect)
977 silc_schedule_task_add(server->schedule, 0,
978 silc_server_connect_to_router_retry,
979 context, 0, 1, SILC_TASK_TIMEOUT,
980 SILC_TASK_PRI_NORMAL);
982 silc_server_config_unref(&sconn->conn);
983 silc_free(sconn->remote_host);
984 silc_free(sconn->backup_replace_ip);
990 /* Continue with key exchange protocol */
991 silc_server_start_key_exchange(server, sconn, sock);
994 /* This function connects to our primary router or if we are a router this
995 establishes all our primary routes. This is called at the start of the
996 server to do authentication and key exchange with our router - called
999 SILC_TASK_CALLBACK_GLOBAL(silc_server_connect_to_router)
1001 SilcServer server = (SilcServer)context;
1002 SilcServerConnection sconn;
1003 SilcServerConfigRouter *ptr;
1005 /* Don't connect if we are shutting down. */
1006 if (server->server_shutdown)
1009 SILC_LOG_DEBUG(("We are %s",
1010 (server->server_type == SILC_SERVER ?
1011 "normal server" : server->server_type == SILC_ROUTER ?
1012 "router" : "backup router/normal server")));
1014 if (!server->config->routers) {
1015 /* There wasn't a configured router, we will continue but we don't
1016 have a connection to outside world. We will be standalone server. */
1017 SILC_LOG_DEBUG(("No router(s), we are standalone"));
1018 server->standalone = TRUE;
1022 /* Cancel any possible retry timeouts */
1023 silc_schedule_task_del_by_callback(server->schedule,
1024 silc_server_connect_router);
1025 silc_schedule_task_del_by_callback(server->schedule,
1026 silc_server_connect_to_router_retry);
1028 /* Create the connections to all our routes */
1029 for (ptr = server->config->routers; ptr; ptr = ptr->next) {
1031 SILC_LOG_DEBUG(("%s connection [%s] %s:%d",
1032 ptr->backup_router ? "Backup router" : "Router",
1033 ptr->initiator ? "Initiator" : "Responder",
1034 ptr->host, ptr->port));
1036 if (server->server_type == SILC_ROUTER && ptr->backup_router &&
1037 ptr->initiator == FALSE && !server->backup_router &&
1038 !silc_server_config_get_backup_router(server))
1039 server->wait_backup = TRUE;
1041 if (ptr->initiator) {
1042 /* Check whether we are connecting or connected to this host already */
1043 if (silc_server_num_sockets_by_remote(server,
1044 silc_net_is_ip(ptr->host) ?
1046 silc_net_is_ip(ptr->host) ?
1047 NULL : ptr->host, ptr->port,
1048 SILC_SOCKET_TYPE_ROUTER)) {
1049 SILC_LOG_DEBUG(("We are already connected to this router"));
1052 if (silc_server_num_sockets_by_remote(server,
1053 silc_net_is_ip(ptr->host) ?
1055 silc_net_is_ip(ptr->host) ?
1056 NULL : ptr->host, ptr->port,
1057 SILC_SOCKET_TYPE_UNKNOWN)) {
1058 SILC_LOG_DEBUG(("We are already connecting to this router"));
1062 /* Allocate connection object for hold connection specific stuff. */
1063 sconn = silc_calloc(1, sizeof(*sconn));
1064 sconn->remote_host = strdup(ptr->host);
1065 sconn->remote_port = ptr->port;
1066 sconn->backup = ptr->backup_router;
1067 if (sconn->backup) {
1068 sconn->backup_replace_ip = strdup(ptr->backup_replace_ip);
1069 sconn->backup_replace_port = ptr->backup_replace_port;
1072 if (!server->router_conn && !sconn->backup)
1073 server->router_conn = sconn;
1075 silc_schedule_task_add(server->schedule, 0,
1076 silc_server_connect_router,
1077 (void *)sconn, 0, 1, SILC_TASK_TIMEOUT,
1078 SILC_TASK_PRI_NORMAL);
1083 /* Second part of connecting to router(s). Key exchange protocol has been
1084 executed and now we will execute authentication protocol. */
1086 SILC_TASK_CALLBACK(silc_server_connect_to_router_second)
1088 SilcProtocol protocol = (SilcProtocol)context;
1089 SilcServerKEInternalContext *ctx =
1090 (SilcServerKEInternalContext *)protocol->context;
1091 SilcServer server = (SilcServer)ctx->server;
1092 SilcServerConnection sconn = (SilcServerConnection)ctx->context;
1093 SilcSocketConnection sock = ctx->sock;
1094 SilcServerConnAuthInternalContext *proto_ctx;
1095 SilcServerConfigRouter *conn = NULL;
1097 SILC_LOG_DEBUG(("Start"));
1099 if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
1100 protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
1101 /* Error occured during protocol */
1102 silc_protocol_free(protocol);
1103 sock->protocol = NULL;
1104 silc_ske_free_key_material(ctx->keymat);
1106 silc_packet_context_free(ctx->packet);
1108 silc_ske_free(ctx->ske);
1109 silc_free(ctx->dest_id);
1111 silc_server_disconnect_remote(server, sock,
1112 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1114 /* Try reconnecting if configuration wants it */
1115 if (!sconn->no_reconnect) {
1116 silc_schedule_task_add(server->schedule, 0,
1117 silc_server_connect_to_router_retry,
1118 sconn, 0, 1, SILC_TASK_TIMEOUT,
1119 SILC_TASK_PRI_NORMAL);
1123 /* Call completion to indicate error */
1124 if (sconn->callback)
1125 (*sconn->callback)(server, NULL, sconn->callback_context);
1127 silc_server_config_unref(&sconn->conn);
1128 silc_free(sconn->remote_host);
1129 silc_free(sconn->backup_replace_ip);
1134 /* We now have the key material as the result of the key exchange
1135 protocol. Take the key material into use. Free the raw key material
1136 as soon as we've set them into use. */
1137 if (!silc_server_protocol_ke_set_keys(server, ctx->ske,
1138 ctx->sock, ctx->keymat,
1139 ctx->ske->prop->cipher,
1140 ctx->ske->prop->pkcs,
1141 ctx->ske->prop->hash,
1142 ctx->ske->prop->hmac,
1143 ctx->ske->prop->group,
1145 silc_protocol_free(protocol);
1146 sock->protocol = NULL;
1147 silc_ske_free_key_material(ctx->keymat);
1149 silc_packet_context_free(ctx->packet);
1151 silc_ske_free(ctx->ske);
1152 silc_free(ctx->dest_id);
1154 silc_server_disconnect_remote(server, sock,
1155 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1157 /* Try reconnecting if configuration wants it */
1158 if (!sconn->no_reconnect) {
1159 silc_schedule_task_add(server->schedule, 0,
1160 silc_server_connect_to_router_retry,
1161 sconn, 0, 1, SILC_TASK_TIMEOUT,
1162 SILC_TASK_PRI_NORMAL);
1166 /* Call completion to indicate error */
1167 if (sconn->callback)
1168 (*sconn->callback)(server, NULL, sconn->callback_context);
1170 silc_server_config_unref(&sconn->conn);
1171 silc_free(sconn->remote_host);
1172 silc_free(sconn->backup_replace_ip);
1176 silc_ske_free_key_material(ctx->keymat);
1178 /* Allocate internal context for the authentication protocol. This
1179 is sent as context for the protocol. */
1180 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
1181 proto_ctx->server = (void *)server;
1182 proto_ctx->context = (void *)sconn;
1183 proto_ctx->sock = sock;
1184 proto_ctx->ske = ctx->ske; /* Save SKE object from previous protocol */
1185 proto_ctx->dest_id_type = ctx->dest_id_type;
1186 proto_ctx->dest_id = ctx->dest_id;
1188 /* Resolve the authentication method used in this connection. Check if
1189 we find a match from user configured connections */
1190 if (!sconn->conn.ref_ptr)
1191 conn = silc_server_config_find_router_conn(server, sock->hostname,
1194 conn = sconn->conn.ref_ptr;
1197 /* Match found. Use the configured authentication method. Take only
1198 the passphrase, since for public key auth we automatically use
1199 our local key pair. */
1200 if (conn->passphrase) {
1201 if (conn->publickeys && !server->config->prefer_passphrase_auth) {
1202 proto_ctx->auth_meth = SILC_AUTH_PUBLIC_KEY;
1204 proto_ctx->auth_data = strdup(conn->passphrase);
1205 proto_ctx->auth_data_len = strlen(conn->passphrase);
1206 proto_ctx->auth_meth = SILC_AUTH_PASSWORD;
1208 } else if (conn->publickeys) {
1209 proto_ctx->auth_meth = SILC_AUTH_PUBLIC_KEY;
1211 proto_ctx->auth_meth = SILC_AUTH_NONE;
1214 SILC_LOG_ERROR(("Could not find connection data for %s (%s) on port",
1215 sock->hostname, sock->ip, sock->port));
1216 silc_protocol_free(protocol);
1217 sock->protocol = NULL;
1219 silc_packet_context_free(ctx->packet);
1221 silc_ske_free(ctx->ske);
1222 silc_free(ctx->dest_id);
1224 silc_server_config_unref(&sconn->conn);
1225 silc_free(sconn->remote_host);
1226 silc_free(sconn->backup_replace_ip);
1228 silc_server_disconnect_remote(server, sock,
1229 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1233 /* Free old protocol as it is finished now */
1234 silc_protocol_free(protocol);
1236 silc_packet_context_free(ctx->packet);
1238 sock->protocol = NULL;
1240 /* Allocate the authentication protocol. This is allocated here
1241 but we won't start it yet. We will be receiving party of this
1242 protocol thus we will wait that connecting party will make
1243 their first move. */
1244 silc_protocol_alloc(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1245 &sock->protocol, proto_ctx,
1246 silc_server_connect_to_router_final);
1248 /* Register timeout task. If the protocol is not executed inside
1249 this timelimit the connection will be terminated. */
1250 proto_ctx->timeout_task =
1251 silc_schedule_task_add(server->schedule, sock->sock,
1252 silc_server_timeout_remote,
1254 server->config->conn_auth_timeout, 0,
1258 /* Run the protocol */
1259 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
1262 /* Finalizes the connection to router. Registers a server task to the
1263 queue so that we can accept new connections. */
1265 SILC_TASK_CALLBACK(silc_server_connect_to_router_final)
1267 SilcProtocol protocol = (SilcProtocol)context;
1268 SilcServerConnAuthInternalContext *ctx =
1269 (SilcServerConnAuthInternalContext *)protocol->context;
1270 SilcServer server = (SilcServer)ctx->server;
1271 SilcServerConnection sconn = (SilcServerConnection)ctx->context;
1272 SilcSocketConnection sock = ctx->sock;
1273 SilcServerEntry id_entry = NULL;
1275 unsigned char *id_string;
1277 SilcIDListData idata;
1278 SilcServerConfigRouter *conn = NULL;
1279 SilcServerConfigConnParams *param = NULL;
1281 SILC_LOG_DEBUG(("Start"));
1283 if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
1284 protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
1285 /* Error occured during protocol */
1286 silc_free(ctx->dest_id);
1287 silc_server_disconnect_remote(server, sock, SILC_STATUS_ERR_AUTH_FAILED,
1290 /* Try reconnecting if configuration wants it */
1291 if (!sconn->no_reconnect) {
1292 silc_schedule_task_add(server->schedule, 0,
1293 silc_server_connect_to_router_retry,
1294 sconn, 0, 1, SILC_TASK_TIMEOUT,
1295 SILC_TASK_PRI_NORMAL);
1302 /* Add a task to the queue. This task receives new connections to the
1303 server. This task remains on the queue until the end of the program. */
1304 if (!server->listenning && !sconn->backup) {
1305 silc_schedule_task_add(server->schedule, server->sock,
1306 silc_server_accept_new_connection,
1307 (void *)server, 0, 0,
1309 SILC_TASK_PRI_NORMAL);
1310 server->listenning = TRUE;
1313 /* Send NEW_SERVER packet to the router. We will become registered
1314 to the SILC network after sending this packet. */
1315 id_string = silc_id_id2str(server->id, SILC_ID_SERVER);
1316 id_len = silc_id_get_len(server->id, SILC_ID_SERVER);
1317 packet = silc_buffer_alloc(2 + 2 + id_len + strlen(server->server_name));
1318 silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
1319 silc_buffer_format(packet,
1320 SILC_STR_UI_SHORT(id_len),
1321 SILC_STR_UI_XNSTRING(id_string, id_len),
1322 SILC_STR_UI_SHORT(strlen(server->server_name)),
1323 SILC_STR_UI_XNSTRING(server->server_name,
1324 strlen(server->server_name)),
1327 /* Send the packet */
1328 silc_server_packet_send(server, ctx->sock, SILC_PACKET_NEW_SERVER, 0,
1329 packet->data, packet->len, TRUE);
1330 silc_buffer_free(packet);
1331 silc_free(id_string);
1333 SILC_LOG_INFO(("Connected to router %s", sock->hostname));
1335 /* Check that we do not have this ID already */
1336 id_entry = silc_idlist_find_server_by_id(server->local_list,
1337 ctx->dest_id, TRUE, NULL);
1339 silc_idcache_del_by_context(server->local_list->servers, id_entry);
1341 id_entry = silc_idlist_find_server_by_id(server->global_list,
1342 ctx->dest_id, TRUE, NULL);
1344 silc_idcache_del_by_context(server->global_list->servers, id_entry);
1347 SILC_LOG_DEBUG(("New server id(%s)",
1348 silc_id_render(ctx->dest_id, SILC_ID_SERVER)));
1350 /* Add the connected router to global server list. Router is sent
1351 as NULL since it's local to us. */
1352 id_entry = silc_idlist_add_server(server->global_list,
1353 strdup(sock->hostname),
1354 SILC_ROUTER, ctx->dest_id, NULL, sock);
1356 silc_free(ctx->dest_id);
1357 SILC_LOG_ERROR(("Cannot add new server entry to cache"));
1358 silc_server_disconnect_remote(server, sock, SILC_STATUS_ERR_AUTH_FAILED,
1363 silc_idlist_add_data(id_entry, (SilcIDListData)sock->user_data);
1364 silc_free(sock->user_data);
1365 sock->user_data = (void *)id_entry;
1366 sock->type = SILC_SOCKET_TYPE_ROUTER;
1367 idata = (SilcIDListData)sock->user_data;
1368 idata->status |= (SILC_IDLIST_STATUS_REGISTERED |
1369 SILC_IDLIST_STATUS_LOCAL);
1371 conn = sconn->conn.ref_ptr;
1372 param = &server->config->param;
1373 if (conn && conn->param)
1374 param = conn->param;
1376 /* Perform keepalive. */
1377 silc_socket_set_heartbeat(sock, param->keepalive_secs, server,
1378 silc_server_perform_heartbeat,
1381 /* Register re-key timeout */
1382 idata->rekey->timeout = param->key_exchange_rekey;
1383 silc_schedule_task_add(server->schedule, sock->sock,
1384 silc_server_rekey_callback,
1385 (void *)sock, idata->rekey->timeout, 0,
1386 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1388 if (!sconn->backup) {
1389 /* Mark this router our primary router if we're still standalone */
1390 if (server->standalone) {
1391 SILC_LOG_DEBUG(("This connection is our primary router"));
1392 server->id_entry->router = id_entry;
1393 server->router = id_entry;
1394 server->standalone = FALSE;
1396 /* If we are router then announce our possible servers. Backup
1397 router announces also global servers. */
1398 if (server->server_type == SILC_ROUTER)
1399 silc_server_announce_servers(server,
1400 server->backup_router ? TRUE : FALSE,
1401 0, SILC_PRIMARY_ROUTE(server));
1403 /* Announce our clients and channels to the router */
1404 silc_server_announce_clients(server, 0, SILC_PRIMARY_ROUTE(server));
1405 silc_server_announce_channels(server, 0, SILC_PRIMARY_ROUTE(server));
1407 /* If we are backup router then this primary router is whom we are
1409 if (server->server_type == SILC_BACKUP_ROUTER)
1410 silc_server_backup_add(server, server->id_entry, sock->ip,
1411 sconn->remote_port, TRUE);
1414 /* Add this server to be our backup router */
1415 silc_server_backup_add(server, id_entry, sconn->backup_replace_ip,
1416 sconn->backup_replace_port, FALSE);
1419 sock->protocol = NULL;
1422 /* Call the completion callback to indicate that we've connected to
1424 if (sconn && sconn->callback)
1425 (*sconn->callback)(server, id_entry, sconn->callback_context);
1427 /* Free the temporary connection data context */
1429 silc_server_config_unref(&sconn->conn);
1430 silc_free(sconn->remote_host);
1431 silc_free(sconn->backup_replace_ip);
1434 if (sconn == server->router_conn)
1435 server->router_conn = NULL;
1438 /* Free the protocol object */
1439 if (sock->protocol == protocol)
1440 sock->protocol = NULL;
1441 silc_protocol_free(protocol);
1443 silc_packet_context_free(ctx->packet);
1445 silc_ske_free(ctx->ske);
1446 if (ctx->auth_meth == SILC_AUTH_PASSWORD)
1447 silc_free(ctx->auth_data);
1451 /* Host lookup callback that is called after the incoming connection's
1452 IP and FQDN lookup is performed. This will actually check the acceptance
1453 of the incoming connection and will register the key exchange protocol
1454 for this connection. */
1457 silc_server_accept_new_connection_lookup(SilcSocketConnection sock,
1460 SilcServerKEInternalContext *proto_ctx =
1461 (SilcServerKEInternalContext *)context;
1462 SilcServer server = (SilcServer)proto_ctx->server;
1463 SilcServerConfigClient *cconfig = NULL;
1464 SilcServerConfigServer *sconfig = NULL;
1465 SilcServerConfigRouter *rconfig = NULL;
1466 SilcServerConfigDeny *deny;
1469 /* Check whether we could resolve both IP and FQDN. */
1470 if (!sock->ip || (!strcmp(sock->ip, sock->hostname) &&
1471 server->config->require_reverse_lookup)) {
1472 SILC_LOG_ERROR(("IP/DNS lookup failed %s",
1473 sock->hostname ? sock->hostname :
1474 sock->ip ? sock->ip : ""));
1475 server->stat.conn_failures++;
1476 silc_server_disconnect_remote(server, sock,
1477 SILC_STATUS_ERR_INCOMPLETE_INFORMATION,
1478 "Unknown host or IP");
1479 silc_free(proto_ctx);
1483 /* Register the connection for network input and output. This sets
1484 that scheduler will listen for incoming packets for this connection
1485 and sets that outgoing packets may be sent to this connection as well.
1486 However, this doesn't set the scheduler for outgoing traffic, it
1487 will be set separately by calling SILC_SET_CONNECTION_FOR_OUTPUT,
1488 later when outgoing data is available. */
1489 context = (void *)server;
1490 SILC_REGISTER_CONNECTION_FOR_IO(sock->sock);
1492 SILC_LOG_INFO(("Incoming connection %s (%s)", sock->hostname,
1495 /* Listenning port */
1496 if (!server->sockets[(SilcUInt32)proto_ctx->context]) {
1497 silc_server_disconnect_remote(server, sock,
1498 SILC_STATUS_ERR_RESOURCE_LIMIT,
1499 "Connection refused");
1500 server->stat.conn_failures++;
1501 silc_free(proto_ctx);
1504 port = server->sockets[(SilcUInt32)proto_ctx->context]->port;
1506 /* Check whether this connection is denied to connect to us. */
1507 deny = silc_server_config_find_denied(server, sock->ip);
1509 deny = silc_server_config_find_denied(server, sock->hostname);
1511 /* The connection is denied */
1512 SILC_LOG_INFO(("Connection %s (%s) is denied",
1513 sock->hostname, sock->ip));
1514 silc_server_disconnect_remote(server, sock,
1515 SILC_STATUS_ERR_BANNED_FROM_SERVER,
1517 server->stat.conn_failures++;
1518 silc_free(proto_ctx);
1522 /* Check whether we have configured this sort of connection at all. We
1523 have to check all configurations since we don't know what type of
1524 connection this is. */
1525 if (!(cconfig = silc_server_config_find_client(server, sock->ip)))
1526 cconfig = silc_server_config_find_client(server, sock->hostname);
1527 if (!(sconfig = silc_server_config_find_server_conn(server, sock->ip)))
1528 sconfig = silc_server_config_find_server_conn(server, sock->hostname);
1529 if (server->server_type == SILC_ROUTER) {
1530 if (!(rconfig = silc_server_config_find_router_conn(server,
1531 sock->ip, sock->port)))
1532 rconfig = silc_server_config_find_router_conn(server, sock->hostname,
1535 if (!cconfig && !sconfig && !rconfig) {
1536 SILC_LOG_INFO(("Connection %s (%s) is not allowed", sock->hostname,
1538 silc_server_disconnect_remote(server, sock,
1539 SILC_STATUS_ERR_BANNED_FROM_SERVER, NULL);
1540 server->stat.conn_failures++;
1541 silc_free(proto_ctx);
1545 /* The connection is allowed */
1547 /* Set internal context for key exchange protocol. This is
1548 sent as context for the protocol. */
1549 proto_ctx->sock = sock;
1550 proto_ctx->rng = server->rng;
1551 proto_ctx->responder = TRUE;
1552 silc_server_config_ref(&proto_ctx->cconfig, server->config, cconfig);
1553 silc_server_config_ref(&proto_ctx->sconfig, server->config, sconfig);
1554 silc_server_config_ref(&proto_ctx->rconfig, server->config, rconfig);
1556 /* Take flags for key exchange. Since we do not know what type of connection
1557 this is, we go through all found configurations and use the global ones
1558 as well. This will result always into strictest key exchange flags. */
1559 SILC_GET_SKE_FLAGS(cconfig, proto_ctx);
1560 SILC_GET_SKE_FLAGS(sconfig, proto_ctx);
1561 SILC_GET_SKE_FLAGS(rconfig, proto_ctx);
1562 if (server->config->param.key_exchange_pfs)
1563 proto_ctx->flags |= SILC_SKE_SP_FLAG_PFS;
1565 /* Prepare the connection for key exchange protocol. We allocate the
1566 protocol but will not start it yet. The connector will be the
1567 initiator of the protocol thus we will wait for initiation from
1568 there before we start the protocol. */
1569 server->stat.auth_attempts++;
1570 SILC_LOG_DEBUG(("Starting key exchange protocol"));
1571 silc_protocol_alloc(SILC_PROTOCOL_SERVER_KEY_EXCHANGE,
1572 &sock->protocol, proto_ctx,
1573 silc_server_accept_new_connection_second);
1575 /* Register a timeout task that will be executed if the connector
1576 will not start the key exchange protocol within specified timeout
1577 and the connection will be closed. */
1578 proto_ctx->timeout_task =
1579 silc_schedule_task_add(server->schedule, sock->sock,
1580 silc_server_timeout_remote,
1582 server->config->key_exchange_timeout, 0,
1587 /* Accepts new connections to the server. Accepting new connections are
1588 done in three parts to make it async. */
1590 SILC_TASK_CALLBACK(silc_server_accept_new_connection)
1592 SilcServer server = (SilcServer)context;
1593 SilcSocketConnection newsocket;
1594 SilcServerKEInternalContext *proto_ctx;
1597 SILC_LOG_DEBUG(("Accepting new connection"));
1599 server->stat.conn_attempts++;
1601 sock = silc_net_accept_connection(fd);
1603 SILC_LOG_ERROR(("Could not accept new connection: %s", strerror(errno)));
1604 server->stat.conn_failures++;
1608 /* Check for maximum allowed connections */
1609 if (sock > server->config->param.connections_max) {
1610 SILC_LOG_ERROR(("Refusing connection, server is full"));
1611 server->stat.conn_failures++;
1612 silc_net_close_connection(sock);
1616 /* Set socket options */
1617 silc_net_set_socket_nonblock(sock);
1618 silc_net_set_socket_opt(sock, SOL_SOCKET, SO_REUSEADDR, 1);
1620 /* We don't create a ID yet, since we don't know what type of connection
1621 this is yet. But, we do add the connection to the socket table. */
1622 silc_socket_alloc(sock, SILC_SOCKET_TYPE_UNKNOWN, NULL, &newsocket);
1623 server->sockets[sock] = newsocket;
1625 /* Perform asynchronous host lookup. This will lookup the IP and the
1626 FQDN of the remote connection. After the lookup is done the connection
1627 is accepted further. */
1628 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
1629 proto_ctx->server = server;
1630 proto_ctx->context = (void *)fd;
1631 silc_socket_host_lookup(newsocket, TRUE,
1632 silc_server_accept_new_connection_lookup,
1633 (void *)proto_ctx, server->schedule);
1636 /* Second part of accepting new connection. Key exchange protocol has been
1637 performed and now it is time to do little connection authentication
1638 protocol to figure out whether this connection is client or server
1639 and whether it has right to access this server (especially server
1640 connections needs to be authenticated). */
1642 SILC_TASK_CALLBACK(silc_server_accept_new_connection_second)
1644 SilcProtocol protocol = (SilcProtocol)context;
1645 SilcServerKEInternalContext *ctx =
1646 (SilcServerKEInternalContext *)protocol->context;
1647 SilcServer server = (SilcServer)ctx->server;
1648 SilcSocketConnection sock = ctx->sock;
1649 SilcServerConnAuthInternalContext *proto_ctx;
1651 SILC_LOG_DEBUG(("Start"));
1653 if ((protocol->state == SILC_PROTOCOL_STATE_ERROR) ||
1654 (protocol->state == SILC_PROTOCOL_STATE_FAILURE)) {
1655 /* Error occured during protocol */
1656 SILC_LOG_DEBUG(("Error key exchange protocol"));
1657 silc_protocol_free(protocol);
1658 sock->protocol = NULL;
1659 silc_ske_free_key_material(ctx->keymat);
1661 silc_packet_context_free(ctx->packet);
1663 silc_ske_free(ctx->ske);
1664 silc_free(ctx->dest_id);
1665 silc_server_config_unref(&ctx->cconfig);
1666 silc_server_config_unref(&ctx->sconfig);
1667 silc_server_config_unref(&ctx->rconfig);
1669 silc_server_disconnect_remote(server, sock,
1670 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED,
1672 server->stat.auth_failures++;
1676 /* We now have the key material as the result of the key exchange
1677 protocol. Take the key material into use. Free the raw key material
1678 as soon as we've set them into use. */
1679 if (!silc_server_protocol_ke_set_keys(server, ctx->ske,
1680 ctx->sock, ctx->keymat,
1681 ctx->ske->prop->cipher,
1682 ctx->ske->prop->pkcs,
1683 ctx->ske->prop->hash,
1684 ctx->ske->prop->hmac,
1685 ctx->ske->prop->group,
1687 SILC_LOG_ERROR(("Error setting key material in use"));
1688 silc_protocol_free(protocol);
1689 sock->protocol = NULL;
1690 silc_ske_free_key_material(ctx->keymat);
1692 silc_packet_context_free(ctx->packet);
1694 silc_ske_free(ctx->ske);
1695 silc_free(ctx->dest_id);
1696 silc_server_config_unref(&ctx->cconfig);
1697 silc_server_config_unref(&ctx->sconfig);
1698 silc_server_config_unref(&ctx->rconfig);
1700 silc_server_disconnect_remote(server, sock,
1701 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED, NULL);
1702 server->stat.auth_failures++;
1705 silc_ske_free_key_material(ctx->keymat);
1707 /* Allocate internal context for the authentication protocol. This
1708 is sent as context for the protocol. */
1709 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
1710 proto_ctx->server = (void *)server;
1711 proto_ctx->sock = sock;
1712 proto_ctx->ske = ctx->ske; /* Save SKE object from previous protocol */
1713 proto_ctx->responder = TRUE;
1714 proto_ctx->dest_id_type = ctx->dest_id_type;
1715 proto_ctx->dest_id = ctx->dest_id;
1716 proto_ctx->cconfig = ctx->cconfig;
1717 proto_ctx->sconfig = ctx->sconfig;
1718 proto_ctx->rconfig = ctx->rconfig;
1720 /* Free old protocol as it is finished now */
1721 silc_protocol_free(protocol);
1723 silc_packet_context_free(ctx->packet);
1725 sock->protocol = NULL;
1727 /* Allocate the authentication protocol. This is allocated here
1728 but we won't start it yet. We will be receiving party of this
1729 protocol thus we will wait that connecting party will make
1730 their first move. */
1731 SILC_LOG_DEBUG(("Starting connection authentication protocol"));
1732 silc_protocol_alloc(SILC_PROTOCOL_SERVER_CONNECTION_AUTH,
1733 &sock->protocol, proto_ctx,
1734 silc_server_accept_new_connection_final);
1736 /* Register timeout task. If the protocol is not executed inside
1737 this timelimit the connection will be terminated. */
1738 proto_ctx->timeout_task =
1739 silc_schedule_task_add(server->schedule, sock->sock,
1740 silc_server_timeout_remote,
1742 server->config->conn_auth_timeout, 0,
1747 /* After this is called, server don't wait for backup router anymore.
1748 This gets called automatically even after we have backup router
1749 connection established. */
1751 SILC_TASK_CALLBACK(silc_server_backup_router_wait)
1753 SilcServer server = context;
1754 server->wait_backup = FALSE;
1757 /* Final part of accepting new connection. The connection has now
1758 been authenticated and keys has been exchanged. We also know whether
1759 this is client or server connection. */
1761 SILC_TASK_CALLBACK(silc_server_accept_new_connection_final)
1763 SilcProtocol protocol = (SilcProtocol)context;
1764 SilcServerConnAuthInternalContext *ctx =
1765 (SilcServerConnAuthInternalContext *)protocol->context;
1766 SilcServer server = (SilcServer)ctx->server;
1767 SilcSocketConnection sock = ctx->sock;
1768 SilcUnknownEntry entry = (SilcUnknownEntry)sock->user_data;
1770 SilcServerConfigConnParams *param = &server->config->param;
1772 if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
1773 protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
1774 /* Error occured during protocol */
1775 SILC_LOG_DEBUG(("Error during authentication protocol"));
1776 silc_protocol_free(protocol);
1777 sock->protocol = NULL;
1779 silc_packet_context_free(ctx->packet);
1781 silc_ske_free(ctx->ske);
1782 silc_free(ctx->dest_id);
1783 silc_server_config_unref(&ctx->cconfig);
1784 silc_server_config_unref(&ctx->sconfig);
1785 silc_server_config_unref(&ctx->rconfig);
1787 silc_server_disconnect_remote(server, sock, SILC_STATUS_ERR_AUTH_FAILED,
1789 server->stat.auth_failures++;
1793 entry->data.last_receive = time(NULL);
1795 switch (ctx->conn_type) {
1796 case SILC_SOCKET_TYPE_CLIENT:
1798 SilcClientEntry client;
1799 SilcServerConfigClient *conn = ctx->cconfig.ref_ptr;
1801 /* Verify whether this connection is after all allowed to connect */
1802 if (!silc_server_connection_allowed(server, sock, ctx->conn_type,
1803 &server->config->param,
1804 conn->param, ctx->ske)) {
1805 server->stat.auth_failures++;
1809 /* If we are primary router and we have backup router configured
1810 but it has not connected to use yet, do not accept any other
1812 if (server->wait_backup && server->server_type == SILC_ROUTER &&
1813 !server->backup_router) {
1814 SilcServerConfigRouter *router;
1815 router = silc_server_config_get_backup_router(server);
1816 if (router && strcmp(server->config->server_info->primary->server_ip,
1818 silc_server_find_socket_by_host(server,
1819 SILC_SOCKET_TYPE_SERVER,
1820 router->backup_replace_ip, 0)) {
1821 SILC_LOG_INFO(("Will not accept connections because we do "
1822 "not have backup router connection established"));
1823 silc_server_disconnect_remote(server, sock,
1824 SILC_STATUS_ERR_PERM_DENIED,
1825 "We do not have connection to backup "
1826 "router established, try later");
1827 silc_free(sock->user_data);
1828 server->stat.auth_failures++;
1830 /* From here on, wait 10 seconds for the backup router to appear. */
1831 silc_schedule_task_add(server->schedule, 0,
1832 silc_server_backup_router_wait,
1833 (void *)server, 10, 0,
1834 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
1839 SILC_LOG_DEBUG(("Remote host is client"));
1840 SILC_LOG_INFO(("Connection %s (%s) is client", sock->hostname,
1843 /* Add the client to the client ID cache. The nickname and Client ID
1844 and other information is created after we have received NEW_CLIENT
1845 packet from client. */
1846 client = silc_idlist_add_client(server->local_list,
1847 NULL, NULL, NULL, NULL, NULL, sock, 0);
1849 SILC_LOG_ERROR(("Could not add new client to cache"));
1850 silc_free(sock->user_data);
1851 silc_server_disconnect_remote(server, sock,
1852 SILC_STATUS_ERR_AUTH_FAILED, NULL);
1853 server->stat.auth_failures++;
1856 entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
1859 server->stat.my_clients++;
1860 server->stat.clients++;
1861 server->stat.cell_clients++;
1863 /* Get connection parameters */
1865 param = conn->param;
1867 if (!param->keepalive_secs)
1868 param->keepalive_secs = server->config->param.keepalive_secs;
1870 if (!param->qos && server->config->param.qos) {
1871 param->qos = server->config->param.qos;
1872 param->qos_rate_limit = server->config->param.qos_rate_limit;
1873 param->qos_bytes_limit = server->config->param.qos_bytes_limit;
1874 param->qos_limit_sec = server->config->param.qos_limit_sec;
1875 param->qos_limit_usec = server->config->param.qos_limit_usec;
1878 /* Check if to be anonymous connection */
1879 if (param->anonymous)
1880 client->mode |= SILC_UMODE_ANONYMOUS;
1883 id_entry = (void *)client;
1886 case SILC_SOCKET_TYPE_SERVER:
1887 case SILC_SOCKET_TYPE_ROUTER:
1889 SilcServerEntry new_server;
1890 bool initiator = FALSE;
1891 bool backup_local = FALSE;
1892 bool backup_router = FALSE;
1893 char *backup_replace_ip = NULL;
1894 SilcUInt16 backup_replace_port = 0;
1895 SilcServerConfigServer *sconn = ctx->sconfig.ref_ptr;
1896 SilcServerConfigRouter *rconn = ctx->rconfig.ref_ptr;
1898 /* If we are backup router and this is incoming server connection
1899 and we do not have connection to primary router, do not allow
1901 if (server->server_type == SILC_BACKUP_ROUTER &&
1902 ctx->conn_type == SILC_SOCKET_TYPE_SERVER &&
1903 !SILC_PRIMARY_ROUTE(server)) {
1904 SILC_LOG_INFO(("Will not accept server connection because we do "
1905 "not have primary router connection established"));
1906 silc_server_disconnect_remote(server, sock,
1907 SILC_STATUS_ERR_PERM_DENIED,
1908 "We do not have connection to primary "
1909 "router established, try later");
1910 silc_free(sock->user_data);
1911 server->stat.auth_failures++;
1915 if (ctx->conn_type == SILC_SOCKET_TYPE_ROUTER) {
1916 /* Verify whether this connection is after all allowed to connect */
1917 if (!silc_server_connection_allowed(server, sock, ctx->conn_type,
1918 &server->config->param,
1919 rconn ? rconn->param : NULL,
1921 silc_free(sock->user_data);
1922 server->stat.auth_failures++;
1928 param = rconn->param;
1930 if (!param->keepalive_secs)
1931 param->keepalive_secs = server->config->param.keepalive_secs;
1933 if (!param->qos && server->config->param.qos) {
1934 param->qos = server->config->param.qos;
1935 param->qos_rate_limit = server->config->param.qos_rate_limit;
1936 param->qos_bytes_limit = server->config->param.qos_bytes_limit;
1937 param->qos_limit_sec = server->config->param.qos_limit_sec;
1938 param->qos_limit_usec = server->config->param.qos_limit_usec;
1942 initiator = rconn->initiator;
1943 backup_local = rconn->backup_local;
1944 backup_router = rconn->backup_router;
1945 backup_replace_ip = rconn->backup_replace_ip;
1946 backup_replace_port = rconn->backup_replace_port;
1950 if (ctx->conn_type == SILC_SOCKET_TYPE_SERVER) {
1951 /* Verify whether this connection is after all allowed to connect */
1952 if (!silc_server_connection_allowed(server, sock, ctx->conn_type,
1953 &server->config->param,
1954 sconn ? sconn->param : NULL,
1956 silc_free(sock->user_data);
1957 server->stat.auth_failures++;
1962 param = sconn->param;
1964 if (!param->keepalive_secs)
1965 param->keepalive_secs = server->config->param.keepalive_secs;
1967 if (!param->qos && server->config->param.qos) {
1968 param->qos = server->config->param.qos;
1969 param->qos_rate_limit = server->config->param.qos_rate_limit;
1970 param->qos_bytes_limit = server->config->param.qos_bytes_limit;
1971 param->qos_limit_sec = server->config->param.qos_limit_sec;
1972 param->qos_limit_usec = server->config->param.qos_limit_usec;
1976 backup_router = sconn->backup_router;
1980 /* If we are primary router and we have backup router configured
1981 but it has not connected to use yet, do not accept any other
1983 if (server->wait_backup && server->server_type == SILC_ROUTER &&
1984 !server->backup_router && !backup_router) {
1985 SilcServerConfigRouter *router;
1986 router = silc_server_config_get_backup_router(server);
1987 if (router && strcmp(server->config->server_info->primary->server_ip,
1989 silc_server_find_socket_by_host(server,
1990 SILC_SOCKET_TYPE_SERVER,
1991 router->backup_replace_ip, 0)) {
1992 SILC_LOG_INFO(("Will not accept connections because we do "
1993 "not have backup router connection established"));
1994 silc_server_disconnect_remote(server, sock,
1995 SILC_STATUS_ERR_PERM_DENIED,
1996 "We do not have connection to backup "
1997 "router established, try later");
1998 silc_free(sock->user_data);
1999 server->stat.auth_failures++;
2001 /* From here on, wait 10 seconds for the backup router to appear. */
2002 silc_schedule_task_add(server->schedule, 0,
2003 silc_server_backup_router_wait,
2004 (void *)server, 10, 0,
2005 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
2010 SILC_LOG_DEBUG(("Remote host is %s",
2011 ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
2012 "server" : (backup_router ?
2013 "backup router" : "router")));
2014 SILC_LOG_INFO(("Connection %s (%s) is %s", sock->hostname,
2015 sock->ip, ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
2016 "server" : (backup_router ?
2017 "backup router" : "router")));
2019 /* Add the server into server cache. The server name and Server ID
2020 is updated after we have received NEW_SERVER packet from the
2021 server. We mark ourselves as router for this server if we really
2024 silc_idlist_add_server((ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
2025 server->local_list : (backup_router ?
2026 server->local_list :
2027 server->global_list)),
2029 (ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
2030 SILC_SERVER : SILC_ROUTER),
2032 (ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
2033 server->id_entry : (backup_router ?
2034 server->id_entry : NULL)),
2037 SILC_LOG_ERROR(("Could not add new server to cache"));
2038 silc_free(sock->user_data);
2039 silc_server_disconnect_remote(server, sock,
2040 SILC_STATUS_ERR_AUTH_FAILED, NULL);
2041 server->stat.auth_failures++;
2044 entry->data.status |= SILC_IDLIST_STATUS_LOCAL;
2046 id_entry = (void *)new_server;
2048 /* If the incoming connection is router and marked as backup router
2049 then add it to be one of our backups */
2050 if (ctx->conn_type == SILC_SOCKET_TYPE_ROUTER && backup_router) {
2051 /* Change it back to SERVER type since that's what it really is. */
2053 ctx->conn_type = SILC_SOCKET_TYPE_SERVER;
2054 new_server->server_type = SILC_BACKUP_ROUTER;
2056 SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
2057 ("Backup router %s is now online",
2060 /* Remove the backup waiting with timeout */
2061 silc_schedule_task_add(server->schedule, 0,
2062 silc_server_backup_router_wait,
2063 (void *)server, 5, 0,
2064 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
2068 if (ctx->conn_type == SILC_SOCKET_TYPE_SERVER) {
2069 server->stat.my_servers++;
2071 server->stat.my_routers++;
2072 server->stat.routers++;
2074 server->stat.servers++;
2076 /* Check whether this connection is to be our primary router connection
2077 if we do not already have the primary route. */
2078 if (!backup_router &&
2079 server->standalone && ctx->conn_type == SILC_SOCKET_TYPE_ROUTER) {
2080 if (silc_server_config_is_primary_route(server) && !initiator)
2083 SILC_LOG_DEBUG(("We are not standalone server anymore"));
2084 server->standalone = FALSE;
2085 if (!server->id_entry->router) {
2086 server->id_entry->router = id_entry;
2087 server->router = id_entry;
2098 sock->type = ctx->conn_type;
2100 /* Add the common data structure to the ID entry. */
2101 silc_idlist_add_data(id_entry, (SilcIDListData)sock->user_data);
2103 /* Add to sockets internal pointer for fast referencing */
2104 silc_free(sock->user_data);
2105 sock->user_data = id_entry;
2107 /* Connection has been fully established now. Everything is ok. */
2108 SILC_LOG_DEBUG(("New connection authenticated"));
2110 /* Perform keepalive. */
2111 if (param->keepalive_secs)
2112 silc_socket_set_heartbeat(sock, param->keepalive_secs, server,
2113 silc_server_perform_heartbeat,
2116 /* Perform Quality of Service */
2118 silc_socket_set_qos(sock, param->qos_rate_limit, param->qos_bytes_limit,
2119 param->qos_limit_sec, param->qos_limit_usec,
2123 silc_protocol_free(protocol);
2125 silc_packet_context_free(ctx->packet);
2127 silc_ske_free(ctx->ske);
2128 silc_free(ctx->dest_id);
2129 silc_server_config_unref(&ctx->cconfig);
2130 silc_server_config_unref(&ctx->sconfig);
2131 silc_server_config_unref(&ctx->rconfig);
2133 sock->protocol = NULL;
2136 /* This function is used to read packets from network and send packets to
2137 network. This is usually a generic task. */
2139 SILC_TASK_CALLBACK(silc_server_packet_process)
2141 SilcServer server = (SilcServer)context;
2142 SilcSocketConnection sock = server->sockets[fd];
2143 SilcIDListData idata;
2144 SilcCipher cipher = NULL;
2145 SilcHmac hmac = NULL;
2146 SilcUInt32 sequence = 0;
2147 bool local_is_router;
2151 SILC_LOG_DEBUG(("Unknown socket connection"));
2155 /* Packet sending */
2157 if (type == SILC_TASK_WRITE) {
2158 /* Do not send data to disconnected connection */
2159 if (SILC_IS_DISCONNECTED(sock)) {
2160 SILC_LOG_DEBUG(("Disconnected socket connection, cannot send"));
2164 server->stat.packets_sent++;
2166 /* Send the packet */
2167 ret = silc_packet_send(sock, TRUE);
2169 /* If returned -2 could not write to connection now, will do
2174 /* The packet has been sent and now it is time to set the connection
2175 back to only for input. When there is again some outgoing data
2176 available for this connection it will be set for output as well.
2177 This call clears the output setting and sets it only for input. */
2178 SILC_SET_CONNECTION_FOR_INPUT(server->schedule, fd);
2179 SILC_UNSET_OUTBUF_PENDING(sock);
2180 silc_buffer_clear(sock->outbuf);
2183 SILC_LOG_ERROR(("Error sending packet to connection "
2184 "%s:%d [%s]", sock->hostname, sock->port,
2185 (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
2186 sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
2187 sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
2190 SILC_SET_DISCONNECTING(sock);
2191 if (sock->user_data)
2192 silc_server_free_sock_user_data(server, sock, NULL);
2193 silc_server_close_connection(server, sock);
2198 /* Packet receiving */
2200 /* Read some data from connection */
2201 ret = silc_packet_receive(sock);
2205 SILC_LOG_ERROR(("Error receiving packet from connection "
2206 "%s:%d [%s] %s", sock->hostname, sock->port,
2207 (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
2208 sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
2209 sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
2210 "Router"), strerror(errno)));
2212 SILC_SET_DISCONNECTING(sock);
2213 if (sock->user_data)
2214 silc_server_free_sock_user_data(server, sock, NULL);
2215 silc_server_close_connection(server, sock);
2222 SILC_LOG_DEBUG(("Read EOF"));
2224 /* If connection is disconnecting already we will finally
2225 close the connection */
2226 if (SILC_IS_DISCONNECTING(sock)) {
2227 if (sock->user_data)
2228 silc_server_free_sock_user_data(server, sock, NULL);
2229 silc_server_close_connection(server, sock);
2233 SILC_LOG_DEBUG(("Premature EOF from connection %d", sock->sock));
2234 SILC_SET_DISCONNECTING(sock);
2236 if (sock->user_data) {
2238 if (silc_socket_get_error(sock, tmp, sizeof(tmp) - 1))
2239 silc_server_free_sock_user_data(server, sock, tmp);
2241 silc_server_free_sock_user_data(server, sock, NULL);
2242 } else if (server->router_conn && server->router_conn->sock == sock &&
2243 !server->router && server->standalone) {
2244 silc_server_create_connections(server);
2247 silc_server_close_connection(server, sock);
2251 /* If connection is disconnecting or disconnected we will ignore
2253 if (SILC_IS_DISCONNECTING(sock) || SILC_IS_DISCONNECTED(sock)) {
2254 SILC_LOG_DEBUG(("Ignoring read data from disconnected connection"));
2258 /* Get keys and stuff from ID entry */
2259 idata = (SilcIDListData)sock->user_data;
2261 cipher = idata->receive_key;
2262 hmac = idata->hmac_receive;
2263 sequence = idata->psn_receive;
2266 /* Then, process the packet. This will call the parser that will then
2267 decrypt and parse the packet. */
2269 local_is_router = (server->server_type == SILC_ROUTER);
2271 /* If socket connection is our primary, we are backup and we are doing
2272 backup resuming, we won't process the packet as being a router
2273 (affects channel message decryption). */
2274 if (server->backup_router && SILC_SERVER_IS_BACKUP(sock) &&
2275 SILC_PRIMARY_ROUTE(server) == sock)
2276 local_is_router = FALSE;
2278 ret = silc_packet_receive_process(sock, local_is_router,
2279 cipher, hmac, sequence,
2280 silc_server_packet_parse, server);
2282 /* If processing failed the connection is closed. */
2284 /* On packet processing errors we may close our primary router
2285 connection but won't become primary router if we are the backup
2286 since this is local error condition. */
2287 if (SILC_PRIMARY_ROUTE(server) == sock && server->backup_router)
2288 server->backup_noswitch = TRUE;
2290 SILC_SET_DISCONNECTING(sock);
2291 if (sock->user_data)
2292 silc_server_free_sock_user_data(server, sock, NULL);
2293 silc_server_close_connection(server, sock);
2297 /* Parses whole packet, received earlier. */
2299 SILC_TASK_CALLBACK(silc_server_packet_parse_real)
2301 SilcPacketParserContext *parse_ctx = (SilcPacketParserContext *)context;
2302 SilcServer server = (SilcServer)parse_ctx->context;
2303 SilcSocketConnection sock = parse_ctx->sock;
2304 SilcPacketContext *packet = parse_ctx->packet;
2305 SilcIDListData idata = (SilcIDListData)sock->user_data;
2308 server->stat.packets_received++;
2310 /* Parse the packet */
2311 if (parse_ctx->normal)
2312 ret = silc_packet_parse(packet, idata ? idata->receive_key : NULL);
2314 ret = silc_packet_parse_special(packet, idata ? idata->receive_key : NULL);
2316 /* If entry is disabled ignore what we got. */
2317 if (idata && idata->status & SILC_IDLIST_STATUS_DISABLED &&
2318 ret != SILC_PACKET_HEARTBEAT && ret != SILC_PACKET_RESUME_ROUTER &&
2319 ret != SILC_PACKET_REKEY && ret != SILC_PACKET_REKEY_DONE) {
2320 SILC_LOG_DEBUG(("Connection is disabled"));
2324 if (ret == SILC_PACKET_NONE) {
2325 SILC_LOG_DEBUG(("Error parsing packet"));
2329 /* Check that the the current client ID is same as in the client's packet. */
2330 if (sock->type == SILC_SOCKET_TYPE_CLIENT) {
2331 SilcClientEntry client = (SilcClientEntry)sock->user_data;
2332 if (client && client->id && packet->src_id) {
2333 void *id = silc_id_str2id(packet->src_id, packet->src_id_len,
2334 packet->src_id_type);
2335 if (!id || !SILC_ID_CLIENT_COMPARE(client->id, id)) {
2337 SILC_LOG_DEBUG(("Packet source is not same as sender"));
2344 if (server->server_type == SILC_ROUTER) {
2345 /* Route the packet if it is not destined to us. Other ID types but
2346 server are handled separately after processing them. */
2347 if (packet->dst_id && !(packet->flags & SILC_PACKET_FLAG_BROADCAST) &&
2348 packet->dst_id_type == SILC_ID_SERVER &&
2349 sock->type != SILC_SOCKET_TYPE_CLIENT &&
2350 memcmp(packet->dst_id, server->id_string, server->id_string_len)) {
2352 /* Route the packet to fastest route for the destination ID */
2353 void *id = silc_id_str2id(packet->dst_id, packet->dst_id_len,
2354 packet->dst_id_type);
2357 silc_server_packet_route(server,
2358 silc_server_route_get(server, id,
2359 packet->dst_id_type),
2366 /* Parse the incoming packet type */
2367 silc_server_packet_parse_type(server, sock, packet);
2369 /* Broadcast packet if it is marked as broadcast packet and it is
2370 originated from router and we are router. */
2371 if (server->server_type == SILC_ROUTER &&
2372 sock->type == SILC_SOCKET_TYPE_ROUTER &&
2373 packet->flags & SILC_PACKET_FLAG_BROADCAST) {
2374 /* Broadcast to our primary route */
2375 silc_server_packet_broadcast(server, SILC_PRIMARY_ROUTE(server), packet);
2377 /* If we have backup routers then we need to feed all broadcast
2378 data to those servers. */
2379 silc_server_backup_broadcast(server, sock, packet);
2383 silc_packet_context_free(packet);
2384 silc_free(parse_ctx);
2387 /* Parser callback called by silc_packet_receive_process. This merely
2388 registers timeout that will handle the actual parsing when appropriate. */
2390 bool silc_server_packet_parse(SilcPacketParserContext *parser_context,
2393 SilcServer server = (SilcServer)context;
2394 SilcSocketConnection sock = parser_context->sock;
2395 SilcIDListData idata = (SilcIDListData)sock->user_data;
2399 idata->psn_receive = parser_context->packet->sequence + 1;
2401 /* If protocol for this connection is key exchange or rekey then we'll
2402 process all packets synchronously, since there might be packets in
2403 queue that we are not able to decrypt without first processing the
2404 packets before them. */
2405 if ((parser_context->packet->type == SILC_PACKET_REKEY ||
2406 parser_context->packet->type == SILC_PACKET_REKEY_DONE) ||
2407 (sock->protocol && sock->protocol->protocol &&
2408 (sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_KEY_EXCHANGE ||
2409 sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY))) {
2410 silc_server_packet_parse_real(server->schedule, server, 0, sock->sock,
2413 /* Reprocess data since we'll return FALSE here. This is because
2414 the idata->receive_key might have become valid in the last packet
2415 and we want to call this processor with valid cipher. */
2417 ret = silc_packet_receive_process(
2418 sock, server->server_type == SILC_ROUTER,
2420 idata->hmac_receive, idata->psn_receive,
2421 silc_server_packet_parse, server);
2423 ret = silc_packet_receive_process(
2424 sock, server->server_type == SILC_ROUTER,
2426 silc_server_packet_parse, server);
2429 /* On packet processing errors we may close our primary router
2430 connection but won't become primary router if we are the backup
2431 since this is local error condition. */
2432 if (SILC_PRIMARY_ROUTE(server) == sock && server->backup_router)
2433 server->backup_noswitch = TRUE;
2435 SILC_SET_DISCONNECTING(sock);
2436 if (sock->user_data)
2437 silc_server_free_sock_user_data(server, sock, NULL);
2438 silc_server_close_connection(server, sock);
2444 switch (sock->type) {
2445 case SILC_SOCKET_TYPE_UNKNOWN:
2446 case SILC_SOCKET_TYPE_CLIENT:
2447 /* Parse the packet with timeout */
2448 silc_schedule_task_add(server->schedule, sock->sock,
2449 silc_server_packet_parse_real,
2450 (void *)parser_context, 0, 100000,
2452 SILC_TASK_PRI_NORMAL);
2454 case SILC_SOCKET_TYPE_SERVER:
2455 case SILC_SOCKET_TYPE_ROUTER:
2456 /* Packets from servers are parsed immediately */
2457 silc_server_packet_parse_real(server->schedule, server, 0, sock->sock,
2467 /* Parses the packet type and calls what ever routines the packet type
2468 requires. This is done for all incoming packets. */
2470 void silc_server_packet_parse_type(SilcServer server,
2471 SilcSocketConnection sock,
2472 SilcPacketContext *packet)
2474 SilcPacketType type = packet->type;
2475 SilcIDListData idata = (SilcIDListData)sock->user_data;
2477 SILC_LOG_DEBUG(("Received %s packet [flags %d]",
2478 silc_get_packet_name(type), packet->flags));
2480 /* Parse the packet type */
2482 case SILC_PACKET_DISCONNECT:
2485 char *message = NULL;
2487 if (packet->flags & SILC_PACKET_FLAG_LIST)
2489 if (packet->buffer->len < 1)
2492 status = (SilcStatus)packet->buffer->data[0];
2493 if (packet->buffer->len > 1 &&
2494 silc_utf8_valid(packet->buffer->data + 1, packet->buffer->len - 1))
2495 message = silc_memdup(packet->buffer->data + 1,
2496 packet->buffer->len - 1);
2498 SILC_LOG_INFO(("Disconnected by %s (%s): %s (%d) %s",
2499 sock->ip, sock->hostname,
2500 silc_get_status_message(status), status,
2501 message ? message : ""));
2504 /* Do not switch to backup in case of error */
2505 server->backup_noswitch = (status == SILC_STATUS_OK ? FALSE : TRUE);
2507 /* Handle the disconnection from our end too */
2508 SILC_SET_DISCONNECTING(sock);
2509 if (sock->user_data && SILC_IS_LOCAL(sock->user_data))
2510 silc_server_free_sock_user_data(server, sock, NULL);
2511 silc_server_close_connection(server, sock);
2512 server->backup_noswitch = FALSE;
2516 case SILC_PACKET_SUCCESS:
2518 * Success received for something. For now we can have only
2519 * one protocol for connection executing at once hence this
2520 * success message is for whatever protocol is executing currently.
2522 if (packet->flags & SILC_PACKET_FLAG_LIST)
2525 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2528 case SILC_PACKET_FAILURE:
2530 * Failure received for something. For now we can have only
2531 * one protocol for connection executing at once hence this
2532 * failure message is for whatever protocol is executing currently.
2534 if (packet->flags & SILC_PACKET_FLAG_LIST)
2536 if (sock->protocol) {
2537 sock->protocol->state = SILC_PROTOCOL_STATE_FAILURE;
2538 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2542 case SILC_PACKET_REJECT:
2543 if (packet->flags & SILC_PACKET_FLAG_LIST)
2548 case SILC_PACKET_NOTIFY:
2550 * Received notify packet. Server can receive notify packets from
2551 * router. Server then relays the notify messages to clients if needed.
2553 if (packet->flags & SILC_PACKET_FLAG_LIST)
2554 silc_server_notify_list(server, sock, packet);
2556 silc_server_notify(server, sock, packet);
2562 case SILC_PACKET_CHANNEL_MESSAGE:
2564 * Received channel message. Channel messages are special packets
2565 * (although probably most common ones) thus they are handled
2568 if (packet->flags & SILC_PACKET_FLAG_LIST)
2570 idata->last_receive = time(NULL);
2571 silc_server_channel_message(server, sock, packet);
2574 case SILC_PACKET_CHANNEL_KEY:
2576 * Received key for channel. As channels are created by the router
2577 * the keys are as well. We will distribute the key to all of our
2578 * locally connected clients on the particular channel. Router
2579 * never receives this channel and thus is ignored.
2581 if (packet->flags & SILC_PACKET_FLAG_LIST)
2583 silc_server_channel_key(server, sock, packet);
2589 case SILC_PACKET_COMMAND:
2591 * Recived command. Processes the command request and allocates the
2592 * command context and calls the command.
2594 if (packet->flags & SILC_PACKET_FLAG_LIST)
2596 silc_server_command_process(server, sock, packet);
2599 case SILC_PACKET_COMMAND_REPLY:
2601 * Received command reply packet. Received command reply to command. It
2602 * may be reply to command sent by us or reply to command sent by client
2603 * that we've routed further.
2605 if (packet->flags & SILC_PACKET_FLAG_LIST)
2607 silc_server_command_reply(server, sock, packet);
2611 * Private Message packets
2613 case SILC_PACKET_PRIVATE_MESSAGE:
2615 * Received private message packet. The packet is coming from either
2618 if (packet->flags & SILC_PACKET_FLAG_LIST)
2620 idata->last_receive = time(NULL);
2621 silc_server_private_message(server, sock, packet);
2624 case SILC_PACKET_PRIVATE_MESSAGE_KEY:
2626 * Private message key packet.
2628 if (packet->flags & SILC_PACKET_FLAG_LIST)
2630 silc_server_private_message_key(server, sock, packet);
2634 * Key Exchange protocol packets
2636 case SILC_PACKET_KEY_EXCHANGE:
2637 if (packet->flags & SILC_PACKET_FLAG_LIST)
2640 if (sock->protocol && sock->protocol->protocol &&
2641 sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_KEY_EXCHANGE) {
2642 SilcServerKEInternalContext *proto_ctx =
2643 (SilcServerKEInternalContext *)sock->protocol->context;
2645 proto_ctx->packet = silc_packet_context_dup(packet);
2647 /* Let the protocol handle the packet */
2648 silc_protocol_execute(sock->protocol, server->schedule, 0, 100000);
2650 SILC_LOG_ERROR(("Received Key Exchange packet but no key exchange "
2651 "protocol active, packet dropped."));
2655 case SILC_PACKET_KEY_EXCHANGE_1:
2656 if (packet->flags & SILC_PACKET_FLAG_LIST)
2659 if (sock->protocol && sock->protocol->protocol &&
2660 (sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_KEY_EXCHANGE ||
2661 sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY)) {
2663 if (sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY) {
2664 SilcServerRekeyInternalContext *proto_ctx =
2665 (SilcServerRekeyInternalContext *)sock->protocol->context;
2667 if (proto_ctx->packet)
2668 silc_packet_context_free(proto_ctx->packet);
2670 proto_ctx->packet = silc_packet_context_dup(packet);
2672 /* Let the protocol handle the packet */
2673 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2675 SilcServerKEInternalContext *proto_ctx =
2676 (SilcServerKEInternalContext *)sock->protocol->context;
2678 if (proto_ctx->packet)
2679 silc_packet_context_free(proto_ctx->packet);
2681 proto_ctx->packet = silc_packet_context_dup(packet);
2682 proto_ctx->dest_id_type = packet->src_id_type;
2683 proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2684 packet->src_id_type);
2685 if (!proto_ctx->dest_id)
2688 /* Let the protocol handle the packet */
2689 silc_protocol_execute(sock->protocol, server->schedule,
2693 SILC_LOG_ERROR(("Received Key Exchange 1 packet but no key exchange "
2694 "protocol active, packet dropped."));
2698 case SILC_PACKET_KEY_EXCHANGE_2:
2699 if (packet->flags & SILC_PACKET_FLAG_LIST)
2702 if (sock->protocol && sock->protocol->protocol &&
2703 (sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_KEY_EXCHANGE ||
2704 sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY)) {
2706 if (sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY) {
2707 SilcServerRekeyInternalContext *proto_ctx =
2708 (SilcServerRekeyInternalContext *)sock->protocol->context;
2710 if (proto_ctx->packet)
2711 silc_packet_context_free(proto_ctx->packet);
2713 proto_ctx->packet = silc_packet_context_dup(packet);
2715 /* Let the protocol handle the packet */
2716 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2718 SilcServerKEInternalContext *proto_ctx =
2719 (SilcServerKEInternalContext *)sock->protocol->context;
2721 if (proto_ctx->packet)
2722 silc_packet_context_free(proto_ctx->packet);
2724 proto_ctx->packet = silc_packet_context_dup(packet);
2725 proto_ctx->dest_id_type = packet->src_id_type;
2726 proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
2727 packet->src_id_type);
2728 if (!proto_ctx->dest_id)
2731 /* Let the protocol handle the packet */
2732 silc_protocol_execute(sock->protocol, server->schedule,
2736 SILC_LOG_ERROR(("Received Key Exchange 2 packet but no key exchange "
2737 "protocol active, packet dropped."));
2741 case SILC_PACKET_CONNECTION_AUTH_REQUEST:
2743 * Connection authentication request packet. When we receive this packet
2744 * we will send to the other end information about our mandatory
2745 * authentication method for the connection. This packet maybe received
2748 if (packet->flags & SILC_PACKET_FLAG_LIST)
2750 silc_server_connection_auth_request(server, sock, packet);
2754 * Connection Authentication protocol packets
2756 case SILC_PACKET_CONNECTION_AUTH:
2757 /* Start of the authentication protocol. We receive here the
2758 authentication data and will verify it. */
2759 if (packet->flags & SILC_PACKET_FLAG_LIST)
2762 if (sock->protocol && sock->protocol->protocol->type
2763 == SILC_PROTOCOL_SERVER_CONNECTION_AUTH) {
2765 SilcServerConnAuthInternalContext *proto_ctx =
2766 (SilcServerConnAuthInternalContext *)sock->protocol->context;
2768 proto_ctx->packet = silc_packet_context_dup(packet);
2770 /* Let the protocol handle the packet */
2771 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2773 SILC_LOG_ERROR(("Received Connection Auth packet but no authentication "
2774 "protocol active, packet dropped."));
2778 case SILC_PACKET_NEW_ID:
2780 * Received New ID packet. This includes some new ID that has been
2781 * created. It may be for client, server or channel. This is the way
2782 * to distribute information about new registered entities in the
2785 if (packet->flags & SILC_PACKET_FLAG_LIST)
2786 silc_server_new_id_list(server, sock, packet);
2788 silc_server_new_id(server, sock, packet);
2791 case SILC_PACKET_NEW_CLIENT:
2793 * Received new client packet. This includes client information that
2794 * we will use to create initial client ID. After creating new
2795 * ID we will send it to the client.
2797 if (packet->flags & SILC_PACKET_FLAG_LIST)
2799 silc_server_new_client(server, sock, packet);
2802 case SILC_PACKET_NEW_SERVER:
2804 * Received new server packet. This includes Server ID and some other
2805 * information that we may save. This is received after server has
2808 if (packet->flags & SILC_PACKET_FLAG_LIST)
2810 silc_server_new_server(server, sock, packet);
2813 case SILC_PACKET_NEW_CHANNEL:
2815 * Received new channel packet. Information about new channel in the
2816 * network are distributed using this packet.
2818 if (packet->flags & SILC_PACKET_FLAG_LIST)
2819 silc_server_new_channel_list(server, sock, packet);
2821 silc_server_new_channel(server, sock, packet);
2824 case SILC_PACKET_HEARTBEAT:
2826 * Received heartbeat.
2828 if (packet->flags & SILC_PACKET_FLAG_LIST)
2832 case SILC_PACKET_KEY_AGREEMENT:
2834 * Received heartbeat.
2836 if (packet->flags & SILC_PACKET_FLAG_LIST)
2838 silc_server_key_agreement(server, sock, packet);
2841 case SILC_PACKET_REKEY:
2843 * Received re-key packet. The sender wants to regenerate the session
2846 if (packet->flags & SILC_PACKET_FLAG_LIST)
2848 silc_server_rekey(server, sock, packet);
2851 case SILC_PACKET_REKEY_DONE:
2853 * The re-key is done.
2855 if (packet->flags & SILC_PACKET_FLAG_LIST)
2858 if (sock->protocol && sock->protocol->protocol &&
2859 sock->protocol->protocol->type == SILC_PROTOCOL_SERVER_REKEY) {
2861 SilcServerRekeyInternalContext *proto_ctx =
2862 (SilcServerRekeyInternalContext *)sock->protocol->context;
2864 if (proto_ctx->packet)
2865 silc_packet_context_free(proto_ctx->packet);
2867 proto_ctx->packet = silc_packet_context_dup(packet);
2869 /* Let the protocol handle the packet */
2870 silc_protocol_execute(sock->protocol, server->schedule, 0, 0);
2872 SILC_LOG_ERROR(("Received Re-key done packet but no re-key "
2873 "protocol active, packet dropped."));
2877 case SILC_PACKET_FTP:
2879 if (packet->flags & SILC_PACKET_FLAG_LIST)
2881 silc_server_ftp(server, sock, packet);
2884 case SILC_PACKET_RESUME_CLIENT:
2886 if (packet->flags & SILC_PACKET_FLAG_LIST)
2888 silc_server_resume_client(server, sock, packet);
2891 case SILC_PACKET_RESUME_ROUTER:
2892 /* Resume router packet received. This packet is received for backup
2893 router resuming protocol. */
2894 if (packet->flags & SILC_PACKET_FLAG_LIST)
2896 silc_server_backup_resume_router(server, sock, packet);
2900 SILC_LOG_ERROR(("Incorrect packet type %d, packet dropped", type));
2905 /* Creates connection to a remote router. */
2907 void silc_server_create_connection(SilcServer server,
2908 const char *remote_host, SilcUInt32 port)
2910 SilcServerConnection sconn;
2912 /* Allocate connection object for hold connection specific stuff. */
2913 sconn = silc_calloc(1, sizeof(*sconn));
2914 sconn->remote_host = strdup(remote_host);
2915 sconn->remote_port = port;
2916 sconn->no_reconnect = TRUE;
2918 silc_schedule_task_add(server->schedule, 0,
2919 silc_server_connect_router,
2920 (void *)sconn, 0, 1, SILC_TASK_TIMEOUT,
2921 SILC_TASK_PRI_NORMAL);
2924 SILC_TASK_CALLBACK(silc_server_close_connection_final)
2926 silc_socket_free(context);
2929 /* Closes connection to socket connection */
2931 void silc_server_close_connection(SilcServer server,
2932 SilcSocketConnection sock)
2936 if (!server->sockets[sock->sock] && SILC_IS_DISCONNECTED(sock)) {
2937 silc_schedule_unset_listen_fd(server->schedule, sock->sock);
2938 silc_schedule_task_del_by_fd(server->schedule, sock->sock);
2939 silc_net_close_connection(sock->sock);
2940 silc_schedule_task_add(server->schedule, sock->sock,
2941 silc_server_close_connection_final,
2942 (void *)sock, 0, 1, SILC_TASK_TIMEOUT,
2943 SILC_TASK_PRI_NORMAL);
2947 memset(tmp, 0, sizeof(tmp));
2948 silc_socket_get_error(sock, tmp, sizeof(tmp));
2949 SILC_LOG_INFO(("Closing connection %s:%d [%s] %s", sock->hostname,
2951 (sock->type == SILC_SOCKET_TYPE_UNKNOWN ? "Unknown" :
2952 sock->type == SILC_SOCKET_TYPE_CLIENT ? "Client" :
2953 sock->type == SILC_SOCKET_TYPE_SERVER ? "Server" :
2954 "Router"), tmp[0] ? tmp : ""));
2956 /* Unregister all tasks */
2957 silc_schedule_task_del_by_fd(server->schedule, sock->sock);
2959 server->sockets[sock->sock] = NULL;
2961 /* If sock->user_data is NULL then we'll check for active protocols
2962 here since the silc_server_free_sock_user_data has not been called
2963 for this connection. */
2964 if (!sock->user_data) {
2965 /* If any protocol is active cancel its execution. It will call
2966 the final callback which will finalize the disconnection. */
2967 if (sock->protocol && sock->protocol->protocol &&
2968 sock->protocol->protocol->type != SILC_PROTOCOL_SERVER_BACKUP) {
2969 SILC_LOG_DEBUG(("Cancelling protocol, calling final callback"));
2970 silc_protocol_cancel(sock->protocol, server->schedule);
2971 sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
2972 silc_protocol_execute_final(sock->protocol, server->schedule);
2973 sock->protocol = NULL;
2978 /* Close the actual connection */
2979 silc_net_close_connection(sock->sock);
2981 /* We won't listen for this connection anymore */
2982 silc_schedule_unset_listen_fd(server->schedule, sock->sock);
2984 silc_schedule_task_add(server->schedule, sock->sock,
2985 silc_server_close_connection_final,
2986 (void *)sock, 0, 1, SILC_TASK_TIMEOUT,
2987 SILC_TASK_PRI_NORMAL);
2990 /* Sends disconnect message to remote connection and disconnects the
2993 void silc_server_disconnect_remote(SilcServer server,
2994 SilcSocketConnection sock,
2995 SilcStatus status, ...)
2998 unsigned char buf[512];
3006 if (SILC_IS_DISCONNECTED(sock)) {
3007 silc_server_close_connection(server, sock);
3011 memset(buf, 0, sizeof(buf));
3012 va_start(ap, status);
3013 cp = va_arg(ap, char *);
3015 vsnprintf(buf, sizeof(buf) - 1, cp, ap);
3020 SILC_LOG_DEBUG(("Disconnecting remote host"));
3022 /* Notify remote end that the conversation is over. The notify message
3023 is tried to be sent immediately. */
3027 len += silc_utf8_encoded_len(buf, strlen(buf), SILC_STRING_ASCII);
3029 buffer = silc_buffer_alloc_size(len);
3033 buffer->data[0] = status;
3035 silc_utf8_encode(buf, strlen(buf), SILC_STRING_ASCII, buffer->data + 1,
3037 silc_server_packet_send(server, sock, SILC_PACKET_DISCONNECT, 0,
3038 buffer->data, buffer->len, TRUE);
3039 silc_buffer_free(buffer);
3042 silc_server_packet_queue_purge(server, sock);
3044 /* Mark the connection to be disconnected */
3045 SILC_SET_DISCONNECTED(sock);
3046 silc_server_close_connection(server, sock);
3049 SILC_TASK_CALLBACK(silc_server_free_client_data_timeout)
3051 SilcServer server = app_context;
3052 SilcClientEntry client = context;
3054 assert(!silc_hash_table_count(client->channels));
3056 silc_idlist_del_data(client);
3057 silc_idcache_purge_by_context(server->local_list->clients, client);
3060 /* Frees client data and notifies about client's signoff. */
3062 void silc_server_free_client_data(SilcServer server,
3063 SilcSocketConnection sock,
3064 SilcClientEntry client,
3066 const char *signoff)
3068 SILC_LOG_DEBUG(("Freeing client data"));
3070 /* If there is pending outgoing data for the client then purge it
3071 to the network before removing the client entry. */
3072 silc_server_packet_queue_purge(server, sock);
3075 /* Check if anyone is watching this nickname */
3076 if (server->server_type == SILC_ROUTER)
3077 silc_server_check_watcher_list(server, client, NULL,
3078 SILC_NOTIFY_TYPE_SIGNOFF);
3080 /* Send SIGNOFF notify to routers. */
3082 silc_server_send_notify_signoff(server, SILC_PRIMARY_ROUTE(server),
3083 SILC_BROADCAST(server), client->id,
3087 /* Remove client from all channels */
3089 silc_server_remove_from_channels(server, NULL, client,
3090 TRUE, (char *)signoff, TRUE, FALSE);
3092 silc_server_remove_from_channels(server, NULL, client,
3093 FALSE, NULL, FALSE, FALSE);
3095 /* Remove this client from watcher list if it is */
3096 silc_server_del_from_watcher_list(server, client);
3098 /* Update statistics */
3099 server->stat.my_clients--;
3100 server->stat.clients--;
3101 if (server->stat.cell_clients)
3102 server->stat.cell_clients--;
3103 SILC_OPER_STATS_UPDATE(client, server, SILC_UMODE_SERVER_OPERATOR);
3104 SILC_OPER_STATS_UPDATE(client, router, SILC_UMODE_ROUTER_OPERATOR);
3105 silc_schedule_task_del_by_context(server->schedule, client);
3107 /* We will not delete the client entry right away. We will take it
3108 into history (for WHOWAS command) for 5 minutes, unless we're
3109 shutting down server. */
3110 if (!server->server_shutdown) {
3111 silc_schedule_task_add(server->schedule, 0,
3112 silc_server_free_client_data_timeout,
3114 SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
3115 client->data.status &= ~SILC_IDLIST_STATUS_REGISTERED;
3116 client->data.status &= ~SILC_IDLIST_STATUS_LOCAL;
3118 client->router = NULL;
3119 client->connection = NULL;
3121 /* Delete directly since we're shutting down server */
3122 silc_idlist_del_data(client);
3123 silc_idlist_del_client(server->local_list, client);
3127 /* Frees user_data pointer from socket connection object. This also sends
3128 appropriate notify packets to the network to inform about leaving
3131 void silc_server_free_sock_user_data(SilcServer server,
3132 SilcSocketConnection sock,
3133 const char *signoff_message)
3135 switch (sock->type) {
3136 case SILC_SOCKET_TYPE_CLIENT:
3138 SilcClientEntry user_data = (SilcClientEntry)sock->user_data;
3139 silc_server_free_client_data(server, sock, user_data, TRUE,
3143 case SILC_SOCKET_TYPE_SERVER:
3144 case SILC_SOCKET_TYPE_ROUTER:
3146 SilcServerEntry user_data = (SilcServerEntry)sock->user_data;
3147 SilcServerEntry backup_router = NULL;
3149 SILC_LOG_DEBUG(("Freeing server data"));
3152 backup_router = silc_server_backup_get(server, user_data->id);
3154 if (!server->backup_router && server->server_type == SILC_ROUTER &&
3155 backup_router == server->id_entry &&
3156 sock->type != SILC_SOCKET_TYPE_ROUTER)
3157 backup_router = NULL;
3159 if (server->server_shutdown || server->backup_noswitch)
3160 backup_router = NULL;
3162 /* If this was our primary router connection then we're lost to
3163 the outside world. */
3164 if (server->router == user_data) {
3165 /* Check whether we have a backup router connection */
3166 if (!backup_router || backup_router == user_data) {
3167 silc_server_create_connections(server);
3168 server->id_entry->router = NULL;
3169 server->router = NULL;
3170 server->standalone = TRUE;
3171 server->backup_primary = FALSE;
3172 backup_router = NULL;
3174 if (server->id_entry != backup_router) {
3175 SILC_LOG_INFO(("New primary router is backup router %s",
3176 backup_router->server_name));
3177 server->id_entry->router = backup_router;
3178 server->router = backup_router;
3179 server->router_connect = time(0);
3180 server->backup_primary = TRUE;
3182 SILC_LOG_INFO(("We are now new primary router in this cell"));
3183 server->id_entry->router = NULL;
3184 server->router = NULL;
3185 server->standalone = TRUE;
3187 /* We stop here to take a breath */
3191 if (server->server_type == SILC_BACKUP_ROUTER) {
3192 server->server_type = SILC_ROUTER;
3194 /* We'll need to constantly try to reconnect to the primary
3195 router so that we'll see when it comes back online. */
3196 silc_server_backup_reconnect(server, sock->ip, sock->port,
3197 silc_server_backup_connected,
3201 /* Mark this connection as replaced */
3202 silc_server_backup_replaced_add(server, user_data->id,
3205 } else if (backup_router) {
3206 SILC_LOG_INFO(("Enabling the use of backup router %s",
3207 backup_router->server_name));
3209 /* Mark this connection as replaced */
3210 silc_server_backup_replaced_add(server, user_data->id,
3212 } else if (server->server_type == SILC_SERVER &&
3213 sock->type == SILC_SOCKET_TYPE_ROUTER) {
3214 /* Reconnect to the router (backup) */
3215 silc_server_create_connections(server);
3218 if (user_data->server_name)
3219 SILC_SERVER_SEND_OPERS(server, FALSE, TRUE, SILC_NOTIFY_TYPE_NONE,
3220 ("Server %s signoff", user_data->server_name));
3222 if (!backup_router) {
3223 /* Remove all servers that are originated from this server, and
3224 remove the clients of those servers too. */
3225 silc_server_remove_servers_by_server(server, user_data, TRUE);
3228 /* Remove the clients that this server owns as they will become
3229 invalid now too. For backup router the server is actually
3230 coming from the primary router, so mark that as the owner
3232 if (server->server_type == SILC_BACKUP_ROUTER &&
3233 sock->type == SILC_SOCKET_TYPE_SERVER)
3234 silc_server_remove_clients_by_server(server, server->router,
3238 silc_server_remove_clients_by_server(server, user_data,
3241 /* Remove channels owned by this server */
3242 if (server->server_type == SILC_SERVER)
3243 silc_server_remove_channels_by_server(server, user_data);
3245 /* Enable local server connections that may be disabled */
3246 silc_server_local_servers_toggle_enabled(server, TRUE);
3248 /* Update the client entries of this server to the new backup
3249 router. If we are the backup router we also resolve the real
3250 servers for the clients. After updating is over this also
3251 removes the clients that this server explicitly owns. */
3252 silc_server_update_clients_by_server(server, user_data,
3253 backup_router, TRUE);
3255 /* If we are router and just lost our primary router (now standlaone)
3256 we remove everything that was behind it, since we don't know
3258 if (server->server_type == SILC_ROUTER && server->standalone)
3259 /* Remove all servers that are originated from this server, and
3260 remove the clients of those servers too. */
3261 silc_server_remove_servers_by_server(server, user_data, TRUE);
3263 /* Finally remove the clients that are explicitly owned by this
3264 server. They go down with the server. */
3265 silc_server_remove_clients_by_server(server, user_data,
3268 /* Update our server cache to use the new backup router too. */
3269 silc_server_update_servers_by_server(server, user_data, backup_router);
3270 if (server->server_type == SILC_SERVER)
3271 silc_server_update_channels_by_server(server, user_data,
3274 /* Send notify about primary router going down to local operators */
3275 if (server->backup_router)
3276 SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3277 SILC_NOTIFY_TYPE_NONE,
3278 ("%s switched to backup router %s "
3279 "(we are primary router now)",
3280 server->server_name, server->server_name));
3281 else if (server->router)
3282 SILC_SERVER_SEND_OPERS(server, FALSE, TRUE,
3283 SILC_NOTIFY_TYPE_NONE,
3284 ("%s switched to backup router %s",
3285 server->server_name,
3286 server->router->server_name));
3288 server->backup_noswitch = FALSE;
3290 /* Free the server entry */
3291 silc_server_backup_del(server, user_data);
3292 silc_server_backup_replaced_del(server, user_data);
3293 silc_idlist_del_data(user_data);
3294 if (!silc_idlist_del_server(server->local_list, user_data))
3295 silc_idlist_del_server(server->global_list, user_data);
3296 if (sock->type == SILC_SOCKET_TYPE_SERVER) {
3297 server->stat.my_servers--;
3299 server->stat.my_routers--;
3300 server->stat.routers--;
3302 server->stat.servers--;
3303 if (server->server_type == SILC_ROUTER)
3304 server->stat.cell_servers--;
3306 if (backup_router && backup_router != server->id_entry) {
3307 /* Announce all of our stuff that was created about 5 minutes ago.
3308 The backup router knows all the other stuff already. */
3309 if (server->server_type == SILC_ROUTER)
3310 silc_server_announce_servers(server, FALSE, time(0) - 300,
3311 backup_router->connection);
3313 /* Announce our clients and channels to the router */
3314 silc_server_announce_clients(server, time(0) - 300,
3315 backup_router->connection);
3316 silc_server_announce_channels(server, time(0) - 300,
3317 backup_router->connection);
3323 SilcUnknownEntry user_data = (SilcUnknownEntry)sock->user_data;
3325 SILC_LOG_DEBUG(("Freeing unknown connection data"));
3327 silc_idlist_del_data(user_data);
3328 silc_free(user_data);
3333 /* If any protocol is active cancel its execution */
3334 if (sock->protocol && sock->protocol->protocol &&
3335 sock->protocol->protocol->type != SILC_PROTOCOL_SERVER_BACKUP) {
3336 SILC_LOG_DEBUG(("Cancelling protocol, calling final callback"));
3337 silc_protocol_cancel(sock->protocol, server->schedule);
3338 sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
3339 silc_protocol_execute_final(sock->protocol, server->schedule);
3340 sock->protocol = NULL;
3343 sock->user_data = NULL;
3346 /* Removes client from all channels it has joined. This is used when client
3347 connection is disconnected. If the client on a channel is last, the
3348 channel is removed as well. This sends the SIGNOFF notify types. */
3350 void silc_server_remove_from_channels(SilcServer server,
3351 SilcSocketConnection sock,
3352 SilcClientEntry client,
3354 const char *signoff_message,
3358 SilcChannelEntry channel;
3359 SilcChannelClientEntry chl;
3360 SilcHashTableList htl;
3361 SilcBuffer clidp = NULL;
3366 SILC_LOG_DEBUG(("Removing client from joined channels"));
3368 if (notify && !client->id)
3372 clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3377 /* Remove the client from all channels. The client is removed from
3378 the channels' user list. */
3379 silc_hash_table_list(client->channels, &htl);
3380 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
3381 channel = chl->channel;
3383 /* Remove channel if this is last client leaving the channel, unless
3384 the channel is permanent. */
3385 if (server->server_type != SILC_SERVER &&
3386 silc_hash_table_count(channel->user_list) < 2) {
3387 silc_server_channel_delete(server, channel);
3391 silc_hash_table_del(client->channels, channel);
3392 silc_hash_table_del(channel->user_list, client);
3393 channel->user_count--;
3395 /* If there is no global users on the channel anymore mark the channel
3396 as local channel. Do not check if the removed client is local client. */
3397 if (server->server_type == SILC_SERVER && channel->global_users &&
3398 chl->client->router && !silc_server_channel_has_global(channel))
3399 channel->global_users = FALSE;
3401 memset(chl, 'A', sizeof(*chl));
3404 /* Update statistics */
3405 if (SILC_IS_LOCAL(client))
3406 server->stat.my_chanclients--;
3407 if (server->server_type == SILC_ROUTER) {
3408 server->stat.cell_chanclients--;
3409 server->stat.chanclients--;
3412 /* If there is not at least one local user on the channel then we don't
3413 need the channel entry anymore, we can remove it safely, unless the
3414 channel is permanent channel */
3415 if (server->server_type == SILC_SERVER &&
3416 !silc_server_channel_has_local(channel)) {
3417 /* Notify about leaving client if this channel has global users. */
3418 if (notify && channel->global_users)
3419 silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
3420 SILC_NOTIFY_TYPE_SIGNOFF,
3421 signoff_message ? 2 : 1,
3422 clidp->data, clidp->len,
3423 signoff_message, signoff_message ?
3424 strlen(signoff_message) : 0);
3426 silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3427 silc_server_channel_delete(server, channel);
3431 /* Send notify to channel about client leaving SILC and channel too */
3433 silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
3434 SILC_NOTIFY_TYPE_SIGNOFF,
3435 signoff_message ? 2 : 1,
3436 clidp->data, clidp->len,
3437 signoff_message, signoff_message ?
3438 strlen(signoff_message) : 0);
3440 if (killed && clidp) {
3441 /* Remove the client from channel's invite list */
3442 if (channel->invite_list &&
3443 silc_hash_table_count(channel->invite_list)) {
3445 SilcArgumentPayload iargs;
3446 ab = silc_argument_payload_encode_one(NULL, clidp->data,
3448 iargs = silc_argument_payload_parse(ab->data, ab->len, 1);
3449 silc_server_inviteban_process(server, channel->invite_list, 1, iargs);
3450 silc_buffer_free(ab);
3451 silc_argument_payload_free(iargs);
3455 /* Don't create keys if we are shutting down */
3456 if (server->server_shutdown)
3459 /* Re-generate channel key if needed */
3460 if (keygen && !(channel->mode & SILC_CHANNEL_MODE_PRIVKEY)) {
3461 if (!silc_server_create_channel_key(server, channel, 0))
3464 /* Send the channel key to the channel. The key of course is not sent
3465 to the client who was removed from the channel. */
3466 silc_server_send_channel_key(server, client->connection, channel,
3467 server->server_type == SILC_ROUTER ?
3468 FALSE : !server->standalone);
3472 silc_hash_table_list_reset(&htl);
3474 silc_buffer_free(clidp);
3477 /* Removes client from one channel. This is used for example when client
3478 calls LEAVE command to remove itself from the channel. Returns TRUE
3479 if channel still exists and FALSE if the channel is removed when
3480 last client leaves the channel. If `notify' is FALSE notify messages
3483 bool silc_server_remove_from_one_channel(SilcServer server,
3484 SilcSocketConnection sock,
3485 SilcChannelEntry channel,
3486 SilcClientEntry client,
3489 SilcChannelClientEntry chl;
3492 SILC_LOG_DEBUG(("Removing %s from channel %s",
3493 silc_id_render(client->id, SILC_ID_CLIENT),
3494 channel->channel_name));
3496 /* Get the entry to the channel, if this client is not on the channel
3498 if (!silc_hash_table_find(client->channels, channel, NULL, (void *)&chl))
3501 /* Remove channel if this is last client leaving the channel, unless
3502 the channel is permanent. */
3503 if (server->server_type != SILC_SERVER &&
3504 silc_hash_table_count(channel->user_list) < 2) {
3505 silc_server_channel_delete(server, channel);
3509 silc_hash_table_del(client->channels, channel);
3510 silc_hash_table_del(channel->user_list, client);
3511 channel->user_count--;
3513 /* If there is no global users on the channel anymore mark the channel
3514 as local channel. Do not check if the client is local client. */
3515 if (server->server_type == SILC_SERVER && channel->global_users &&
3516 chl->client->router && !silc_server_channel_has_global(channel))
3517 channel->global_users = FALSE;
3519 memset(chl, 'O', sizeof(*chl));
3522 /* Update statistics */
3523 if (SILC_IS_LOCAL(client))
3524 server->stat.my_chanclients--;
3525 if (server->server_type == SILC_ROUTER) {
3526 server->stat.cell_chanclients--;
3527 server->stat.chanclients--;
3530 clidp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
3534 /* If there is not at least one local user on the channel then we don't
3535 need the channel entry anymore, we can remove it safely, unless the
3536 channel is permanent channel */
3537 if (server->server_type == SILC_SERVER &&
3538 !silc_server_channel_has_local(channel)) {
3539 /* Notify about leaving client if this channel has global users. */
3540 if (notify && channel->global_users)
3541 silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
3542 SILC_NOTIFY_TYPE_LEAVE, 1,
3543 clidp->data, clidp->len);
3545 silc_schedule_task_del_by_context(server->schedule, channel->rekey);
3546 silc_server_channel_delete(server, channel);
3547 silc_buffer_free(clidp);
3551 /* Send notify to channel about client leaving the channel */
3553 silc_server_send_notify_to_channel(server, NULL, channel, FALSE,
3554 SILC_NOTIFY_TYPE_LEAVE, 1,
3555 clidp->data, clidp->len);
3557 silc_buffer_free(clidp);
3561 /* Timeout callback. This is called if connection is idle or for some
3562 other reason is not responding within some period of time. This
3563 disconnects the remote end. */
3565 SILC_TASK_CALLBACK(silc_server_timeout_remote)
3567 SilcServer server = (SilcServer)context;
3568 SilcSocketConnection sock = server->sockets[fd];
3569 SilcProtocolType protocol = 0;
3571 SILC_LOG_DEBUG(("Start"));
3576 SILC_LOG_ERROR(("No response from %s (%s), Connection timeout",
3577 sock->hostname, sock->ip));
3579 /* If we have protocol active we must assure that we call the protocol's
3580 final callback so that all the memory is freed. */
3581 if (sock->protocol && sock->protocol->protocol &&
3582 sock->protocol->protocol->type != SILC_PROTOCOL_SERVER_BACKUP) {
3583 protocol = sock->protocol->protocol->type;
3584 silc_protocol_cancel(sock->protocol, server->schedule);
3585 sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
3586 silc_protocol_execute_final(sock->protocol, server->schedule);
3587 sock->protocol = NULL;
3591 silc_server_disconnect_remote(server, sock,
3593 SILC_PROTOCOL_SERVER_CONNECTION_AUTH ?
3594 SILC_STATUS_ERR_AUTH_FAILED :
3595 SILC_STATUS_ERR_KEY_EXCHANGE_FAILED,
3596 "Connection timeout");
3598 if (sock->user_data)
3599 silc_server_free_sock_user_data(server, sock, NULL);
3602 /* Creates new channel. Sends NEW_CHANNEL packet to primary route. This
3603 function may be used only by router. In real SILC network all channels
3604 are created by routers thus this function is never used by normal
3607 SilcChannelEntry silc_server_create_new_channel(SilcServer server,
3608 SilcServerID *router_id,
3614 SilcChannelID *channel_id;
3615 SilcChannelEntry entry;
3619 SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3622 cipher = SILC_DEFAULT_CIPHER;
3624 hmac = SILC_DEFAULT_HMAC;
3626 /* Allocate cipher */
3627 if (!silc_cipher_alloc(cipher, &key))
3631 if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3632 silc_cipher_free(key);
3636 channel_name = strdup(channel_name);
3638 /* Create the channel ID */
3639 if (!silc_id_create_channel_id(server, router_id, server->rng,
3641 silc_free(channel_name);
3642 silc_cipher_free(key);
3643 silc_hmac_free(newhmac);
3647 /* Create the channel */
3648 entry = silc_idlist_add_channel(server->local_list, channel_name,
3649 SILC_CHANNEL_MODE_NONE, channel_id,
3650 NULL, key, newhmac, 0);
3652 silc_free(channel_name);
3653 silc_cipher_free(key);
3654 silc_hmac_free(newhmac);
3655 silc_free(channel_id);
3659 entry->cipher = strdup(cipher);
3660 entry->hmac_name = strdup(hmac);
3662 /* Now create the actual key material */
3663 if (!silc_server_create_channel_key(server, entry,
3664 silc_cipher_get_key_len(key) / 8)) {
3665 silc_idlist_del_channel(server->local_list, entry);
3669 /* Notify other routers about the new channel. We send the packet
3670 to our primary route. */
3672 silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3673 channel_name, entry->id,
3674 silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3677 /* Distribute to backup routers */
3678 if (broadcast && server->server_type == SILC_ROUTER) {
3681 SilcUInt32 name_len = strlen(channel_name);
3682 SilcUInt32 channel_id_len = silc_id_get_len(entry->id, SILC_ID_CHANNEL);
3683 cid = silc_id_id2str(entry->id, SILC_ID_CHANNEL);
3685 packet = silc_channel_payload_encode(channel_name, name_len,
3686 cid, channel_id_len, entry->mode);
3687 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3688 packet->data, packet->len, FALSE, TRUE);
3690 silc_buffer_free(packet);
3693 server->stat.my_channels++;
3694 if (server->server_type == SILC_ROUTER) {
3695 server->stat.channels++;
3696 server->stat.cell_channels++;
3697 entry->users_resolved = TRUE;
3703 /* Same as above but creates the channel with Channel ID `channel_id. */
3706 silc_server_create_new_channel_with_id(SilcServer server,
3710 SilcChannelID *channel_id,
3713 SilcChannelEntry entry;
3717 SILC_LOG_DEBUG(("Creating new channel %s", channel_name));
3720 cipher = SILC_DEFAULT_CIPHER;
3722 hmac = SILC_DEFAULT_HMAC;
3724 /* Allocate cipher */
3725 if (!silc_cipher_alloc(cipher, &key))
3729 if (!silc_hmac_alloc(hmac, NULL, &newhmac)) {
3730 silc_cipher_free(key);
3734 channel_name = strdup(channel_name);
3736 /* Create the channel */
3737 entry = silc_idlist_add_channel(server->local_list, channel_name,
3738 SILC_CHANNEL_MODE_NONE, channel_id,
3739 NULL, key, newhmac, 0);
3741 silc_cipher_free(key);
3742 silc_hmac_free(newhmac);
3743 silc_free(channel_name);
3747 /* Now create the actual key material */
3748 if (!silc_server_create_channel_key(server, entry,
3749 silc_cipher_get_key_len(key) / 8)) {
3750 silc_idlist_del_channel(server->local_list, entry);
3754 /* Notify other routers about the new channel. We send the packet
3755 to our primary route. */
3757 silc_server_send_new_channel(server, SILC_PRIMARY_ROUTE(server), TRUE,
3758 channel_name, entry->id,
3759 silc_id_get_len(entry->id, SILC_ID_CHANNEL),
3762 /* Distribute to backup routers */
3763 if (broadcast && server->server_type == SILC_ROUTER) {
3766 SilcUInt32 name_len = strlen(channel_name);
3767 SilcUInt32 channel_id_len = silc_id_get_len(entry->id, SILC_ID_CHANNEL);
3768 cid = silc_id_id2str(entry->id, SILC_ID_CHANNEL);
3770 packet = silc_channel_payload_encode(channel_name, name_len,
3771 cid, channel_id_len, entry->mode);
3772 silc_server_backup_send(server, NULL, SILC_PACKET_NEW_CHANNEL, 0,
3773 packet->data, packet->len, FALSE, TRUE);
3775 silc_buffer_free(packet);
3778 server->stat.my_channels++;
3779 if (server->server_type == SILC_ROUTER) {
3780 server->stat.channels++;
3781 server->stat.cell_channels++;
3782 entry->users_resolved = TRUE;
3788 /* Channel's key re-key timeout callback. */
3790 SILC_TASK_CALLBACK(silc_server_channel_key_rekey)
3792 SilcServer server = app_context;
3793 SilcServerChannelRekey rekey = (SilcServerChannelRekey)context;
3797 /* Return now if we are shutting down */
3798 if (server->server_shutdown)
3801 if (!silc_server_create_channel_key(server, rekey->channel, rekey->key_len))
3804 silc_server_send_channel_key(server, NULL, rekey->channel, FALSE);
3807 /* Generates new channel key. This is used to create the initial channel key
3808 but also to re-generate new key for channel. If `key_len' is provided
3809 it is the bytes of the key length. */
3811 bool silc_server_create_channel_key(SilcServer server,
3812 SilcChannelEntry channel,
3816 unsigned char channel_key[32], hash[32];
3819 if (channel->mode & SILC_CHANNEL_MODE_PRIVKEY) {
3820 SILC_LOG_DEBUG(("Channel has private keys, will not generate new key"));
3824 SILC_LOG_DEBUG(("Generating channel %s key", channel->channel_name));
3826 if (!channel->channel_key)
3827 if (!silc_cipher_alloc(SILC_DEFAULT_CIPHER, &channel->channel_key)) {
3828 channel->channel_key = NULL;
3834 else if (channel->key_len)
3835 len = channel->key_len / 8;
3837 len = silc_cipher_get_key_len(channel->channel_key) / 8;
3839 /* Create channel key */
3840 for (i = 0; i < len; i++) channel_key[i] = silc_rng_get_byte(server->rng);
3843 silc_cipher_set_key(channel->channel_key, channel_key, len * 8);
3845 /* Remove old key if exists */
3847 memset(channel->key, 0, channel->key_len / 8);
3848 silc_free(channel->key);
3852 channel->key_len = len * 8;
3853 channel->key = silc_memdup(channel_key, len);
3854 memset(channel_key, 0, sizeof(channel_key));
3856 /* Generate HMAC key from the channel key data and set it */
3858 if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3859 memset(channel->key, 0, channel->key_len / 8);
3860 silc_free(channel->key);
3861 channel->channel_key = NULL;
3864 silc_hash_make(silc_hmac_get_hash(channel->hmac), channel->key, len, hash);
3865 silc_hmac_set_key(channel->hmac, hash,
3866 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3867 memset(hash, 0, sizeof(hash));
3869 if (server->server_type == SILC_ROUTER) {
3870 if (!channel->rekey)
3871 channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3872 channel->rekey->channel = channel;
3873 channel->rekey->key_len = key_len;
3874 if (channel->rekey->task)
3875 silc_schedule_task_del(server->schedule, channel->rekey->task);
3877 channel->rekey->task =
3878 silc_schedule_task_add(server->schedule, 0,
3879 silc_server_channel_key_rekey,
3880 (void *)channel->rekey,
3881 server->config->channel_rekey_secs, 0,
3883 SILC_TASK_PRI_NORMAL);
3889 /* Saves the channel key found in the encoded `key_payload' buffer. This
3890 function is used when we receive Channel Key Payload and also when we're
3891 processing JOIN command reply. Returns entry to the channel. */
3893 SilcChannelEntry silc_server_save_channel_key(SilcServer server,
3894 SilcBuffer key_payload,
3895 SilcChannelEntry channel)
3897 SilcChannelKeyPayload payload = NULL;
3898 SilcChannelID *id = NULL;
3899 unsigned char *tmp, hash[32];
3903 /* Decode channel key payload */
3904 payload = silc_channel_key_payload_parse(key_payload->data,
3907 SILC_LOG_ERROR(("Bad channel key payload received, dropped"));
3912 /* Get the channel entry */
3915 /* Get channel ID */
3916 tmp = silc_channel_key_get_id(payload, &tmp_len);
3917 id = silc_id_str2id(tmp, tmp_len, SILC_ID_CHANNEL);
3923 channel = silc_idlist_find_channel_by_id(server->local_list, id, NULL);
3925 channel = silc_idlist_find_channel_by_id(server->global_list, id, NULL);
3927 if (server->server_type == SILC_ROUTER)
3928 SILC_LOG_ERROR(("Received key for non-existent channel %s",
3929 silc_id_render(id, SILC_ID_CHANNEL)));
3935 SILC_LOG_DEBUG(("Saving new channel %s key", channel->channel_name));
3937 tmp = silc_channel_key_get_key(payload, &tmp_len);
3943 cipher = silc_channel_key_get_cipher(payload, NULL);
3949 /* Remove old key if exists */
3951 memset(channel->key, 0, channel->key_len / 8);
3952 silc_free(channel->key);
3953 silc_cipher_free(channel->channel_key);
3956 /* Create new cipher */
3957 if (!silc_cipher_alloc(cipher, &channel->channel_key)) {
3958 channel->channel_key = NULL;
3963 if (channel->cipher)
3964 silc_free(channel->cipher);
3965 channel->cipher = strdup(cipher);
3968 channel->key_len = tmp_len * 8;
3969 channel->key = silc_memdup(tmp, tmp_len);
3970 silc_cipher_set_key(channel->channel_key, tmp, channel->key_len);
3972 /* Generate HMAC key from the channel key data and set it */
3974 if (!silc_hmac_alloc(SILC_DEFAULT_HMAC, NULL, &channel->hmac)) {
3975 memset(channel->key, 0, channel->key_len / 8);
3976 silc_free(channel->key);
3977 channel->channel_key = NULL;
3980 silc_hash_make(silc_hmac_get_hash(channel->hmac), tmp, tmp_len, hash);
3981 silc_hmac_set_key(channel->hmac, hash,
3982 silc_hash_len(silc_hmac_get_hash(channel->hmac)));
3984 memset(hash, 0, sizeof(hash));
3985 memset(tmp, 0, tmp_len);
3987 if (server->server_type == SILC_ROUTER) {
3988 if (!channel->rekey)
3989 channel->rekey = silc_calloc(1, sizeof(*channel->rekey));
3990 channel->rekey->channel = channel;
3991 if (channel->rekey->task)
3992 silc_schedule_task_del(server->schedule, channel->rekey->task);
3994 channel->rekey->task =
3995 silc_schedule_task_add(server->schedule, 0,
3996 silc_server_channel_key_rekey,
3997 (void *)channel->rekey,
3998 server->config->channel_rekey_secs, 0,
4000 SILC_TASK_PRI_NORMAL);
4006 silc_channel_key_payload_free(payload);
4011 /* Heartbeat callback. This function is set as argument for the
4012 silc_socket_set_heartbeat function. The library will call this function
4013 at the set time interval. */
4015 void silc_server_perform_heartbeat(SilcSocketConnection sock,
4018 SilcServer server = hb_context;
4020 SILC_LOG_DEBUG(("Sending heartbeat to %s:%d (%s)", sock->hostname,
4021 sock->port, sock->ip));
4023 /* Send the heartbeat */
4024 silc_server_send_heartbeat(server, sock);
4027 /* Returns assembled of all servers in the given ID list. The packet's
4028 form is dictated by the New ID payload. */
4030 static void silc_server_announce_get_servers(SilcServer server,
4031 SilcServerEntry remote,
4033 SilcBuffer *servers,
4034 unsigned long creation_time)
4036 SilcIDCacheList list;
4037 SilcIDCacheEntry id_cache;
4038 SilcServerEntry entry;
4041 /* Go through all clients in the list */
4042 if (silc_idcache_get_all(id_list->servers, &list)) {
4043 if (silc_idcache_list_first(list, &id_cache)) {
4045 entry = (SilcServerEntry)id_cache->context;
4047 /* Do not announce the one we've sending our announcements and
4048 do not announce ourself. Also check the creation time if it's
4050 if ((entry == remote) || (entry == server->id_entry) ||
4051 (creation_time && entry->data.created < creation_time)) {
4052 if (!silc_idcache_list_next(list, &id_cache))
4057 idp = silc_id_payload_encode(entry->id, SILC_ID_SERVER);
4059 *servers = silc_buffer_realloc(*servers,
4061 (*servers)->truelen + idp->len :
4063 silc_buffer_pull_tail(*servers, ((*servers)->end - (*servers)->data));
4064 silc_buffer_put(*servers, idp->data, idp->len);
4065 silc_buffer_pull(*servers, idp->len);
4066 silc_buffer_free(idp);
4068 if (!silc_idcache_list_next(list, &id_cache))
4073 silc_idcache_list_free(list);
4078 silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
4084 p = silc_notify_payload_encode(notify, argc, ap);
4090 /* This function is used by router to announce existing servers to our
4091 primary router when we've connected to it. If `creation_time' is non-zero
4092 then only the servers that has been created after the `creation_time'
4093 will be announced. */
4095 void silc_server_announce_servers(SilcServer server, bool global,
4096 unsigned long creation_time,
4097 SilcSocketConnection remote)
4099 SilcBuffer servers = NULL;
4101 SILC_LOG_DEBUG(("Announcing servers"));
4103 /* Get servers in local list */
4104 silc_server_announce_get_servers(server, remote->user_data,
4105 server->local_list, &servers,
4109 /* Get servers in global list */
4110 silc_server_announce_get_servers(server, remote->user_data,
4111 server->global_list, &servers,
4115 silc_buffer_push(servers, servers->data - servers->head);
4116 SILC_LOG_HEXDUMP(("servers"), servers->data, servers->len);
4118 /* Send the packet */
4119 silc_server_packet_send(server, remote,
4120 SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4121 servers->data, servers->len, TRUE);
4123 silc_buffer_free(servers);
4127 /* Returns assembled packet of all clients in the given ID list. The
4128 packet's form is dictated by the New ID Payload. */
4130 static void silc_server_announce_get_clients(SilcServer server,
4132 SilcBuffer *clients,
4134 unsigned long creation_time)
4136 SilcIDCacheList list;
4137 SilcIDCacheEntry id_cache;
4138 SilcClientEntry client;
4141 unsigned char mode[4];
4143 /* Go through all clients in the list */
4144 if (silc_idcache_get_all(id_list->clients, &list)) {
4145 if (silc_idcache_list_first(list, &id_cache)) {
4147 client = (SilcClientEntry)id_cache->context;
4149 if (creation_time && client->data.created < creation_time) {
4150 if (!silc_idcache_list_next(list, &id_cache))
4154 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED) &&
4155 !client->connection && !client->router && !SILC_IS_LOCAL(client)) {
4156 if (!silc_idcache_list_next(list, &id_cache))
4161 idp = silc_id_payload_encode(client->id, SILC_ID_CLIENT);
4163 *clients = silc_buffer_realloc(*clients,
4165 (*clients)->truelen + idp->len :
4167 silc_buffer_pull_tail(*clients, ((*clients)->end - (*clients)->data));
4168 silc_buffer_put(*clients, idp->data, idp->len);
4169 silc_buffer_pull(*clients, idp->len);
4171 SILC_PUT32_MSB(client->mode, mode);
4173 silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_UMODE_CHANGE,
4174 2, idp->data, idp->len,
4176 *umodes = silc_buffer_realloc(*umodes,
4178 (*umodes)->truelen + tmp->len :
4180 silc_buffer_pull_tail(*umodes, ((*umodes)->end - (*umodes)->data));
4181 silc_buffer_put(*umodes, tmp->data, tmp->len);
4182 silc_buffer_pull(*umodes, tmp->len);
4183 silc_buffer_free(tmp);
4185 silc_buffer_free(idp);
4187 if (!silc_idcache_list_next(list, &id_cache))
4192 silc_idcache_list_free(list);
4196 /* This function is used to announce our existing clients to our router
4197 when we've connected to it. If `creation_time' is non-zero then only
4198 the clients that has been created after the `creation_time' will be
4201 void silc_server_announce_clients(SilcServer server,
4202 unsigned long creation_time,
4203 SilcSocketConnection remote)
4205 SilcBuffer clients = NULL;
4206 SilcBuffer umodes = NULL;
4208 SILC_LOG_DEBUG(("Announcing clients"));
4210 /* Get clients in local list */
4211 silc_server_announce_get_clients(server, server->local_list,
4212 &clients, &umodes, creation_time);
4214 /* As router we announce our global list as well */
4215 if (server->server_type == SILC_ROUTER)
4216 silc_server_announce_get_clients(server, server->global_list,
4217 &clients, &umodes, creation_time);
4220 silc_buffer_push(clients, clients->data - clients->head);
4221 SILC_LOG_HEXDUMP(("clients"), clients->data, clients->len);
4223 /* Send the packet */
4224 silc_server_packet_send(server, remote,
4225 SILC_PACKET_NEW_ID, SILC_PACKET_FLAG_LIST,
4226 clients->data, clients->len, TRUE);
4228 silc_buffer_free(clients);
4232 silc_buffer_push(umodes, umodes->data - umodes->head);
4233 SILC_LOG_HEXDUMP(("umodes"), umodes->data, umodes->len);
4235 /* Send the packet */
4236 silc_server_packet_send(server, remote,
4237 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4238 umodes->data, umodes->len, TRUE);
4240 silc_buffer_free(umodes);
4244 /* Returns channel's topic for announcing it */
4246 void silc_server_announce_get_channel_topic(SilcServer server,
4247 SilcChannelEntry channel,
4252 if (channel->topic) {
4253 chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4254 *topic = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_TOPIC_SET, 2,
4255 chidp->data, chidp->len,
4257 strlen(channel->topic));
4258 silc_buffer_free(chidp);
4262 /* Returns assembled packets for channel users of the `channel'. */
4264 void silc_server_announce_get_channel_users(SilcServer server,
4265 SilcChannelEntry channel,
4266 SilcBuffer *channel_modes,
4267 SilcBuffer *channel_users,
4268 SilcBuffer *channel_users_modes)
4270 SilcChannelClientEntry chl;
4271 SilcHashTableList htl;
4272 SilcBuffer chidp, clidp, csidp;
4273 SilcBuffer tmp, fkey = NULL;
4275 unsigned char mode[4];
4278 SILC_LOG_DEBUG(("Start"));
4280 chidp = silc_id_payload_encode(channel->id, SILC_ID_CHANNEL);
4281 csidp = silc_id_payload_encode(server->id, SILC_ID_SERVER);
4284 SILC_PUT32_MSB(channel->mode, mode);
4285 hmac = channel->hmac ? (char *)silc_hmac_get_name(channel->hmac) : NULL;
4286 if (channel->founder_key)
4287 fkey = silc_pkcs_public_key_payload_encode(channel->founder_key);
4289 silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CMODE_CHANGE,
4290 6, csidp->data, csidp->len,
4293 hmac, hmac ? strlen(hmac) : 0,
4294 channel->passphrase,
4295 channel->passphrase ?
4296 strlen(channel->passphrase) : 0,
4297 fkey ? fkey->data : NULL,
4298 fkey ? fkey->len : 0);
4301 silc_buffer_realloc(*channel_modes,
4303 (*channel_modes)->truelen + len : len));
4304 silc_buffer_pull_tail(*channel_modes,
4305 ((*channel_modes)->end -
4306 (*channel_modes)->data));
4307 silc_buffer_put(*channel_modes, tmp->data, tmp->len);
4308 silc_buffer_pull(*channel_modes, len);
4309 silc_buffer_free(tmp);
4310 silc_buffer_free(fkey);
4313 /* Now find all users on the channel */
4314 silc_hash_table_list(channel->user_list, &htl);
4315 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4316 clidp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4319 tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_JOIN, 2,
4320 clidp->data, clidp->len,
4321 chidp->data, chidp->len);
4324 silc_buffer_realloc(*channel_users,
4326 (*channel_users)->truelen + len : len));
4327 silc_buffer_pull_tail(*channel_users,
4328 ((*channel_users)->end -
4329 (*channel_users)->data));
4331 silc_buffer_put(*channel_users, tmp->data, tmp->len);
4332 silc_buffer_pull(*channel_users, len);
4333 silc_buffer_free(tmp);
4335 /* CUMODE notify for mode change on the channel */
4336 SILC_PUT32_MSB(chl->mode, mode);
4337 if (chl->mode & SILC_CHANNEL_UMODE_CHANFO && channel->founder_key)
4338 fkey = silc_pkcs_public_key_payload_encode(channel->founder_key);
4339 tmp = silc_server_announce_encode_notify(SILC_NOTIFY_TYPE_CUMODE_CHANGE,
4340 4, csidp->data, csidp->len,
4342 clidp->data, clidp->len,
4343 fkey ? fkey->data : NULL,
4344 fkey ? fkey->len : 0);
4346 *channel_users_modes =
4347 silc_buffer_realloc(*channel_users_modes,
4348 (*channel_users_modes ?
4349 (*channel_users_modes)->truelen + len : len));
4350 silc_buffer_pull_tail(*channel_users_modes,
4351 ((*channel_users_modes)->end -
4352 (*channel_users_modes)->data));
4354 silc_buffer_put(*channel_users_modes, tmp->data, tmp->len);
4355 silc_buffer_pull(*channel_users_modes, len);
4356 silc_buffer_free(tmp);
4357 silc_buffer_free(fkey);
4359 silc_buffer_free(clidp);
4361 silc_hash_table_list_reset(&htl);
4362 silc_buffer_free(chidp);
4363 silc_buffer_free(csidp);
4366 /* Returns assembled packets for all channels and users on those channels
4367 from the given ID List. The packets are in the form dictated by the
4368 New Channel and New Channel User payloads. */
4370 void silc_server_announce_get_channels(SilcServer server,
4372 SilcBuffer *channels,
4373 SilcBuffer **channel_modes,
4374 SilcBuffer *channel_users,
4375 SilcBuffer **channel_users_modes,
4376 SilcUInt32 *channel_users_modes_c,
4377 SilcBuffer **channel_topics,
4378 SilcChannelID ***channel_ids,
4379 unsigned long creation_time)
4381 SilcIDCacheList list;
4382 SilcIDCacheEntry id_cache;
4383 SilcChannelEntry channel;
4386 SilcUInt16 name_len;
4388 int i = *channel_users_modes_c;
4391 SILC_LOG_DEBUG(("Start"));
4393 /* Go through all channels in the list */
4394 if (silc_idcache_get_all(id_list->channels, &list)) {
4395 if (silc_idcache_list_first(list, &id_cache)) {
4397 channel = (SilcChannelEntry)id_cache->context;
4399 if (creation_time && channel->created < creation_time)
4404 cid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
4405 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
4406 name_len = strlen(channel->channel_name);
4409 len = 4 + name_len + id_len + 4;
4411 silc_buffer_realloc(*channels,
4412 (*channels ? (*channels)->truelen +
4414 silc_buffer_pull_tail(*channels,
4415 ((*channels)->end - (*channels)->data));
4416 silc_buffer_format(*channels,
4417 SILC_STR_UI_SHORT(name_len),
4418 SILC_STR_UI_XNSTRING(channel->channel_name,
4420 SILC_STR_UI_SHORT(id_len),
4421 SILC_STR_UI_XNSTRING(cid, id_len),
4422 SILC_STR_UI_INT(channel->mode),
4424 silc_buffer_pull(*channels, len);
4427 if (creation_time && channel->updated < creation_time)
4433 /* Channel user modes */
4434 *channel_users_modes = silc_realloc(*channel_users_modes,
4435 sizeof(**channel_users_modes) *
4437 (*channel_users_modes)[i] = NULL;
4438 *channel_modes = silc_realloc(*channel_modes,
4439 sizeof(**channel_modes) * (i + 1));
4440 (*channel_modes)[i] = NULL;
4441 *channel_ids = silc_realloc(*channel_ids,
4442 sizeof(**channel_ids) * (i + 1));
4443 (*channel_ids)[i] = NULL;
4444 silc_server_announce_get_channel_users(server, channel,
4445 &(*channel_modes)[i],
4447 &(*channel_users_modes)[i]);
4448 (*channel_ids)[i] = channel->id;
4450 /* Channel's topic */
4451 *channel_topics = silc_realloc(*channel_topics,
4452 sizeof(**channel_topics) * (i + 1));
4453 (*channel_topics)[i] = NULL;
4454 silc_server_announce_get_channel_topic(server, channel,
4455 &(*channel_topics)[i]);
4456 (*channel_users_modes_c)++;
4463 if (!silc_idcache_list_next(list, &id_cache))
4468 silc_idcache_list_free(list);
4472 /* This function is used to announce our existing channels to our router
4473 when we've connected to it. This also announces the users on the
4474 channels to the router. If the `creation_time' is non-zero only the
4475 channels that was created after the `creation_time' are announced.
4476 Note that the channel users are still announced even if the `creation_time'
4479 void silc_server_announce_channels(SilcServer server,
4480 unsigned long creation_time,
4481 SilcSocketConnection remote)
4483 SilcBuffer channels = NULL, *channel_modes = NULL, channel_users = NULL;
4484 SilcBuffer *channel_users_modes = NULL;
4485 SilcBuffer *channel_topics = NULL;
4486 SilcUInt32 channel_users_modes_c = 0;
4487 SilcChannelID **channel_ids = NULL;
4489 SILC_LOG_DEBUG(("Announcing channels and channel users"));
4491 /* Get channels and channel users in local list */
4492 silc_server_announce_get_channels(server, server->local_list,
4493 &channels, &channel_modes,
4495 &channel_users_modes,
4496 &channel_users_modes_c,
4498 &channel_ids, creation_time);
4500 /* Get channels and channel users in global list */
4501 if (server->server_type != SILC_SERVER)
4502 silc_server_announce_get_channels(server, server->global_list,
4503 &channels, &channel_modes,
4505 &channel_users_modes,
4506 &channel_users_modes_c,
4508 &channel_ids, creation_time);
4511 silc_buffer_push(channels, channels->data - channels->head);
4512 SILC_LOG_HEXDUMP(("channels"), channels->data, channels->len);
4514 /* Send the packet */
4515 silc_server_packet_send(server, remote,
4516 SILC_PACKET_NEW_CHANNEL, SILC_PACKET_FLAG_LIST,
4517 channels->data, channels->len,
4520 silc_buffer_free(channels);
4523 if (channel_users) {
4524 silc_buffer_push(channel_users, channel_users->data - channel_users->head);
4525 SILC_LOG_HEXDUMP(("channel users"), channel_users->data,
4526 channel_users->len);
4528 /* Send the packet */
4529 silc_server_packet_send(server, remote,
4530 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4531 channel_users->data, channel_users->len,
4534 silc_buffer_free(channel_users);
4537 if (channel_modes) {
4540 for (i = 0; i < channel_users_modes_c; i++) {
4541 if (!channel_modes[i])
4543 silc_buffer_push(channel_modes[i],
4544 channel_modes[i]->data -
4545 channel_modes[i]->head);
4546 SILC_LOG_HEXDUMP(("channel modes"), channel_modes[i]->data,
4547 channel_modes[i]->len);
4548 silc_server_packet_send_dest(server, remote,
4549 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4550 channel_ids[i], SILC_ID_CHANNEL,
4551 channel_modes[i]->data,
4552 channel_modes[i]->len,
4554 silc_buffer_free(channel_modes[i]);
4556 silc_free(channel_modes);
4559 if (channel_users_modes) {
4562 for (i = 0; i < channel_users_modes_c; i++) {
4563 if (!channel_users_modes[i])
4565 silc_buffer_push(channel_users_modes[i],
4566 channel_users_modes[i]->data -
4567 channel_users_modes[i]->head);
4568 SILC_LOG_HEXDUMP(("channel users modes"), channel_users_modes[i]->data,
4569 channel_users_modes[i]->len);
4570 silc_server_packet_send_dest(server, remote,
4571 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4572 channel_ids[i], SILC_ID_CHANNEL,
4573 channel_users_modes[i]->data,
4574 channel_users_modes[i]->len,
4576 silc_buffer_free(channel_users_modes[i]);
4578 silc_free(channel_users_modes);
4581 if (channel_topics) {
4584 for (i = 0; i < channel_users_modes_c; i++) {
4585 if (!channel_topics[i])
4588 silc_buffer_push(channel_topics[i],
4589 channel_topics[i]->data -
4590 channel_topics[i]->head);
4591 SILC_LOG_HEXDUMP(("channel topic"), channel_topics[i]->data,
4592 channel_topics[i]->len);
4593 silc_server_packet_send_dest(server, remote,
4594 SILC_PACKET_NOTIFY, SILC_PACKET_FLAG_LIST,
4595 channel_ids[i], SILC_ID_CHANNEL,
4596 channel_topics[i]->data,
4597 channel_topics[i]->len,
4599 silc_buffer_free(channel_topics[i]);
4601 silc_free(channel_topics);
4604 silc_free(channel_ids);
4607 /* Assembles user list and users mode list from the `channel'. */
4609 bool silc_server_get_users_on_channel(SilcServer server,
4610 SilcChannelEntry channel,
4611 SilcBuffer *user_list,
4612 SilcBuffer *mode_list,
4613 SilcUInt32 *user_count)
4615 SilcChannelClientEntry chl;
4616 SilcHashTableList htl;
4617 SilcBuffer client_id_list;
4618 SilcBuffer client_mode_list;
4620 SilcUInt32 list_count = 0, len = 0;
4622 if (!silc_hash_table_count(channel->user_list))
4625 silc_hash_table_list(channel->user_list, &htl);
4626 while (silc_hash_table_get(&htl, NULL, (void *)&chl))
4627 len += (silc_id_get_len(chl->client->id, SILC_ID_CLIENT) + 4);
4628 silc_hash_table_list_reset(&htl);
4630 client_id_list = silc_buffer_alloc(len);
4632 silc_buffer_alloc(4 * silc_hash_table_count(channel->user_list));
4633 silc_buffer_pull_tail(client_id_list, SILC_BUFFER_END(client_id_list));
4634 silc_buffer_pull_tail(client_mode_list, SILC_BUFFER_END(client_mode_list));
4636 silc_hash_table_list(channel->user_list, &htl);
4637 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4639 idp = silc_id_payload_encode(chl->client->id, SILC_ID_CLIENT);
4640 silc_buffer_put(client_id_list, idp->data, idp->len);
4641 silc_buffer_pull(client_id_list, idp->len);
4642 silc_buffer_free(idp);
4644 /* Client's mode on channel */
4645 SILC_PUT32_MSB(chl->mode, client_mode_list->data);
4646 silc_buffer_pull(client_mode_list, 4);
4650 silc_hash_table_list_reset(&htl);
4651 silc_buffer_push(client_id_list,
4652 client_id_list->data - client_id_list->head);
4653 silc_buffer_push(client_mode_list,
4654 client_mode_list->data - client_mode_list->head);
4656 *user_list = client_id_list;
4657 *mode_list = client_mode_list;
4658 *user_count = list_count;
4662 /* Saves users and their modes to the `channel'. */
4664 void silc_server_save_users_on_channel(SilcServer server,
4665 SilcSocketConnection sock,
4666 SilcChannelEntry channel,
4667 SilcClientID *noadd,
4668 SilcBuffer user_list,
4669 SilcBuffer mode_list,
4670 SilcUInt32 user_count)
4675 SilcClientID *client_id;
4676 SilcClientEntry client;
4677 SilcIDCacheEntry cache;
4678 SilcChannelClientEntry chl;
4680 SILC_LOG_DEBUG(("Saving %d users on %s channel", user_count,
4681 channel->channel_name));
4683 for (i = 0; i < user_count; i++) {
4685 SILC_GET16_MSB(idp_len, user_list->data + 2);
4687 client_id = silc_id_payload_parse_id(user_list->data, idp_len, NULL);
4688 silc_buffer_pull(user_list, idp_len);
4693 SILC_GET32_MSB(mode, mode_list->data);
4694 silc_buffer_pull(mode_list, 4);
4696 if (noadd && SILC_ID_CLIENT_COMPARE(client_id, noadd)) {
4697 silc_free(client_id);
4703 /* Check if we have this client cached already. */
4704 client = silc_idlist_find_client_by_id(server->local_list, client_id,
4705 server->server_type, &cache);
4707 client = silc_idlist_find_client_by_id(server->global_list,
4708 client_id, server->server_type,
4711 /* If router did not find such Client ID in its lists then this must
4712 be bogus client or some router in the net is buggy. */
4713 if (server->server_type != SILC_SERVER) {
4714 silc_free(client_id);
4718 /* We don't have that client anywhere, add it. The client is added
4719 to global list since server didn't have it in the lists so it must be
4721 client = silc_idlist_add_client(server->global_list, NULL, NULL, NULL,
4722 silc_id_dup(client_id, SILC_ID_CLIENT),
4723 sock->user_data, NULL, 0);
4725 SILC_LOG_ERROR(("Could not add new client to the ID Cache"));
4726 silc_free(client_id);
4730 client->data.status |= SILC_IDLIST_STATUS_REGISTERED;
4735 silc_free(client_id);
4737 if (!(client->data.status & SILC_IDLIST_STATUS_REGISTERED)) {
4738 SILC_LOG_ERROR(("Attempting to add unregistered client to channel ",
4739 "%s", channel->channel_name));
4743 if (!silc_server_client_on_channel(client, channel, &chl)) {
4744 /* Client was not on the channel, add it. */
4745 chl = silc_calloc(1, sizeof(*chl));
4746 chl->client = client;
4748 chl->channel = channel;
4749 silc_hash_table_add(channel->user_list, chl->client, chl);
4750 silc_hash_table_add(client->channels, chl->channel, chl);
4751 channel->user_count++;
4759 /* Saves channels and channels user modes to the `client'. Removes
4760 the client from those channels that are not sent in the list but
4763 void silc_server_save_user_channels(SilcServer server,
4764 SilcSocketConnection sock,
4765 SilcClientEntry client,
4766 SilcBuffer channels,
4767 SilcBuffer channels_user_modes)
4770 SilcUInt32 *chumodes;
4771 SilcChannelPayload entry;
4772 SilcChannelEntry channel;
4773 SilcChannelID *channel_id;
4774 SilcChannelClientEntry chl;
4775 SilcHashTable ht = NULL;
4776 SilcHashTableList htl;
4780 if (!channels || !channels_user_modes ||
4781 !(client->data.status & SILC_IDLIST_STATUS_REGISTERED))
4784 ch = silc_channel_payload_parse_list(channels->data, channels->len);
4785 if (ch && silc_get_mode_list(channels_user_modes, silc_dlist_count(ch),
4787 ht = silc_hash_table_alloc(0, silc_hash_ptr, NULL, NULL,
4788 NULL, NULL, NULL, TRUE);
4789 silc_dlist_start(ch);
4790 while ((entry = silc_dlist_get(ch)) != SILC_LIST_END) {
4791 /* Check if we have this channel, and add it if we don't have it.
4792 Also add the client on the channel unless it is there already. */
4793 channel_id = silc_channel_get_id_parse(entry);
4794 channel = silc_idlist_find_channel_by_id(server->local_list,
4797 channel = silc_idlist_find_channel_by_id(server->global_list,
4800 if (server->server_type != SILC_SERVER) {
4801 silc_free(channel_id);
4806 /* We don't have that channel anywhere, add it. */
4807 name = silc_channel_get_name(entry, NULL);
4808 channel = silc_idlist_add_channel(server->global_list, strdup(name), 0,
4809 channel_id, server->router,
4812 silc_free(channel_id);
4819 channel->mode = silc_channel_get_mode(entry);
4821 /* Add the client on the channel */
4822 if (!silc_server_client_on_channel(client, channel, &chl)) {
4823 chl = silc_calloc(1, sizeof(*chl));
4824 chl->client = client;
4825 chl->mode = chumodes[i++];
4826 chl->channel = channel;
4827 silc_hash_table_add(channel->user_list, chl->client, chl);
4828 silc_hash_table_add(client->channels, chl->channel, chl);
4829 channel->user_count++;
4832 chl->mode = chumodes[i++];
4835 silc_hash_table_add(ht, channel, channel);
4836 silc_free(channel_id);
4838 silc_channel_payload_list_free(ch);
4839 silc_free(chumodes);
4843 /* Go through the list again and remove client from channels that
4844 are no part of the list. */
4846 silc_hash_table_list(client->channels, &htl);
4847 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
4848 if (!silc_hash_table_find(ht, chl->channel, NULL, NULL)) {
4849 silc_hash_table_del(chl->channel->user_list, chl->client);
4850 silc_hash_table_del(chl->client->channels, chl->channel);
4854 silc_hash_table_list_reset(&htl);
4855 silc_hash_table_free(ht);
4857 silc_hash_table_list(client->channels, &htl);
4858 while (silc_hash_table_get(&htl, NULL, (void **)&chl)) {
4859 silc_hash_table_del(chl->channel->user_list, chl->client);
4860 silc_hash_table_del(chl->client->channels, chl->channel);
4863 silc_hash_table_list_reset(&htl);
4867 /* Lookups route to the client indicated by the `id_data'. The connection
4868 object and internal data object is returned. Returns NULL if route
4869 could not be found to the client. If the `client_id' is specified then
4870 it is used and the `id_data' is ignored. */
4872 SilcSocketConnection
4873 silc_server_get_client_route(SilcServer server,
4874 unsigned char *id_data,
4876 SilcClientID *client_id,
4877 SilcIDListData *idata,
4878 SilcClientEntry *client_entry)
4881 SilcClientEntry client;
4883 SILC_LOG_DEBUG(("Start"));
4886 *client_entry = NULL;
4888 /* Decode destination Client ID */
4890 id = silc_id_str2id(id_data, id_len, SILC_ID_CLIENT);
4892 SILC_LOG_ERROR(("Could not decode destination Client ID, dropped"));
4896 id = silc_id_dup(client_id, SILC_ID_CLIENT);
4899 /* If the destination belongs to our server we don't have to route
4900 the packet anywhere but to send it to the local destination. */
4901 client = silc_idlist_find_client_by_id(server->local_list, id, TRUE, NULL);
4905 /* If we are router and the client has router then the client is in
4906 our cell but not directly connected to us. */
4907 if (server->server_type == SILC_ROUTER && client->router) {
4908 /* We are of course in this case the client's router thus the route
4909 to the client is the server who owns the client. So, we will send
4910 the packet to that server. */
4912 *idata = (SilcIDListData)client->router;
4913 return client->router->connection;
4916 /* Seems that client really is directly connected to us */
4918 *idata = (SilcIDListData)client;
4920 *client_entry = client;
4921 return client->connection;
4924 /* Destination belongs to someone not in this server. If we are normal
4925 server our action is to send the packet to our router. */
4926 if (server->server_type != SILC_ROUTER && !server->standalone) {
4929 *idata = (SilcIDListData)server->router;
4930 return SILC_PRIMARY_ROUTE(server);
4933 /* We are router and we will perform route lookup for the destination
4934 and send the packet to fastest route. */
4935 if (server->server_type == SILC_ROUTER && !server->standalone) {
4936 /* Check first that the ID is valid */
4937 client = silc_idlist_find_client_by_id(server->global_list, id,
4940 SilcSocketConnection dst_sock;
4942 dst_sock = silc_server_route_get(server, id, SILC_ID_CLIENT);
4946 *idata = (SilcIDListData)dst_sock->user_data;
4955 /* Encodes and returns channel list of channels the `client' has joined.
4956 Secret channels are not put to the list. */
4958 SilcBuffer silc_server_get_client_channel_list(SilcServer server,
4959 SilcClientEntry client,
4962 SilcBuffer *user_mode_list)
4964 SilcBuffer buffer = NULL;
4965 SilcChannelEntry channel;
4966 SilcChannelClientEntry chl;
4967 SilcHashTableList htl;
4970 SilcUInt16 name_len;
4974 *user_mode_list = NULL;
4976 silc_hash_table_list(client->channels, &htl);
4977 while (silc_hash_table_get(&htl, NULL, (void *)&chl)) {
4978 channel = chl->channel;
4980 if (channel->mode & SILC_CHANNEL_MODE_SECRET && !get_secret)
4982 if (channel->mode & SILC_CHANNEL_MODE_PRIVATE && !get_private)
4985 cid = silc_id_id2str(channel->id, SILC_ID_CHANNEL);
4986 id_len = silc_id_get_len(channel->id, SILC_ID_CHANNEL);
4987 name_len = strlen(channel->channel_name);
4989 len = 4 + name_len + id_len + 4;
4990 buffer = silc_buffer_realloc(buffer,
4991 (buffer ? buffer->truelen + len : len));
4992 silc_buffer_pull_tail(buffer, (buffer->end - buffer->data));
4993 silc_buffer_format(buffer,
4994 SILC_STR_UI_SHORT(name_len),
4995 SILC_STR_UI_XNSTRING(channel->channel_name,
4997 SILC_STR_UI_SHORT(id_len),
4998 SILC_STR_UI_XNSTRING(cid, id_len),
4999 SILC_STR_UI_INT(chl->channel->mode),
5001 silc_buffer_pull(buffer, len);
5004 if (user_mode_list) {
5005 *user_mode_list = silc_buffer_realloc(*user_mode_list,
5007 (*user_mode_list)->truelen + 4 :
5009 silc_buffer_pull_tail(*user_mode_list, ((*user_mode_list)->end -
5010 (*user_mode_list)->data));
5011 SILC_PUT32_MSB(chl->mode, (*user_mode_list)->data);
5012 silc_buffer_pull(*user_mode_list, 4);
5015 silc_hash_table_list_reset(&htl);
5018 silc_buffer_push(buffer, buffer->data - buffer->head);
5019 if (user_mode_list && *user_mode_list)
5020 silc_buffer_push(*user_mode_list, ((*user_mode_list)->data -
5021 (*user_mode_list)->head));
5026 /* A timeout callback for the re-key. We will be the initiator of the
5029 SILC_TASK_CALLBACK_GLOBAL(silc_server_rekey_callback)
5031 SilcServer server = app_context;
5032 SilcSocketConnection sock = (SilcSocketConnection)context;
5033 SilcIDListData idata = (SilcIDListData)sock->user_data;
5034 SilcProtocol protocol;
5035 SilcServerRekeyInternalContext *proto_ctx;
5037 /* Allocate internal protocol context. This is sent as context
5039 proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
5040 proto_ctx->server = (void *)server;
5041 proto_ctx->sock = sock;
5042 proto_ctx->responder = FALSE;
5043 proto_ctx->pfs = idata->rekey->pfs;
5045 /* Perform rekey protocol. Will call the final callback after the
5046 protocol is over. */
5047 silc_protocol_alloc(SILC_PROTOCOL_SERVER_REKEY,
5048 &protocol, proto_ctx, silc_server_rekey_final);
5049 sock->protocol = protocol;
5051 /* Run the protocol */
5052 silc_protocol_execute(protocol, server->schedule, 0, 0);
5054 SILC_LOG_DEBUG(("Rekey protocol completed"));
5056 /* Re-register re-key timeout */
5057 silc_schedule_task_add(server->schedule, sock->sock,
5058 silc_server_rekey_callback,
5059 context, idata->rekey->timeout, 0,
5060 SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
5063 /* The final callback for the REKEY protocol. This will actually take the
5064 new key material into use. */
5066 SILC_TASK_CALLBACK_GLOBAL(silc_server_rekey_final)
5068 SilcProtocol protocol = (SilcProtocol)context;
5069 SilcServerRekeyInternalContext *ctx =
5070 (SilcServerRekeyInternalContext *)protocol->context;
5071 SilcServer server = (SilcServer)ctx->server;
5072 SilcSocketConnection sock = ctx->sock;
5074 SILC_LOG_DEBUG(("Start"));
5076 if (protocol->state == SILC_PROTOCOL_STATE_ERROR ||
5077 protocol->state == SILC_PROTOCOL_STATE_FAILURE) {
5078 /* Error occured during protocol */
5079 SILC_LOG_ERROR(("Error occurred during rekey protocol with "
5080 "%s (%s)", sock->hostname, sock->ip));
5081 silc_protocol_cancel(protocol, server->schedule);
5082 silc_protocol_free(protocol);
5083 sock->protocol = NULL;
5085 silc_packet_context_free(ctx->packet);
5087 silc_ske_free(ctx->ske);
5091 SILC_SET_DISCONNECTING(sock);
5092 server->backup_noswitch = TRUE;
5093 if (sock->user_data)
5094 silc_server_free_sock_user_data(server, sock, NULL);
5095 silc_server_close_connection(server, sock);
5096 silc_server_create_connections(server);
5100 /* Purge the outgoing data queue to assure that all rekey packets really
5101 go to the network before we quit the protocol. */
5102 silc_server_packet_queue_purge(server, sock);
5105 silc_protocol_free(protocol);
5106 sock->protocol = NULL;
5108 silc_packet_context_free(ctx->packet);
5110 silc_ske_free(ctx->ske);
5114 /* Task callback used to retrieve network statistical information from
5115 router server once in a while. */
5117 SILC_TASK_CALLBACK(silc_server_get_stats)
5119 SilcServer server = (SilcServer)context;
5120 SilcBuffer idp, packet;
5122 SILC_LOG_DEBUG(("Retrieving stats from router"));
5124 if (!server->standalone) {
5125 idp = silc_id_payload_encode(server->router->id, SILC_ID_SERVER);
5126 packet = silc_command_payload_encode_va(SILC_COMMAND_STATS,
5127 ++server->cmd_ident, 1,
5128 1, idp->data, idp->len);
5129 silc_server_packet_send(server, SILC_PRIMARY_ROUTE(server),
5130 SILC_PACKET_COMMAND, 0, packet->data,
5131 packet->len, FALSE);
5132 silc_buffer_free(packet);
5133 silc_buffer_free(idp);
5136 silc_schedule_task_add(server->schedule, 0, silc_server_get_stats,
5137 server, 120, 0, SILC_TASK_TIMEOUT,