From 7442402559fc951743360779cede89e0efcb63bf Mon Sep 17 00:00:00 2001 From: Pekka Riikonen Date: Fri, 13 Apr 2001 15:10:20 +0000 Subject: [PATCH] updates. --- CHANGES | 12 +++++++++ apps/silc/client_ops.c | 33 ++++++++++++++++++++++++ lib/silcclient/client.c | 43 +++----------------------------- lib/silcclient/client_internal.h | 10 -------- lib/silcclient/client_keyagr.c | 4 --- lib/silcske/silcske.c | 4 +-- 6 files changed, 50 insertions(+), 56 deletions(-) diff --git a/CHANGES b/CHANGES index 4f4c38f5..2186b85a 100644 --- a/CHANGES +++ b/CHANGES @@ -1,3 +1,15 @@ +Fri Apr 13 17:12:46 EEST 2001 Pekka Riikonen + + * Added printing of error messages during SKE protocol from the + failure packet sent by server during SKE. Affected file + silc/client_ops.c. + + * Removed the client's failure_callback handling with timeout + and handle it immediately when received. + + * The SKE library returned wrong type in SUCCESS and FAILURE + packets. They must be 32 bit MSB not 16 bit MSB. + Fri Apr 13 00:09:08 EEST 2001 Pekka Riikonen * Ok, rewrote the logic of the re-key and now it seems to work. diff --git a/apps/silc/client_ops.c b/apps/silc/client_ops.c index 985be666..bfd3a205 100644 --- a/apps/silc/client_ops.c +++ b/apps/silc/client_ops.c @@ -1195,7 +1195,40 @@ int silc_get_auth_method(SilcClient client, SilcClientConnection conn, void silc_failure(SilcClient client, SilcClientConnection conn, SilcProtocol protocol, void *failure) { + if (protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE) { + SilcSKEStatus status = (SilcSKEStatus)failure; + + if (status == SILC_SKE_STATUS_BAD_VERSION) + silc_say(client, conn, + "You are running incompatible client version (it may be " + "too old or too new)"); + if (status == SILC_SKE_STATUS_UNSUPPORTED_PUBLIC_KEY) + silc_say(client, conn, "Server does not support your public key type"); + if (status == SILC_SKE_STATUS_UNKNOWN_GROUP) + silc_say(client, conn, + "Server does not support one of your proposed KE group"); + if (status == SILC_SKE_STATUS_UNKNOWN_CIPHER) + silc_say(client, conn, + "Server does not support one of your proposed cipher"); + if (status == SILC_SKE_STATUS_UNKNOWN_PKCS) + silc_say(client, conn, + "Server does not support one of your proposed PKCS"); + if (status == SILC_SKE_STATUS_UNKNOWN_HASH_FUNCTION) + silc_say(client, conn, + "Server does not support one of your proposed hash function"); + if (status == SILC_SKE_STATUS_UNKNOWN_HMAC) + silc_say(client, conn, + "Server does not support one of your proposed HMAC"); + if (status == SILC_SKE_STATUS_INCORRECT_SIGNATURE) + silc_say(client, conn, "Incorrect signature"); + } + if (protocol->protocol->type == SILC_PROTOCOL_CLIENT_CONNECTION_AUTH) { + uint32 err = (uint32)failure; + + if (err == SILC_AUTH_FAILED) + silc_say(client, conn, "Authentication failed"); + } } /* Asks whether the user would like to perform the key agreement protocol. diff --git a/lib/silcclient/client.c b/lib/silcclient/client.c index 50445d00..52cda1dd 100644 --- a/lib/silcclient/client.c +++ b/lib/silcclient/client.c @@ -434,8 +434,6 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_second) if (ctx->dest_id) silc_free(ctx->dest_id); ctx->sock->protocol = NULL; - silc_task_unregister_by_callback(client->timeout_queue, - silc_client_failure_callback); /* Notify application of failure */ client->ops->connect(client, ctx->sock->user_data, FALSE); @@ -521,8 +519,6 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) if (ctx->dest_id) silc_free(ctx->dest_id); conn->sock->protocol = NULL; - silc_task_unregister_by_callback(client->timeout_queue, - silc_client_failure_callback); /* Notify application of failure */ client->ops->connect(client, ctx->sock->user_data, FALSE); @@ -564,8 +560,6 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) (void *)conn->sock, conn->rekey->timeout, 0, SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL); - silc_task_unregister_by_callback(client->timeout_queue, - silc_client_failure_callback); silc_protocol_free(protocol); if (ctx->auth_data) silc_free(ctx->auth_data); @@ -1626,30 +1620,6 @@ char *silc_client_chumode_char(uint32 mode) return strdup(string); } -/* Failure timeout callback. If this is called then we will immediately - process the received failure. We always process the failure with timeout - since we do not want to blindly trust to received failure packets. - This won't be called (the timeout is cancelled) if the failure was - bogus (it is bogus if remote does not close the connection after sending - the failure). */ - -SILC_TASK_CALLBACK_GLOBAL(silc_client_failure_callback) -{ - SilcClientFailureContext *f = (SilcClientFailureContext *)context; - - if (f->sock->protocol) { - f->sock->protocol->state = SILC_PROTOCOL_STATE_FAILURE; - f->sock->protocol->execute(f->client->timeout_queue, 0, - f->sock->protocol, f->sock->sock, 0, 0); - - /* Notify application */ - f->client->ops->failure(f->client, f->sock->user_data, f->sock->protocol, - (void *)f->failure); - } - - silc_free(f); -} - /* Registers failure timeout to process the received failure packet with timeout. */ @@ -1657,22 +1627,15 @@ void silc_client_process_failure(SilcClient client, SilcSocketConnection sock, SilcPacketContext *packet) { - SilcClientFailureContext *f; uint32 failure = 0; if (sock->protocol) { if (packet->buffer->len >= 4) SILC_GET32_MSB(failure, packet->buffer->data); - f = silc_calloc(1, sizeof(*f)); - f->client = client; - f->sock = sock; - f->failure = failure; - - /* We will wait 5 seconds to process this failure packet */ - silc_task_register(client->timeout_queue, sock->sock, - silc_client_failure_callback, (void *)f, 5, 0, - SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL); + /* Notify application */ + client->ops->failure(client, sock->user_data, sock->protocol, + (void *)failure); } } diff --git a/lib/silcclient/client_internal.h b/lib/silcclient/client_internal.h index dadf8f72..53b03ab2 100644 --- a/lib/silcclient/client_internal.h +++ b/lib/silcclient/client_internal.h @@ -52,19 +52,9 @@ struct SilcClientAwayStruct { struct SilcClientAwayStruct *next; }; -/* Failure context. This is allocated when failure packet is received. - Failure packets are processed with timeout and data is saved in this - structure. */ -typedef struct { - SilcClient client; - SilcSocketConnection sock; - uint32 failure; -} SilcClientFailureContext; - /* Protypes */ SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process); -SILC_TASK_CALLBACK_GLOBAL(silc_client_failure_callback); int silc_client_packet_send_real(SilcClient client, SilcSocketConnection sock, bool force_send, diff --git a/lib/silcclient/client_keyagr.c b/lib/silcclient/client_keyagr.c index 9191edd6..e05db76c 100644 --- a/lib/silcclient/client_keyagr.c +++ b/lib/silcclient/client_keyagr.c @@ -119,8 +119,6 @@ SILC_TASK_CALLBACK(silc_client_key_agreement_final) silc_ske_free(ctx->ske); if (ctx->dest_id) silc_free(ctx->dest_id); - silc_task_unregister_by_callback(client->timeout_queue, - silc_client_failure_callback); silc_task_unregister_by_fd(client->io_queue, ke->fd); silc_schedule_unset_listen_fd(ke->fd); silc_net_close_connection(ke->fd); @@ -245,8 +243,6 @@ SILC_TASK_CALLBACK(silc_client_key_agreement_timeout) silc_socket_free(ke->sock); } ke->client_entry->ke = NULL; - silc_task_unregister_by_callback(ke->client->timeout_queue, - silc_client_failure_callback); if (ke->fd) silc_task_unregister_by_fd(ke->client->io_queue, ke->fd); silc_schedule_unset_listen_fd(ke->fd); diff --git a/lib/silcske/silcske.c b/lib/silcske/silcske.c index 852ad4fd..3fef4222 100644 --- a/lib/silcske/silcske.c +++ b/lib/silcske/silcske.c @@ -810,7 +810,7 @@ SilcSKEStatus silc_ske_end(SilcSKE ske, packet = silc_buffer_alloc(4); silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet)); silc_buffer_format(packet, - SILC_STR_UI_SHORT(SILC_SKE_STATUS_OK), + SILC_STR_UI_INT((uint32)SILC_SKE_STATUS_OK), SILC_STR_END); if (send_packet) @@ -836,7 +836,7 @@ SilcSKEStatus silc_ske_abort(SilcSKE ske, SilcSKEStatus status, packet = silc_buffer_alloc(4); silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet)); silc_buffer_format(packet, - SILC_STR_UI_SHORT(status), + SILC_STR_UI_INT((uint32)status), SILC_STR_END); if (send_packet) -- 2.24.0