updated copyright years and pekka's email on some files

[silc.git] / apps / silcd / protocol.c

diff --git a/apps/silcd/protocol.c b/apps/silcd/protocol.c
index a33184d7b1e9d2087afcc8c3e04b80f3b25b792b..fb2d41d371021fe807bf55f71507ee64e738c602 100644 (file)
--- a/apps/silcd/protocol.c
+++ b/apps/silcd/protocol.c
@@ -4,7 +4,7 @@
 
   Author: Pekka Riikonen <priikone@silcnet.org>
 
-  Copyright (C) 1997 - 2001 Pekka Riikonen
+  Copyright (C) 1997 - 2002 Pekka Riikonen
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -175,8 +175,8 @@ silc_server_protocol_ke_verify_key(SilcSKE ske,
   if (silc_verify_public_key_internal(server, ctx->sock, 
                                      (ctx->responder == FALSE ?
                                       SILC_SOCKET_TYPE_ROUTER:
-                                      ctx->sconfig ? SILC_SOCKET_TYPE_SERVER :
-                                      ctx->rconfig ? SILC_SOCKET_TYPE_ROUTER :
+                                      ctx->sconfig.ref_ptr ? SILC_SOCKET_TYPE_SERVER :
+                                      ctx->rconfig.ref_ptr ? SILC_SOCKET_TYPE_ROUTER :
                                       SILC_SOCKET_TYPE_CLIENT),
                                      pk_data, pk_len, pk_type))
     completion(ske, SILC_SKE_STATUS_OK, completion_context);
@@ -331,8 +331,9 @@ SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
   SILC_LOG_INFO(("%s (%s) is version %s", ske->sock->hostname,
                 ske->sock->ip, version));
 
-  /* Check for initial version string */
-  if (!strstr(version, "SILC-1.0-"))
+  /* Check for initial version string. Allowed "SILC-x.x-". More 
+     specific protocol version is checked later in session. */
+  if (!strstr(version, "SILC-"))
     status = SILC_SKE_STATUS_BAD_VERSION;
 
   /* Check software version */
@@ -371,14 +372,6 @@ SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
 
   if (maj != maj2)
     status = SILC_SKE_STATUS_BAD_VERSION;
-#if 0
-  if (min > min2)
-    status = SILC_SKE_STATUS_BAD_VERSION;
-#endif
-
-  /* XXX < 0.6 is not allowed */
-  if (maj == 0 && min < 5)
-    status = SILC_SKE_STATUS_BAD_VERSION;
 
   if (status == SILC_SKE_STATUS_BAD_VERSION)
     SILC_LOG_ERROR(("%s (%s) %s is not allowed/supported version", 
@@ -407,9 +400,7 @@ static void silc_server_protocol_ke_continue(SilcSKE ske, void *context)
   if (ske->status != SILC_SKE_STATUS_OK) {
     SILC_LOG_ERROR(("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->schedule, 0, 300000);
     return;
@@ -495,8 +486,6 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
       if (status != SILC_SKE_STATUS_OK) {
        SILC_LOG_ERROR(("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->schedule, 0, 300000);
@@ -532,8 +521,6 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
       if (status != SILC_SKE_STATUS_OK) {
        SILC_LOG_ERROR(("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->schedule, 0, 300000);
@@ -575,8 +562,6 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
       if (status != SILC_SKE_STATUS_OK) {
        SILC_LOG_ERROR(("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->schedule, 0, 300000);
@@ -613,8 +598,6 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
       if (status != SILC_SKE_STATUS_OK) {
        SILC_LOG_ERROR(("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->schedule, 0, 300000);
@@ -827,7 +810,7 @@ silc_server_get_public_key_auth(SilcServer server,
 static bool 
 silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
                               char *local_passphrase,
-                              void *local_publickey,
+                              SilcHashTable local_publickeys,
                               unsigned char *remote_auth,
                               SilcUInt32 remote_auth_len)
 {
@@ -837,7 +820,8 @@ silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
 
   /* If we don't have authentication data set at all we do not require
      authentication at all */
-  if (!local_passphrase && !local_publickey) {
+  if (!local_passphrase && (!local_publickeys || 
+                           !silc_hash_table_count(local_publickeys))) {
     SILC_LOG_DEBUG(("No authentication required"));
     return TRUE;
   }
@@ -854,13 +838,22 @@ silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
   }
 
   /* Try public key authenetication */
-  if (!result && local_publickey) {
+  if (!result && local_publickeys) {
+    SilcPublicKey cached_key;
+    SilcPublicKey remote_key = 
+      ((SilcIDListData)ctx->sock->user_data)->public_key;
+
     SILC_LOG_DEBUG(("Public key authentication"));
-    result = silc_server_public_key_authentication(server, 
-                                                  local_publickey,
+
+    /* Find the public key to be used in authentication */
+    cached_key = silc_server_find_public_key(server, local_publickeys,
+                                            remote_key);
+    if (!cached_key)
+      return FALSE;
+
+    result = silc_server_public_key_authentication(server, cached_key,
                                                   remote_auth,
-                                                  remote_auth_len, 
-                                                  ske);
+                                                  remote_auth_len, ske);
   }
 
   return result;
@@ -959,23 +952,21 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
 
        /* Remote end is client */
        if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
-         SilcServerConfigClient *client = ctx->cconfig;
-         
+         SilcServerConfigClient *client = ctx->cconfig.ref_ptr;
+
          if (client) {
            ret = silc_server_get_authentication(ctx, client->passphrase,
-                                                client->publickey,
+                                                client->publickeys,
                                                 auth_data, payload_len);
            if (!ret) {
              /* Authentication failed */
              SILC_LOG_ERROR(("Authentication failed"));
-             SILC_LOG_DEBUG(("Authentication failed"));
              silc_free(auth_data);
              protocol->state = SILC_PROTOCOL_STATE_ERROR;
              silc_protocol_execute(protocol, server->schedule, 0, 300000);
              return;
            }
          } else {
-           SILC_LOG_DEBUG(("No configuration for remote client connection"));
            SILC_LOG_ERROR(("Remote client connection not configured"));
            SILC_LOG_ERROR(("Authentication failed"));
            silc_free(auth_data);
@@ -988,23 +979,21 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
        
        /* Remote end is server */
        if (conn_type == SILC_SOCKET_TYPE_SERVER) {
-         SilcServerConfigServer *serv = ctx->sconfig;
-         
+         SilcServerConfigServer *serv = ctx->sconfig.ref_ptr;
+
          if (serv) {
            ret = silc_server_get_authentication(ctx, serv->passphrase,
-                                                serv->publickey,
+                                                serv->publickeys,
                                                 auth_data, payload_len);
            if (!ret) {
              /* Authentication failed */
              SILC_LOG_ERROR(("Authentication failed"));
-             SILC_LOG_DEBUG(("Authentication failed"));
              silc_free(auth_data);
              protocol->state = SILC_PROTOCOL_STATE_ERROR;
              silc_protocol_execute(protocol, server->schedule, 0, 300000);
              return;
            }
          } else {
-           SILC_LOG_DEBUG(("No configuration for remote server connection"));
            SILC_LOG_ERROR(("Remote server connection not configured"));
            SILC_LOG_ERROR(("Authentication failed"));
            protocol->state = SILC_PROTOCOL_STATE_ERROR;
@@ -1017,23 +1006,21 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
        
        /* Remote end is router */
        if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
-         SilcServerConfigRouter *serv = ctx->rconfig;
+         SilcServerConfigRouter *serv = ctx->rconfig.ref_ptr;
 
          if (serv) {
            ret = silc_server_get_authentication(ctx, serv->passphrase,
-                                                serv->publickey,
+                                                serv->publickeys,
                                                 auth_data, payload_len);
            if (!ret) {
              /* Authentication failed */
              SILC_LOG_ERROR(("Authentication failed"));
-             SILC_LOG_DEBUG(("Authentication failed"));
              silc_free(auth_data);
              protocol->state = SILC_PROTOCOL_STATE_ERROR;
              silc_protocol_execute(protocol, server->schedule, 0, 300000);
              return;
            }
          } else {
-           SILC_LOG_DEBUG(("No configuration for remote router connection"));
            SILC_LOG_ERROR(("Remote router connection not configured"));
            SILC_LOG_ERROR(("Authentication failed"));
            silc_free(auth_data);