Integer type name change.

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

diff --git a/apps/silcd/protocol.c b/apps/silcd/protocol.c
index afa0ad43ff69b43465a569a1f5070c9fe16aac87..29eb07a707d6f8cc7f3cea6728a1a2e08115d745 100644 (file)
--- a/apps/silcd/protocol.c
+++ b/apps/silcd/protocol.c
@@ -38,7 +38,7 @@ extern char *silc_version_string;
 static bool 
 silc_verify_public_key_internal(SilcServer server, SilcSocketConnection sock,
                                SilcSocketType conn_type,
-                               unsigned char *pk, uint32 pk_len, 
+                               unsigned char *pk, SilcUInt32 pk_len, 
                                SilcSKEPKType pk_type)
 {
   char file[256], filename[256], *fingerprint;
@@ -103,7 +103,7 @@ silc_verify_public_key_internal(SilcServer server, SilcSocketConnection sock,
     /* The key already exists, verify it. */
     SilcPublicKey public_key;
     unsigned char *encpk;
-    uint32 encpk_len;
+    SilcUInt32 encpk_len;
 
     SILC_LOG_DEBUG(("We have the public key saved locally"));
 
@@ -159,7 +159,7 @@ silc_verify_public_key_internal(SilcServer server, SilcSocketConnection sock,
 static void 
 silc_server_protocol_ke_verify_key(SilcSKE ske,
                                   unsigned char *pk_data,
-                                  uint32 pk_len,
+                                  SilcUInt32 pk_len,
                                   SilcSKEPKType pk_type,
                                   void *context,
                                   SilcSKEVerifyCbCompletion completion,
@@ -276,14 +276,11 @@ int silc_server_protocol_ke_set_keys(SilcServer server,
   }
 
   idata->rekey = silc_calloc(1, sizeof(*idata->rekey));
-  idata->rekey->send_enc_key = 
-    silc_calloc(keymat->enc_key_len / 8,
-               sizeof(*idata->rekey->send_enc_key));
-  memcpy(idata->rekey->send_enc_key, 
-        keymat->send_enc_key, keymat->enc_key_len / 8);
+  idata->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
+                                          keymat->enc_key_len / 8);
   idata->rekey->enc_key_len = keymat->enc_key_len / 8;
 
-  if (ske->start_payload->flags & SILC_SKE_SP_FLAG_PFS)
+  if (ske->prop->flags & SILC_SKE_SP_FLAG_PFS)
     idata->rekey->pfs = TRUE;
   idata->rekey->ske_group = silc_ske_group_get_number(group);
 
@@ -318,7 +315,7 @@ int silc_server_protocol_ke_set_keys(SilcServer server,
 /* Check remote host version string */
 
 SilcSKEStatus silc_ske_check_version(SilcSKE ske, unsigned char *version,
-                                    uint32 len, void *context)
+                                    SilcUInt32 len, void *context)
 {
   SilcSKEStatus status = SILC_SKE_STATUS_OK;
   char *cp;
@@ -457,9 +454,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
       SilcSKE ske;
 
       /* Allocate Key Exchange object */
-      ske = silc_ske_alloc();
-      ctx->ske = ske;
-      ske->rng = server->rng;
+      ctx->ske = ske = silc_ske_alloc(server->rng, server);
       
       silc_ske_set_callbacks(ske, silc_server_protocol_ke_send_packet, NULL,
                             silc_server_protocol_ke_verify_key,
@@ -471,12 +466,12 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
           properties packet from initiator. */
        status = silc_ske_responder_start(ske, ctx->rng, ctx->sock,
                                          silc_version_string,
-                                         ctx->packet->buffer, TRUE);
+                                         ctx->packet->buffer, ctx->flags);
       } else {
        SilcSKEStartPayload *start_payload;
 
        /* Assemble security properties. */
-       silc_ske_assemble_security_properties(ske, SILC_SKE_SP_FLAG_MUTUAL, 
+       silc_ske_assemble_security_properties(ske, ctx->flags, 
                                              silc_version_string,
                                              &start_payload);
 
@@ -514,8 +509,7 @@ 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);
+       status = silc_ske_responder_phase_1(ctx->ske);
       } else {
        /* Call Phase-1 function. This processes the Key Exchange Start
           paylaod reply we just got from the responder. The callback
@@ -562,7 +556,8 @@ SILC_TASK_CALLBACK(silc_server_protocol_key_exchange)
           Key Exhange 1 Payload to the responder. */
        status = silc_ske_initiator_phase_2(ctx->ske,
                                            server->public_key,
-                                           server->private_key);
+                                           server->private_key,
+                                           SILC_SKE_PK_TYPE_SILC);
        protocol->state++;
       }
 
@@ -741,7 +736,7 @@ static int
 silc_server_public_key_authentication(SilcServer server,
                                      SilcPublicKey pub_key,
                                      unsigned char *sign,
-                                     uint32 sign_len,
+                                     SilcUInt32 sign_len,
                                      SilcSKE ske)
 {
   SilcPKCS pkcs;
@@ -784,7 +779,7 @@ silc_server_public_key_authentication(SilcServer server,
 static int
 silc_server_get_public_key_auth(SilcServer server,
                                unsigned char **auth_data,
-                               uint32 *auth_data_len,
+                               SilcUInt32 *auth_data_len,
                                SilcSKE ske)
 {
   int len;
@@ -824,7 +819,7 @@ silc_server_get_authentication(SilcServerConnAuthInternalContext *ctx,
                               char *local_passphrase,
                               void *local_publickey,
                               unsigned char *remote_auth,
-                              uint32 remote_auth_len)
+                              SilcUInt32 remote_auth_len)
 {
   SilcServer server = (SilcServer)ctx->server;
   SilcSKE ske = ctx->ske;
@@ -891,8 +886,8 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
         * We are receiving party
         */
        int ret;
-       uint16 payload_len;
-       uint16 conn_type;
+       SilcUInt16 payload_len;
+       SilcUInt16 conn_type;
        unsigned char *auth_data = NULL;
 
        SILC_LOG_INFO(("Performing authentication protocol for %s (%s)",
@@ -953,7 +948,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
 
        /* Remote end is client */
        if (conn_type == SILC_SOCKET_TYPE_CLIENT) {
-         SilcServerConfigSectionClient *client = ctx->cconfig;
+         SilcServerConfigClient *client = ctx->cconfig;
          
          if (client) {
            ret = silc_server_get_authentication(ctx, client->passphrase,
@@ -982,7 +977,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
        
        /* Remote end is server */
        if (conn_type == SILC_SOCKET_TYPE_SERVER) {
-         SilcServerConfigSectionServer *serv = ctx->sconfig;
+         SilcServerConfigServer *serv = ctx->sconfig;
          
          if (serv) {
            ret = silc_server_get_authentication(ctx, serv->passphrase,
@@ -1011,7 +1006,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
        
        /* Remote end is router */
        if (conn_type == SILC_SOCKET_TYPE_ROUTER) {
-         SilcServerConfigSectionRouter *serv = ctx->rconfig;
+         SilcServerConfigRouter *serv = ctx->rconfig;
 
          if (serv) {
            ret = silc_server_get_authentication(ctx, serv->passphrase,
@@ -1057,7 +1052,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_connection_auth)
        SilcBuffer packet;
        int payload_len = 0;
        unsigned char *auth_data = NULL;
-       uint32 auth_data_len = 0;
+       SilcUInt32 auth_data_len = 0;
        
        switch(ctx->auth_meth) {
        case SILC_AUTH_NONE:
@@ -1249,11 +1244,8 @@ silc_server_protocol_rekey_validate(SilcServer server,
   if (!send) {
     memset(idata->rekey->send_enc_key, 0, idata->rekey->enc_key_len);
     silc_free(idata->rekey->send_enc_key);
-    idata->rekey->send_enc_key = 
-      silc_calloc(keymat->enc_key_len / 8,
-                 sizeof(*idata->rekey->send_enc_key));
-    memcpy(idata->rekey->send_enc_key, keymat->send_enc_key, 
-          keymat->enc_key_len / 8);
+    idata->rekey->send_enc_key = silc_memdup(keymat->send_enc_key,
+                                            keymat->enc_key_len / 8);
     idata->rekey->enc_key_len = keymat->enc_key_len / 8;
   }
 }
@@ -1267,8 +1259,8 @@ void silc_server_protocol_rekey_generate(SilcServer server,
 {
   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
   SilcSKEKeyMaterial *keymat;
-  uint32 key_len = silc_cipher_get_key_len(idata->send_key);
-  uint32 hash_len = idata->hash->hash->hash_len;
+  SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
+  SilcUInt32 hash_len = idata->hash->hash->hash_len;
 
   SILC_LOG_DEBUG(("Generating new %s session keys (no PFS)",
                  send ? "sending" : "receiving"));
@@ -1296,10 +1288,10 @@ silc_server_protocol_rekey_generate_pfs(SilcServer server,
 {
   SilcIDListData idata = (SilcIDListData)ctx->sock->user_data;
   SilcSKEKeyMaterial *keymat;
-  uint32 key_len = silc_cipher_get_key_len(idata->send_key);
-  uint32 hash_len = idata->hash->hash->hash_len;
+  SilcUInt32 key_len = silc_cipher_get_key_len(idata->send_key);
+  SilcUInt32 hash_len = idata->hash->hash->hash_len;
   unsigned char *tmpbuf;
-  uint32 klen;
+  SilcUInt32 klen;
 
   SILC_LOG_DEBUG(("Generating new %s session keys (with PFS)",
                  send ? "sending" : "receiving"));
@@ -1382,8 +1374,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey)
            return;
          }
 
-         ctx->ske = silc_ske_alloc();
-         ctx->ske->rng = server->rng;
+         ctx->ske = silc_ske_alloc(server->rng, server);
          ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
          silc_ske_group_get_by_number(idata->rekey->ske_group,
                                       &ctx->ske->prop->group);
@@ -1438,8 +1429,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey)
           * Use Perfect Forward Secrecy, ie. negotiate the key material
           * using the SKE protocol.
           */
-         ctx->ske = silc_ske_alloc();
-         ctx->ske->rng = server->rng;
+         ctx->ske = silc_ske_alloc(server->rng, server);
          ctx->ske->prop = silc_calloc(1, sizeof(*ctx->ske->prop));
          silc_ske_group_get_by_number(idata->rekey->ske_group,
                                       &ctx->ske->prop->group);
@@ -1449,7 +1439,7 @@ SILC_TASK_CALLBACK(silc_server_protocol_rekey)
                                 NULL, NULL, NULL, silc_ske_check_version,
                                 context);
       
-         status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL);
+         status = silc_ske_initiator_phase_2(ctx->ske, NULL, NULL, 0);
          if (status != SILC_SKE_STATUS_OK) {
            SILC_LOG_WARNING(("Error (%s) during Re-key (PFS)",
                              silc_ske_map_status(status)));