X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=apps%2Fsilcd%2Fprotocol.c;h=170120f696c98007627aa1a7394628185b8ecf59;hp=88de68d42d742760b1cbcdd1430355e54ce637ad;hb=e5d8d3db6caa344b3d419b884556c21b15e7d123;hpb=72c7b823b3aa22af4f0c206e76e3fdabaf2ed7a6 diff --git a/apps/silcd/protocol.c b/apps/silcd/protocol.c index 88de68d4..170120f6 100644 --- a/apps/silcd/protocol.c +++ b/apps/silcd/protocol.c @@ -2,7 +2,7 @@ protocol.c - Author: Pekka Riikonen + Author: Pekka Riikonen Copyright (C) 1997 - 2001 Pekka Riikonen @@ -280,13 +280,19 @@ int silc_server_protocol_ke_set_keys(SilcSKE ske, sock->user_data = (void *)conn_data; + SILC_LOG_INFO(("%s (%s) security properties: %s %s %s", + sock->hostname, sock->ip, + idata->send_key->cipher->name, + idata->hmac_send->hmac->name, + idata->hash->hash->name)); + return TRUE; } /* Check remote host version string */ SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version, - uint32 len) + uint32 len, void *context) { SilcSKEStatus status = SILC_SKE_STATUS_OK; char *cp; @@ -335,7 +341,7 @@ SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version, if (maj != maj2) status = SILC_SKE_STATUS_BAD_VERSION; - if (min < min2) + if (min > min2) status = SILC_SKE_STATUS_BAD_VERSION; return status; @@ -359,20 +365,20 @@ static void silc_server_protocol_ke_continue(SilcSKE ske, void *context) SILC_LOG_DEBUG(("Start")); if (ske->status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol", - ske->status)); - SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol", - ske->status)); + SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(ske->status))); + SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(ske->status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } /* Send Ok to the other end. We will end the protocol as responder sends Ok to us when we will take the new keys into use. */ if (ctx->responder == FALSE) { - silc_ske_end(ctx->ske, silc_server_protocol_ke_send_packet, context); + silc_ske_end(ctx->ske); /* End the protocol on the next round */ protocol->state = SILC_PROTOCOL_STATE_END; @@ -383,7 +389,7 @@ static void silc_server_protocol_ke_continue(SilcSKE ske, void *context) function. */ if (ctx->responder == TRUE) { protocol->state++; - silc_protocol_execute(protocol, server->timeout_queue, 0, 100000); + silc_protocol_execute(protocol, server->schedule, 0, 100000); } } @@ -419,13 +425,17 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) ctx->ske = ske; ske->rng = server->rng; + silc_ske_set_callbacks(ske, silc_server_protocol_ke_send_packet, NULL, + silc_server_protocol_ke_verify_key, + silc_server_protocol_ke_continue, + silc_ske_check_version, context); + if (ctx->responder == TRUE) { /* Start the key exchange by processing the received security properties packet from initiator. */ status = silc_ske_responder_start(ske, ctx->rng, ctx->sock, silc_version_string, - ctx->packet->buffer, FALSE, - NULL, NULL); + ctx->packet->buffer, FALSE); } else { SilcSKEStartPayload *start_payload; @@ -437,9 +447,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) /* Start the key exchange by sending our security properties to the remote end. */ status = silc_ske_initiator_start(ske, ctx->rng, ctx->sock, - start_payload, - silc_server_protocol_ke_send_packet, - context); + start_payload); } /* Return now if the procedure is pending. */ @@ -447,20 +455,20 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) return; if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol", - status)); - SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol", - status)); + SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); + SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } /* Advance protocol state and call the next state if we are responder */ protocol->state++; if (ctx->responder == TRUE) - silc_protocol_execute(protocol, server->timeout_queue, 0, 100000); + silc_protocol_execute(protocol, server->schedule, 0, 100000); } break; case 2: @@ -470,18 +478,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) */ if (ctx->responder == TRUE) { /* Sends the selected security properties to the initiator. */ - status = - silc_ske_responder_phase_1(ctx->ske, - ctx->ske->start_payload, - silc_server_protocol_ke_send_packet, - context); + status = silc_ske_responder_phase_1(ctx->ske, + ctx->ske->start_payload); } else { /* Call Phase-1 function. This processes the Key Exchange Start paylaod reply we just got from the responder. The callback function will receive the processed payload where we will save it. */ - status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer, - NULL, NULL); + status = silc_ske_initiator_phase_1(ctx->ske, ctx->packet->buffer); } /* Return now if the procedure is pending. */ @@ -489,20 +493,20 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) return; if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol", - status)); - SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol", - status)); + SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); + SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } /* Advance protocol state and call next state if we are initiator */ protocol->state++; if (ctx->responder == FALSE) - silc_protocol_execute(protocol, server->timeout_queue, 0, 100000); + silc_protocol_execute(protocol, server->schedule, 0, 100000); } break; case 3: @@ -515,22 +519,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) the initiator. This also creates our parts of the Diffie Hellman algorithm. The silc_server_protocol_ke_continue will be called after the public key has been verified. */ - status = - silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer, - silc_server_protocol_ke_verify_key, - context, - silc_server_protocol_ke_continue, - context); + status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer); } else { /* Call the Phase-2 function. This creates Diffie Hellman key exchange parameters and sends our public part inside Key Exhange 1 Payload to the responder. */ - status = - silc_ske_initiator_phase_2(ctx->ske, - server->public_key, - server->private_key, - silc_server_protocol_ke_send_packet, - context); + status = silc_ske_initiator_phase_2(ctx->ske, + server->public_key, + server->private_key); protocol->state++; } @@ -539,13 +535,13 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) return; if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol", - status)); - SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol", - status)); + SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); + SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } } @@ -558,12 +554,10 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) if (ctx->responder == TRUE) { /* This creates the key exchange material and sends our public parts to the initiator inside Key Exchange 2 Payload. */ - status = - silc_ske_responder_finish(ctx->ske, - server->public_key, server->private_key, - SILC_SKE_PK_TYPE_SILC, - silc_server_protocol_ke_send_packet, - context); + status = silc_ske_responder_finish(ctx->ske, + server->public_key, + server->private_key, + SILC_SKE_PK_TYPE_SILC); /* End the protocol on the next round */ protocol->state = SILC_PROTOCOL_STATE_END; @@ -571,11 +565,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) /* Finish the protocol. This verifies the Key Exchange 2 payload sent by responder. The silc_server_protocol_ke_continue will be called after the public key has been verified. */ - status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer, - silc_server_protocol_ke_verify_key, - context, - silc_server_protocol_ke_continue, - context); + status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer); } /* Return now if the procedure is pending. */ @@ -583,13 +573,13 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) return; if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Key Exchange protocol", - status)); - SILC_LOG_DEBUG(("Error (type %d) during Key Exchange protocol", - status)); + SILC_LOG_WARNING(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); + SILC_LOG_DEBUG(("Error (%s) during Key Exchange protocol", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } } @@ -610,7 +600,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) keymat); if (status != SILC_SKE_STATUS_OK) { protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); silc_ske_free_key_material(keymat); return; } @@ -619,17 +609,17 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) /* Send Ok to the other end if we are responder. If we are initiator we have sent this already. */ if (ctx->responder == TRUE) - silc_ske_end(ctx->ske, silc_server_protocol_ke_send_packet, context); + silc_ske_end(ctx->ske); /* Unregister the timeout task since the protocol has ended. This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* Call the final callback */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); } @@ -641,19 +631,17 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) */ /* Send abort notification */ - silc_ske_abort(ctx->ske, ctx->ske->status, - silc_server_protocol_ke_send_packet, - context); + silc_ske_abort(ctx->ske, ctx->ske->status); /* Unregister the timeout task since the protocol has ended. This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -667,11 +655,11 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange) This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -730,7 +718,8 @@ silc_server_public_key_authentication(SilcServer server, SILC_STR_END); /* Verify signature */ - if (silc_pkcs_verify(pkcs, sign, sign_len, auth->data, auth->len)) { + if (silc_pkcs_verify_with_hash(pkcs, ske->prop->hash, sign, sign_len, + auth->data, auth->len)) { silc_pkcs_free(pkcs); silc_buffer_free(auth); return TRUE; @@ -743,7 +732,6 @@ silc_server_public_key_authentication(SilcServer server, static int silc_server_get_public_key_auth(SilcServer server, - SilcPublicKey pub_key, unsigned char *auth_data, uint32 *auth_data_len, SilcSKE ske) @@ -752,14 +740,7 @@ silc_server_get_public_key_auth(SilcServer server, SilcPKCS pkcs; SilcBuffer auth; - if (!pub_key) - return FALSE; - - silc_pkcs_alloc(pub_key->name, &pkcs); - if (!silc_pkcs_public_key_set(pkcs, pub_key)) { - silc_pkcs_free(pkcs); - return FALSE; - } + pkcs = server->pkcs; /* Make the authentication data. Protocol says it is HASH plus KE Start Payload. */ @@ -772,13 +753,12 @@ silc_server_get_public_key_auth(SilcServer server, ske->start_payload_copy->len), SILC_STR_END); - if (silc_pkcs_sign(pkcs, auth->data, auth->len, auth_data, auth_data_len)) { - silc_pkcs_free(pkcs); + if (silc_pkcs_sign_with_hash(pkcs, ske->prop->hash, auth->data, + auth->len, auth_data, auth_data_len)) { silc_buffer_free(auth); return TRUE; } - silc_pkcs_free(pkcs); silc_buffer_free(auth); return FALSE; } @@ -829,14 +809,14 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) if (ret == -1) { SILC_LOG_DEBUG(("Bad payload in authentication packet")); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } if (payload_len != ctx->packet->buffer->len) { SILC_LOG_DEBUG(("Bad payload in authentication packet")); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -846,7 +826,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) conn_type > SILC_SOCKET_TYPE_ROUTER) { SILC_LOG_ERROR(("Bad connection type %d", conn_type)); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -860,7 +840,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) if (ret == -1) { SILC_LOG_DEBUG(("Bad payload in authentication packet")); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } } @@ -898,7 +878,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; break; @@ -919,7 +899,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -929,7 +909,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_ERROR(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -960,7 +940,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; break; @@ -981,7 +961,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -990,7 +970,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_ERROR(("Remote connection not configured")); SILC_LOG_ERROR(("Authentication failed")); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); silc_free(auth_data); return; @@ -1022,7 +1002,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; break; @@ -1043,7 +1023,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_DEBUG(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -1053,7 +1033,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) SILC_LOG_ERROR(("Authentication failed")); silc_free(auth_data); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -1067,7 +1047,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) /* Advance protocol state. */ protocol->state = SILC_PROTOCOL_STATE_END; - silc_protocol_execute(protocol, server->timeout_queue, 0, 0); + silc_protocol_execute(protocol, server->schedule, 0, 0); } else { /* @@ -1099,8 +1079,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) unsigned char sign[1024]; /* Public key authentication */ - silc_server_get_public_key_auth(server, ctx->auth_data, - sign, &auth_data_len, + silc_server_get_public_key_auth(server, sign, &auth_data_len, ctx->ske); auth_data = silc_calloc(auth_data_len, sizeof(*auth_data)); memcpy(auth_data, sign, auth_data_len); @@ -1154,11 +1133,11 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* Protocol has ended, call the final callback */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); } @@ -1180,11 +1159,11 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); } @@ -1199,11 +1178,11 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth) This was the timeout task to be executed if the protocol is not completed fast enough. */ if (ctx->timeout_task) - silc_task_unregister(server->timeout_queue, ctx->timeout_task); + silc_schedule_task_del(server->schedule, ctx->timeout_task); /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -1390,7 +1369,8 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_1) { /* Error in protocol */ protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); + return; } ctx->ske = silc_ske_alloc(); @@ -1399,20 +1379,24 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) silc_ske_get_group_by_number(idata->rekey->ske_group, &ctx->ske->prop->group); - status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer, - NULL, NULL, NULL, NULL); + silc_ske_set_callbacks(ctx->ske, + silc_server_protocol_rekey_send_packet, + NULL, NULL, NULL, silc_ske_check_version, + context); + + status = silc_ske_responder_phase_2(ctx->ske, ctx->packet->buffer); if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)", - status)); + SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } /* Advance the protocol state */ protocol->state++; - silc_protocol_execute(protocol, server->timeout_queue, 0, 0); + silc_protocol_execute(protocol, server->schedule, 0, 0); } else { /* * Do normal and simple re-key. @@ -1451,17 +1435,18 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) silc_ske_get_group_by_number(idata->rekey->ske_group, &ctx->ske->prop->group); - status = - silc_ske_initiator_phase_2(ctx->ske, NULL, NULL, - silc_server_protocol_rekey_send_packet, - context); - + silc_ske_set_callbacks(ctx->ske, + silc_server_protocol_rekey_send_packet, + NULL, NULL, NULL, silc_ske_check_version, + context); + + status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL); if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)", - status)); + SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } @@ -1499,20 +1484,16 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) * Send our KE packe to the initiator now that we've processed * the initiator's KE packet. */ - status = - silc_ske_responder_finish(ctx->ske, NULL, NULL, - SILC_SKE_PK_TYPE_SILC, - silc_server_protocol_rekey_send_packet, - context); - - if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)", - status)); - - protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); - return; - } + status = silc_ske_responder_finish(ctx->ske, NULL, NULL, + SILC_SKE_PK_TYPE_SILC); + if (status != SILC_SKE_STATUS_OK) { + SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)", + silc_ske_map_status(status))); + + protocol->state = SILC_PROTOCOL_STATE_ERROR; + silc_protocol_execute(protocol, server->schedule, 0, 300000); + return; + } } } else { @@ -1523,17 +1504,17 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) if (ctx->packet->type != SILC_PACKET_KEY_EXCHANGE_2) { /* Error in protocol */ protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); + return; } - status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer, - NULL, NULL, NULL, NULL); + status = silc_ske_initiator_finish(ctx->ske, ctx->packet->buffer); if (status != SILC_SKE_STATUS_OK) { - SILC_LOG_WARNING(("Error (type %d) during Re-key (PFS)", - status)); + SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)", + silc_ske_map_status(status))); protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 300000); + silc_protocol_execute(protocol, server->schedule, 0, 300000); return; } } @@ -1561,7 +1542,8 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) if (ctx->packet->type != SILC_PACKET_REKEY_DONE) { /* Error in protocol */ protocol->state = SILC_PROTOCOL_STATE_ERROR; - silc_protocol_execute(protocol, server->timeout_queue, 0, 0); + silc_protocol_execute(protocol, server->schedule, 0, 300000); + return; } /* We received the REKEY_DONE packet and all packets after this is @@ -1570,7 +1552,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) /* Protocol has ended, call the final callback */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -1582,14 +1564,12 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) if (ctx->pfs == TRUE) { /* Send abort notification */ - silc_ske_abort(ctx->ske, ctx->ske->status, - silc_server_protocol_ke_send_packet, - context); + silc_ske_abort(ctx->ske, ctx->ske->status); } /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -1601,7 +1581,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey) /* On error the final callback is always called. */ if (protocol->final_callback) - silc_protocol_execute_final(protocol, server->timeout_queue); + silc_protocol_execute_final(protocol, server->schedule); else silc_protocol_free(protocol); break; @@ -1622,6 +1602,8 @@ void silc_server_protocols_register(void) silc_server_protocol_key_exchange); silc_protocol_register(SILC_PROTOCOL_SERVER_REKEY, silc_server_protocol_rekey); + silc_protocol_register(SILC_PROTOCOL_SERVER_BACKUP, + silc_server_protocol_backup); } /* Unregisters protocols */ @@ -1634,4 +1616,6 @@ void silc_server_protocols_unregister(void) silc_server_protocol_key_exchange); silc_protocol_unregister(SILC_PROTOCOL_SERVER_REKEY, silc_server_protocol_rekey); + silc_protocol_unregister(SILC_PROTOCOL_SERVER_BACKUP, + silc_server_protocol_backup); }