int i;
if (!server->backup)
- return ;
+ return;
for (i = 0; i < server->backup->servers_count; i++) {
if (server->backup->servers[i].server == server_entry) {
}
}
+/* Frees all data allocated for backup routers. Call this after deleting
+ all backup routers and when new routers are added no more, for example
+ when shutting down the server. */
+
+void silc_server_backup_free(SilcServer server)
+{
+ int i;
+
+ if (!server->backup)
+ return;
+
+ /* Delete existing servers if caller didn't do it */
+ for (i = 0; i < server->backup->servers_count; i++) {
+ if (server->backup->servers[i].server)
+ silc_server_backup_del(server, server->backup->servers[i].server);
+ }
+
+ silc_free(server->backup->servers);
+ silc_free(server->backup);
+ server->backup = NULL;
+}
+
/* Marks the IP address and port from the `server_id' as being replaced
by backup router indicated by the `server'. If the router connects at
a later time we can check whether it has been replaced by an backup
for (i = 0; i < server->backup->servers_count; i++) {
backup = server->backup->servers[i].server;
- if (!backup)
+ if (!backup || sender == backup)
continue;
-
- if (sender == backup)
- continue;
-
if (local && server->backup->servers[i].local == FALSE)
continue;
if (server->backup->servers[i].server == server->id_entry)
for (i = 0; i < server->backup->servers_count; i++) {
backup = server->backup->servers[i].server;
- if (!backup)
+ if (!backup || sender == backup)
continue;
-
- if (sender == backup)
- continue;
-
if (local && server->backup->servers[i].local == FALSE)
continue;
if (server->backup->servers[i].server == server->id_entry)
SILC_STR_UI_CHAR(&session),
SILC_STR_END);
if (ret < 0) {
- SILC_LOG_DEBUG(("Malformed packet received"));
+ SILC_LOG_ERROR(("Malformed resume router packet received"));
return;
}
return;
}
- SILC_LOG_DEBUG(("Bad resume router packet"));
+ SILC_LOG_ERROR(("Bad resume router packet RESUMED %d", type));
return;
}
proto_ctx->start = time(0);
SILC_LOG_DEBUG(("Starting backup resuming protocol as responder"));
+ SILC_LOG_INFO(("Starting backup resuming protocol"));
/* Run the backup resuming protocol */
silc_protocol_alloc(SILC_PROTOCOL_SERVER_BACKUP,
SILC_TASK_CALLBACK(silc_server_backup_connect_to_router)
{
+ SilcServer server = app_context;
SilcServerConnection sconn = (SilcServerConnection)context;
- SilcServer server = sconn->server;
int sock;
const char *server_ip;
{
SilcServerConnection sconn;
+ SILC_LOG_INFO(("Attempting to reconnect to primary router"));
+
sconn = silc_calloc(1, sizeof(*sconn));
- sconn->server = server;
sconn->remote_host = strdup(ip);
sconn->remote_port = port;
sconn->callback = callback;
SilcSocketConnection sock = proto_ctx->sock;
SILC_LOG_DEBUG(("Starting backup resuming protocol as initiator"));
+ SILC_LOG_INFO(("Starting backup resuming protocol"));
/* Run the backup resuming protocol */
silc_protocol_alloc(SILC_PROTOCOL_SERVER_BACKUP,
silc_buffer_free(packet);
- /* Announce all of our information */
- silc_server_announce_servers(server, TRUE, 0, ctx->sock);
- silc_server_announce_clients(server, 0, ctx->sock);
- silc_server_announce_channels(server, 0, ctx->sock);
+ /* If we are not standalone and our primary is not the one we've
+ talking to now, then announce our information to it since we
+ haven't done that yet. Standalone backup router announces
+ these during connecting to the primary. */
+ if (!server->standalone && SILC_PRIMARY_ROUTE(server) != ctx->sock) {
+ silc_server_announce_servers(server, TRUE, 0, ctx->sock);
+ silc_server_announce_clients(server, 0, ctx->sock);
+ silc_server_announce_channels(server, 0, ctx->sock);
+ }
protocol->state++;
} else {
/* We should have received START or START_GLOBAL packet */
if (ctx->type != SILC_SERVER_BACKUP_START &&
ctx->type != SILC_SERVER_BACKUP_START_GLOBAL) {
- SILC_LOG_DEBUG(("Bad resume router packet"));
+ SILC_LOG_ERROR(("Bad resume router packet START %d", ctx->type));
break;
}
/* We should have received CONNECTED packet */
if (ctx->type != SILC_SERVER_BACKUP_CONNECTED) {
- SILC_LOG_DEBUG(("Bad resume router packet"));
+ SILC_LOG_ERROR(("Bad resume router packet CONNECTED %d", ctx->type));
break;
}
/* We should have been received ENDING packet */
if (ctx->type != SILC_SERVER_BACKUP_ENDING) {
- SILC_LOG_DEBUG(("Bad resume router packet"));
+ SILC_LOG_ERROR(("Bad resume router packet ENDING %d", ctx->type));
break;
}
silc_server_update_servers_by_server(server, ctx->sock->user_data,
server->router);
silc_server_update_clients_by_server(server, ctx->sock->user_data,
- server->router, TRUE, FALSE);
+ server->router, TRUE);
if (server->server_type == SILC_SERVER)
silc_server_update_channels_by_server(server, ctx->sock->user_data,
server->router);
silc_buffer_free(packet);
SILC_LOG_INFO(("We are now the primary router of our cell again"));
+ server->wait_backup = FALSE;
/* For us this is the end of this protocol. */
if (protocol->final_callback)
router. */
if (ctx->type != SILC_SERVER_BACKUP_RESUMED &&
ctx->type != SILC_SERVER_BACKUP_RESUMED_GLOBAL) {
- SILC_LOG_DEBUG(("Bad resume router packet"));
+ SILC_LOG_ERROR(("Bad resume router packet RESUMED %d", ctx->type));
break;
}
/* We have new primary router now */
server->id_entry->router = router;
server->router = router;
- server->router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
-
SILC_LOG_INFO(("Switching back to primary router %s",
server->router->server_name));
} else {
/* We are connected to new primary and now continue using it */
- router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
SILC_LOG_INFO(("Resuming the use of primary router %s",
router->server_name));
}
/* Update the client entries of the backup router to the new
router */
silc_server_local_servers_toggle_enabled(server, FALSE);
+ router->data.status &= ~SILC_IDLIST_STATUS_DISABLED;
silc_server_update_servers_by_server(server, backup_router, router);
- silc_server_update_clients_by_server(server, NULL, router,
- FALSE, FALSE);
+ silc_server_update_clients_by_server(server, NULL, router, FALSE);
if (server->server_type == SILC_SERVER)
silc_server_update_channels_by_server(server, backup_router, router);
silc_server_backup_replaced_del(server, backup_router);
/* Announce all of our information to the router. */
if (server->server_type == SILC_ROUTER)
- silc_server_announce_servers(server, FALSE, 0, router->connection);
+ silc_server_announce_servers(server, FALSE, ctx->start,
+ router->connection);
/* Announce our clients and channels to the router */
- silc_server_announce_clients(server, 0, router->connection);
- silc_server_announce_channels(server, 0, router->connection);
+ silc_server_announce_clients(server, ctx->start,
+ router->connection);
+ silc_server_announce_channels(server, ctx->start,
+ router->connection);
}
/* Send notify about primary router going down to local operators */
case SILC_PROTOCOL_STATE_FAILURE:
/* Protocol has ended, call the final callback */
+ SILC_LOG_ERROR(("Error during backup resume: received Failure"));
if (protocol->final_callback)
silc_protocol_execute_final(protocol, server->schedule);
else
server_entry = (SilcServerEntry)id_cache->context;
sock = (SilcSocketConnection)server_entry->connection;
- /* XXXX */
- if (!sock) {
- SILC_LOG_DEBUG(("******** REMOVE THIS TEST, IT ALLOWS A BUG"));
- if (!silc_idcache_list_next(list, &id_cache))
- break;
- continue;
- }
-
if (sock->protocol == protocol) {
sock->protocol = NULL;
server_entry = (SilcServerEntry)id_cache->context;
sock = (SilcSocketConnection)server_entry->connection;
- /* XXXX */
- if (!sock) {
- SILC_LOG_DEBUG(("******** REMOVE THIS TEST, IT ALLOWS A BUG"));
- if (!silc_idcache_list_next(list, &id_cache))
- break;
- continue;
- }
-
if (sock->protocol == protocol) {
sock->protocol = NULL;