Some bugfixes, and type corrections.

diff --git a/configure.in b/configure.in
index 33c689d6874a0902698a30e316083b1cebfa2fa0..01a31039d70188d77ac3ce0ec0622ba38a2a9897 100644 (file)
--- a/configure.in
+++ b/configure.in
@@ -132,7 +132,7 @@ affect compiling.])
 if test $ac_cv_c_compiler_gnu != no; then
 
        if test x$opt_developer_mode = xyes; then
-         CFLAGS="${CFLAGS} -g -Wall -Wcast-align -W -Wpointer-arith -Wchar-subscripts -Wformat-security -Wmissing-braces -Winline -Wstrict-prototypes"
+         CFLAGS="${CFLAGS} -g -std=c99 -pedantic -Wno-format-y2k -Wall -Wcast-align -W -Wpointer-arith -Wchar-subscripts -Wformat-security -Wmissing-braces -Winline -Wstrict-prototypes"
        else
          CFLAGS="${CFLAGS} -O2 -finline-functions"
        fi

diff --git a/lib/auth_cert.c b/lib/auth_cert.c
index b0c0685ca274ee1fb3fa5df747cf13ae6fabd03a..b25a6937aecd9c6e92dd7f967351985c0631c1ef 100644 (file)
--- a/lib/auth_cert.c
+++ b/lib/auth_cert.c
@@ -219,6 +219,10 @@ static int _find_openpgp_cert(const gnutls_certificate_credentials cred,
        return 0;
 }
 
+/* Some upper limit to protect alloca();
+ */
+#define MAX_ISSUERS 512
+
 /* Finds the appropriate certificate depending on the cA Distinguished name
  * advertized by the server. If none matches then returns 0 and -1 as index.
  * In case of an error a negative value, is returned.
@@ -308,8 +312,7 @@ static int _gnutls_find_acceptable_client_cert(gnutls_session session,
                                if (dataptr_size == 0)
                                        break;
 
-                       } while (1);
-
+                       } while (issuers_dn_len < MAX_ISSUERS);
 
                        my_certs =
                            gnutls_alloca(cred->ncerts * sizeof(gnutls_datum));
@@ -529,7 +532,8 @@ extern OPENPGP_CERT2GNUTLS_CERT _E_gnutls_openpgp_cert2gnutls_cert;
 int _gnutls_gen_openpgp_certificate_fpr(gnutls_session session,
                                        opaque ** data)
 {
-       int ret, fpr_size, packet_size;
+       int ret, packet_size;
+       size_t fpr_size;
        opaque *pdata;
        gnutls_cert *apr_cert_list;
        gnutls_privkey* apr_pkey;
@@ -697,7 +701,7 @@ int _gnutls_proc_x509_server_certificate(gnutls_session session,
         */
 
        peer_certificate_list =
-           gnutls_alloca(sizeof(gnutls_cert) *
+           gnutls_malloc(sizeof(gnutls_cert) *
                          (peer_certificate_list_size));
 
        if (peer_certificate_list == NULL) {
@@ -724,12 +728,9 @@ int _gnutls_proc_x509_server_certificate(gnutls_session session,
                if ((ret =
                     _gnutls_x509_cert2gnutls_cert(&peer_certificate_list
                                                   [j], &tmp,
-                                                  CERT_ONLY_EXTENSIONS)) <
-                   0) {
+                                                  CERT_ONLY_EXTENSIONS)) < 0) {
                        gnutls_assert();
-                       CLEAR_CERTS;
-                       gnutls_afree(peer_certificate_list);
-                       return ret;
+                       goto cleanup;
                }
 
                p += len;
@@ -739,28 +740,25 @@ int _gnutls_proc_x509_server_certificate(gnutls_session session,
        if ((ret =
             _gnutls_copy_certificate_auth_info(info, gnutls_certificate_type_get(session),
                                                peer_certificate_list,
-                                               peer_certificate_list_size))
-           < 0) {
+                                               peer_certificate_list_size)) < 0) {
                gnutls_assert();
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return ret;
+               goto cleanup;
        }
 
        if ((ret =
             _gnutls_check_key_usage(&peer_certificate_list[0],
-                                         gnutls_kx_get(session)))
-           < 0) {
+                                         gnutls_kx_get(session))) < 0) {
                gnutls_assert();
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return ret;
+               goto cleanup;
        }
 
+       ret = 0;
+
+cleanup:
        CLEAR_CERTS;
-       gnutls_afree(peer_certificate_list);
+       gnutls_free(peer_certificate_list);
+       return ret;
 
-       return 0;
 }
 
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) _gnutls_free_cert(&peer_certificate_list[x])
@@ -774,7 +772,7 @@ int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
        const gnutls_certificate_credentials cred;
        ssize_t dsize = data_size;
        int i, x;
-       gnutls_cert *peer_certificate_list;
+       gnutls_cert *peer_certificate_list = NULL;
        int peer_certificate_list_size = 0;
        gnutls_datum tmp, akey = { NULL, 0 };
 
@@ -874,7 +872,6 @@ int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
 
        if (peer_certificate_list_size == 0) {
                gnutls_assert();
-               _gnutls_free_datum(&akey);
                return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
        }
 
@@ -883,56 +880,50 @@ int _gnutls_proc_openpgp_server_certificate(gnutls_session session,
                          (peer_certificate_list_size));
        if (peer_certificate_list == NULL) {
                gnutls_assert();
-               return GNUTLS_E_MEMORY_ERROR;
+               ret = GNUTLS_E_MEMORY_ERROR;
+               goto cleanup;
        }
        memset(peer_certificate_list, 0, sizeof(gnutls_cert) *
               peer_certificate_list_size);
 
        if (_E_gnutls_openpgp_cert2gnutls_cert == NULL) {
                gnutls_assert();
-               _gnutls_free_datum(&akey);
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return GNUTLS_E_INIT_LIBEXTRA;
+               ret = GNUTLS_E_INIT_LIBEXTRA;
+               goto cleanup;
        }
 
        if ((ret =
             _E_gnutls_openpgp_cert2gnutls_cert(&peer_certificate_list[0],
                                                &tmp)) < 0) {
                gnutls_assert();
-               _gnutls_free_datum(&akey);
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return ret;
+               goto cleanup;
        }
-       _gnutls_free_datum(&akey);
 
        if ((ret =
             _gnutls_copy_certificate_auth_info(info,
                                                gnutls_certificate_type_get(session),
                                                peer_certificate_list, 
-                                               peer_certificate_list_size))
-           < 0) {
+                                               peer_certificate_list_size)) < 0) {
                gnutls_assert();
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return ret;
+               goto cleanup;
        }
 
        if ((ret =
             _gnutls_check_key_usage(&peer_certificate_list[0],
-                                         gnutls_kx_get(session)))
-           < 0) {
+                                         gnutls_kx_get(session))) < 0) {
                gnutls_assert();
-               CLEAR_CERTS;
-               gnutls_afree(peer_certificate_list);
-               return ret;
+               goto cleanup;
        }
 
+       ret = 0;
+       
+cleanup:
+
+       _gnutls_free_datum(&akey);
        CLEAR_CERTS;
        gnutls_afree(peer_certificate_list);
-
-       return 0;
+       return ret;
+       
 }
 
 int _gnutls_proc_cert_server_certificate(gnutls_session session,
@@ -1232,7 +1223,7 @@ int _gnutls_find_apr_cert(gnutls_session session,
        const gnutls_certificate_credentials cred;
        int ind;
 
-       cred = _gnutls_get_kx_cred(session, GNUTLS_CRD_CERTIFICATE, NULL);
+       cred = _gnutls_get_cred(session->key, GNUTLS_CRD_CERTIFICATE, NULL);
 
        if (cred == NULL) {
                gnutls_assert();

diff --git a/lib/debug.c b/lib/debug.c
index 7b560a6268e5614b994ab4377f70bd72c4d6ac43..cc3c9f72abc4c79fe34f7827dfea1bb23247383f 100644 (file)
--- a/lib/debug.c
+++ b/lib/debug.c
@@ -104,7 +104,7 @@ const char* _gnutls_handshake2str( HandshakeType handshake)
 
 void _gnutls_dump_mpi(const char* prefix, GNUTLS_MPI a)
 {
-       char buf[1024];
+       opaque buf[1024];
        size_t n = sizeof buf;
        
        if (gcry_mpi_print(GCRYMPI_FMT_HEX, buf, n, &n, a))

diff --git a/lib/ext_server_name.c b/lib/ext_server_name.c
index eae9acdc4b88df5b4e1da5ae076e597e24a056d8..6e31932ccf5d5790920802a9c18b3446ac45f47f 100644 (file)
--- a/lib/ext_server_name.c
+++ b/lib/ext_server_name.c
@@ -116,7 +116,7 @@ int _gnutls_server_name_send_params(gnutls_session session, opaque * data,
                                    size_t _data_size)
 {
    uint16 len;
-   char *p;
+   opaque *p;
    int i;
    ssize_t data_size = _data_size;
    int total_size = 0;

diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index 6b1b5570fabe1ee38ae634826e5ea20f6fc56fa7..2b80b9ad5b6d3c1723666aefed8a0c8498441a67 100644 (file)
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -331,7 +331,7 @@ ssize_t _gnutls_io_read_buffered( gnutls_session session, opaque **iptr, size_t
        ssize_t ret=0, ret2=0;
        size_t min;
        int buf_pos;
-       char *buf;
+       opaque *buf;
        int recvlowat;
        int recvdata, alloc_size;
 
@@ -817,11 +817,12 @@ ssize_t _gnutls_handshake_io_send_int( gnutls_session session, ContentType type,
 /* This is a receive function for the gnutls handshake 
  * protocol. Makes sure that we have received all data.
  */
-ssize_t _gnutls_handshake_io_recv_int( gnutls_session session, ContentType type, HandshakeType htype, void *iptr, size_t sizeOfPtr)
+ssize_t _gnutls_handshake_io_recv_int( gnutls_session session, 
+       ContentType type, HandshakeType htype, void *iptr, size_t sizeOfPtr)
 {
        size_t left;
        ssize_t i;
-       char *ptr;
+       opaque *ptr;
        size_t dsize;
                
        ptr = iptr;

diff --git a/lib/gnutls_constate.c b/lib/gnutls_constate.c
index c74fddd38a2fc9fc96914e9fd493bb9254fbb15a..53962844d861fbcb0cdd3d24c3adba13f150c40d 100644 (file)
--- a/lib/gnutls_constate.c
+++ b/lib/gnutls_constate.c
@@ -58,8 +58,8 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
 /* FIXME: This function is too long
  */
        opaque *key_block;
-       char random[2 * TLS_RANDOM_SIZE];
-       char rrandom[2 * TLS_RANDOM_SIZE];
+       opaque random[2 * TLS_RANDOM_SIZE];
+       opaque rrandom[2 * TLS_RANDOM_SIZE];
        int pos, ret;
        int block_size;
        char buf[64];
@@ -285,7 +285,6 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
 
        } else if (IV_size > 0 && export_flag != 0) {
                opaque *iv_block = gnutls_alloca(IV_size * 2);
-
                if (iv_block == NULL) {
                        gnutls_assert();
                        gnutls_free(key_block);
@@ -301,6 +300,7 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
                        if (ret < 0) {
                                gnutls_assert();
                                gnutls_free(key_block);
+                               gnutls_afree(iv_block);
                                return ret;
                        }
 
@@ -311,7 +311,7 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
 
                } else {        /* TLS 1.0 */
                        ret =
-                           _gnutls_PRF("", 0,
+                           _gnutls_PRF( "", 0,
                                        ivblock, ivblock_length, rrandom,
                                        2 * TLS_RANDOM_SIZE, IV_size * 2,
                                        iv_block);
@@ -319,6 +319,7 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
 
                if (ret < 0) {
                        gnutls_assert();
+                       gnutls_afree(iv_block);
                        gnutls_free(key_block);
                        return ret;
                }
@@ -326,6 +327,7 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
                if (_gnutls_sset_datum
                    (&session->cipher_specs.client_write_IV, iv_block,
                     IV_size) < 0) {
+                       gnutls_afree(iv_block);
                        gnutls_free(key_block);
                        return GNUTLS_E_MEMORY_ERROR;
                }
@@ -333,9 +335,12 @@ int _gnutls_set_keys(gnutls_session session, int hash_size, int IV_size,
                if (_gnutls_sset_datum
                    (&session->cipher_specs.server_write_IV,
                     &iv_block[IV_size], IV_size) < 0) {
+                       gnutls_afree(iv_block);
                        gnutls_free(key_block);
                        return GNUTLS_E_MEMORY_ERROR;
                }
+
+               gnutls_afree(iv_block);
        }
 
        gnutls_free(key_block);

diff --git a/lib/gnutls_dh_primes.c b/lib/gnutls_dh_primes.c
index e738398a672b018e9c5d5f8498cb900e4c78e1d9..08c86f3ab12ea3d0dc2d6716d9672c0e291725ae 100644 (file)
--- a/lib/gnutls_dh_primes.c
+++ b/lib/gnutls_dh_primes.c
@@ -384,7 +384,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
        _gnutls_mpi_print( NULL, &g_size, params->_generator);
        _gnutls_mpi_print( NULL, &p_size, params->_prime);
 
-       all_data = gnutls_alloca( g_size + p_size);
+       all_data = gnutls_malloc( g_size + p_size);
        if (all_data == NULL) {
                gnutls_assert();
                return GNUTLS_E_MEMORY_ERROR;
@@ -403,7 +403,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
             (_gnutls_get_gnutls_asn(), "GNUTLS.DHParameter", &c2))
            != ASN1_SUCCESS) {
                gnutls_assert();
-               gnutls_afree(all_data);
+               gnutls_free(all_data);
                return _gnutls_asn2err(result);
        }
 
@@ -413,7 +413,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
                                            p_data, p_size)) != ASN1_SUCCESS) 
        {
                gnutls_assert();
-               gnutls_afree(all_data);
+               gnutls_free(all_data);
                asn1_delete_structure(&c2);
                return _gnutls_asn2err(result);
        }
@@ -423,12 +423,12 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
        if ((result = asn1_write_value(c2, "base",
                                            g_data, g_size)) != ASN1_SUCCESS) {
                gnutls_assert();
-               gnutls_afree(all_data);
+               gnutls_free(all_data);
                asn1_delete_structure(&c2);
                return _gnutls_asn2err(result);
        }
 
-       gnutls_afree(all_data);
+       gnutls_free(all_data);
 
        if ((result = asn1_write_value(c2, "privateValueLength",
                                            NULL, 0)) != ASN1_SUCCESS) {
@@ -461,7 +461,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
                len = 0;
                asn1_der_coding( c2, "", NULL, &len, NULL);
 
-               tmp = gnutls_alloca( len);
+               tmp = gnutls_malloc( len);
                if (tmp == NULL) {
                        gnutls_assert();
                        asn1_delete_structure(&c2);
@@ -470,7 +470,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
 
                if ((result=asn1_der_coding( c2, "", tmp, &len, NULL)) != ASN1_SUCCESS) {
                        gnutls_assert();
-                       gnutls_afree( tmp);
+                       gnutls_free( tmp);
                        asn1_delete_structure(&c2);
                        return _gnutls_asn2err(result);
                }
@@ -480,7 +480,7 @@ int gnutls_dh_params_export_pkcs3( gnutls_dh_params params,
                result = _gnutls_fbase64_encode("DH PARAMETERS",
                                                tmp, len, &out);
 
-               gnutls_afree( tmp);
+               gnutls_free( tmp);
 
                if (result < 0) {
                        gnutls_assert();

diff --git a/lib/gnutls_extensions.c b/lib/gnutls_extensions.c
index de80bf5dbdc28aa88f1db3f695128667b8bbc96b..256f5f6da4d76910b7d654fd6ed16d5db4f713e1 100644 (file)
--- a/lib/gnutls_extensions.c
+++ b/lib/gnutls_extensions.c
@@ -57,22 +57,23 @@ gnutls_extension_entry _gnutls_extensions[MAX_EXT_SIZE] = {
 
 /* EXTENSION functions */
 
-void* _gnutls_ext_func_recv(uint16 type)
+ext_recv_func _gnutls_ext_func_recv(uint16 type)
 {
-       void* ret=NULL;
+       ext_recv_func ret = NULL;
        GNUTLS_EXTENSION_LOOP(ret = p->gnutls_ext_func_recv);
        return ret;
 
 }
-void* _gnutls_ext_func_send(uint16 type)
+
+ext_send_func _gnutls_ext_func_send(uint16 type)
 {
-       void* ret=NULL;
+       ext_send_func ret = NULL;
        GNUTLS_EXTENSION_LOOP(ret = p->gnutls_ext_func_send);
        return ret;
 
 }
 
-const char *_gnutls_extension_get_name(uint16 type)
+const char* _gnutls_extension_get_name(uint16 type)
 {
        const char *ret = NULL;
 

diff --git a/lib/gnutls_extensions.h b/lib/gnutls_extensions.h
index 8a1d5640097a6018f917960b3242ca91e0a653e3..3ea42a773944b512f5c1dacc7d816f65c4d9a8c2 100644 (file)
--- a/lib/gnutls_extensions.h
+++ b/lib/gnutls_extensions.h
@@ -1,5 +1,5 @@
 /*
- *      Copyright (C) 2001 Nikos Mavroyanopoulos
+ * Copyright (C) 2001,2003 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -20,15 +20,19 @@
 
 #include <gnutls_int.h>
 
-void* _gnutls_ext_func_send(uint16 type);
-void* _gnutls_ext_func_recv(uint16 type);
 const char *_gnutls_extension_get_name(uint16 type);
 int _gnutls_parse_extensions( gnutls_session, const opaque*, int);
 int _gnutls_gen_extensions( gnutls_session session, opaque** data);
 
+typedef int (*ext_recv_func)( gnutls_session, const opaque*, size_t); /* recv data */
+typedef int (*ext_send_func)( gnutls_session, opaque*, size_t); /* send data */
+
+ext_send_func _gnutls_ext_func_send(uint16 type);
+ext_recv_func _gnutls_ext_func_recv(uint16 type);
+
 typedef struct {
        const char *name;
        uint16 type;
-       int (*gnutls_ext_func_recv)( gnutls_session, const opaque*, size_t); /* recv data */
-       int (*gnutls_ext_func_send)( gnutls_session, opaque*, size_t); /* send data */
+       ext_recv_func gnutls_ext_func_recv;
+       ext_send_func gnutls_ext_func_send;
 } gnutls_extension_entry;

diff --git a/lib/gnutls_global.c b/lib/gnutls_global.c
index f4d59e7c765c33c633c31bd0de40235865e0712a..df5327877ae60c1110f1d9982deecd9e4affad2d 100644 (file)
--- a/lib/gnutls_global.c
+++ b/lib/gnutls_global.c
@@ -122,15 +122,15 @@ void gnutls_global_set_mem_functions(
                _gnutls_is_secure_memory = _gnutls_is_secure_mem_null;
 
        /* if using the libc's default malloc
-        * then also use the libc's strdup.
+        * use libc's calloc as well.
         */
        if ( gnutls_malloc == malloc) {
-               gnutls_strdup = strdup;
                gnutls_calloc = calloc;
        } else { /* use the included ones */
-               gnutls_strdup = _gnutls_strdup;
                gnutls_calloc = _gnutls_calloc;
        }
+       gnutls_strdup = _gnutls_strdup;
+
 }
 
 #ifdef DEBUG

diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index a892141ead06bf28f18a5fa660fff681520b06d9..872e3b854bcba5641972660d53b8b04a11d1bbcd 100644 (file)
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -136,7 +136,7 @@ static int _gnutls_ssl3_finished(gnutls_session session, int type, opaque * ret)
        const int siz = SSL_MSG_LEN;
        GNUTLS_MAC_HANDLE td_md5;
        GNUTLS_MAC_HANDLE td_sha;
-       const opaque *mesg;
+       const char *mesg;
 
        td_md5 = _gnutls_hash_copy( session->internals.handshake_mac_handle_md5);
        if (td_md5 == NULL) {
@@ -175,7 +175,7 @@ int _gnutls_finished(gnutls_session session, int type, void *ret)
 {
        const int siz = TLS_MSG_LEN;
        opaque concat[36];
-       const opaque *mesg;
+       const char *mesg;
        GNUTLS_MAC_HANDLE td_md5;
        GNUTLS_MAC_HANDLE td_sha;
 
@@ -1181,7 +1181,7 @@ static int _gnutls_client_check_if_resuming(gnutls_session session,
                                            opaque * session_id,
                                            int session_id_len)
 {
-char buf[2*TLS_MAX_SESSION_ID_SIZE+1];
+opaque buf[2*TLS_MAX_SESSION_ID_SIZE+1];
 
        _gnutls_handshake_log("HSK[%x]: SessionID length: %d\n", session, session_id_len);
        _gnutls_handshake_log("HSK[%x]: SessionID: %s\n", session,
@@ -1222,7 +1222,7 @@ char buf[2*TLS_MAX_SESSION_ID_SIZE+1];
  * This function also restores resumed parameters if we are resuming a
  * session.
  */
-static int _gnutls_read_server_hello(gnutls_session session, char *data,
+static int _gnutls_read_server_hello(gnutls_session session, opaque *data,
                                     int datalen)
 {
        uint8 session_id_len = 0;
@@ -1604,7 +1604,7 @@ static int _gnutls_send_server_hello(gnutls_session session, int again)
        uint8 comp;
        opaque *SessionID = session->security_parameters.session_id;
        uint8 session_id_len = session->security_parameters.session_id_size;
-       char buf[2*TLS_MAX_SESSION_ID_SIZE+1];
+       opaque buf[2*TLS_MAX_SESSION_ID_SIZE+1];
 
        if (SessionID == NULL)
                session_id_len = 0;
@@ -1694,7 +1694,7 @@ int _gnutls_send_hello(gnutls_session session, int again)
  * hello message is expected. It uses the security_parameters.current_cipher_suite
  * and internals.compression_method.
  */
-int _gnutls_recv_hello(gnutls_session session, char *data, int datalen)
+int _gnutls_recv_hello(gnutls_session session, opaque *data, int datalen)
 {
        int ret;
 
@@ -2246,7 +2246,7 @@ int _gnutls_handshake_common(gnutls_session session)
 
 }
 
-int _gnutls_generate_session_id(char *session_id, uint8 * len)
+int _gnutls_generate_session_id(opaque *session_id, uint8 * len)
 {
        *len = TLS_MAX_SESSION_ID_SIZE;
 

diff --git a/lib/gnutls_handshake.h b/lib/gnutls_handshake.h
index e58ace6d639dddfb4a7a9799c6a7d6e15dcb86b7..ac11dbe2553db33e6ad1724395b9558363683be5 100644 (file)
--- a/lib/gnutls_handshake.h
+++ b/lib/gnutls_handshake.h
@@ -1,5 +1,5 @@
 /*
- *      Copyright (C) 2000 Nikos Mavroyanopoulos
+ * Copyright (C) 2000,2003 Nikos Mavroyanopoulos
  *
  * This file is part of GNUTLS.
  *
@@ -24,10 +24,10 @@ int _gnutls_send_handshake( gnutls_session session, void* i_data, uint32 i_datas
 int gnutls_send_hello_request( gnutls_session session);
 int _gnutls_recv_hello_request( gnutls_session session, void* data, uint32 data_size);
 int _gnutls_send_hello( gnutls_session session, int again);
-int _gnutls_recv_hello( gnutls_session session, char* data, int datalen);
+int _gnutls_recv_hello( gnutls_session session, opaque* data, int datalen);
 int gnutls_handshake( gnutls_session session);
 int _gnutls_recv_handshake( gnutls_session session, uint8**, int*, HandshakeType, Optional optional);
-int _gnutls_generate_session_id( char* session_id, uint8* len);
+int _gnutls_generate_session_id( opaque* session_id, uint8* len);
 int _gnutls_handshake_common( gnutls_session session);
 int _gnutls_handshake_client( gnutls_session session);
 int _gnutls_handshake_server( gnutls_session session);

diff --git a/lib/gnutls_hash_int.c b/lib/gnutls_hash_int.c
index 8f3abcaf65bcb05d101e24d29b680fe4ed95cb79..1b074e2b6b8fabb4b7fd915ec0d70eb7b1e37ee4 100644 (file)
--- a/lib/gnutls_hash_int.c
+++ b/lib/gnutls_hash_int.c
@@ -121,7 +121,7 @@ GNUTLS_HASH_HANDLE _gnutls_hash_copy(GNUTLS_HASH_HANDLE handle)
 
 void _gnutls_hash_deinit(GNUTLS_HASH_HANDLE handle, void *digest)
 {
-       char *mac;
+       opaque *mac;
        int maclen;
 
        maclen = gcry_md_get_algo_dlen(gcry_md_get_algo(handle->handle));
@@ -192,7 +192,7 @@ int _gnutls_hmac(GNUTLS_MAC_HANDLE handle, const void *text, size_t textlen)
 
 void _gnutls_hmac_deinit(GNUTLS_MAC_HANDLE handle, void *digest)
 {
-       char *mac;
+       opaque *mac;
        int maclen;
 
        maclen = gcry_md_get_algo_dlen(gcry_md_get_algo(handle->handle));
@@ -224,7 +224,7 @@ GNUTLS_MAC_HANDLE _gnutls_mac_init_ssl3(gnutls_mac_algorithm algorithm, void *ke
                                        int keylen)
 {
        GNUTLS_MAC_HANDLE ret;
-       char ipad[48];
+       opaque ipad[48];
        int padsize;
 
        padsize = get_padsize( algorithm);
@@ -252,7 +252,7 @@ void _gnutls_mac_deinit_ssl3(GNUTLS_MAC_HANDLE handle, void *digest)
 {
        opaque ret[MAX_HASH_SIZE];
        GNUTLS_MAC_HANDLE td;
-       char opad[48];
+       opaque opad[48];
        int padsize;
        int block;
 
@@ -284,8 +284,8 @@ void _gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle,
 {
        opaque ret[MAX_HASH_SIZE];
        GNUTLS_MAC_HANDLE td;
-       char opad[48];
-       char ipad[48];
+       opaque opad[48];
+       opaque ipad[48];
        int padsize;
        int block;
 
@@ -317,11 +317,11 @@ void _gnutls_mac_deinit_ssl3_handshake(GNUTLS_MAC_HANDLE handle,
        }
 }
 
-static int ssl3_sha(int i, char *secret, int secret_len, char *random,
+static int ssl3_sha(int i, opaque *secret, int secret_len, opaque *random,
                    int random_len, void *digest)
 {
        int j;
-       char text1[26];
+       opaque text1[26];
 
        GNUTLS_HASH_HANDLE td;
 
@@ -343,7 +343,7 @@ static int ssl3_sha(int i, char *secret, int secret_len, char *random,
        return 0;
 }
 
-static int ssl3_md5(int i, char *secret, int secret_len, char *random,
+static int ssl3_md5(int i, opaque *secret, int secret_len, opaque *random,
                    int random_len, void *digest)
 {
        opaque tmp[MAX_HASH_SIZE];
@@ -406,7 +406,7 @@ int _gnutls_ssl3_generate_random(void *secret, int secret_len,
                                 int ret_bytes, opaque * ret)
 {
        int i = 0, copy, output_bytes;
-       char digest[MAX_HASH_SIZE];
+       opaque digest[MAX_HASH_SIZE];
        int block = _gnutls_hash_get_algo_len(GNUTLS_MAC_MD5);
        int result, times;
 

diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index 58b86444020db389a9432ed4650af70c719ed117..b8f9eac40baf260be6308dbc799d41694b7b1934 100644 (file)
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -229,7 +229,7 @@ typedef int (*gnutls_db_remove_func)(void*, gnutls_datum key);
 typedef gnutls_datum (*gnutls_db_retr_func)(void*, gnutls_datum key);
 
 typedef struct AUTH_CRED {
-       gnutls_kx_algorithm algorithm;
+       gnutls_credentials_type algorithm;
        /* the type of credentials depends on algorithm */
        void* credentials;
        struct AUTH_CRED* next;

diff --git a/lib/gnutls_mem.c b/lib/gnutls_mem.c
index 869d2a5c0e0cca273087c095260cda0f57e43c16..dc21b196e17b057484240ca537aea7b9ee8bdeee 100644 (file)
--- a/lib/gnutls_mem.c
+++ b/lib/gnutls_mem.c
@@ -29,7 +29,7 @@ gnutls_free_function gnutls_free = free;
 gnutls_realloc_function gnutls_realloc = realloc;
 
 void* (*gnutls_calloc)(size_t, size_t) = calloc;
-char* (*gnutls_strdup)(const char*) = strdup;
+char* (*gnutls_strdup)(const char*) = _gnutls_strdup;
 
 int _gnutls_is_secure_mem_null( const void* ign) { return 0; }
 

diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index 0c024292c0fcff093898fd1e8d9833fac9a49d59..918068ea7aac3fda6c8ab6aff5684e3e9a9d6eef 100644 (file)
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -244,7 +244,7 @@ gnutls_protocol_version lver;
        }
 }
 
-static
+inline static
 ssize_t _gnutls_create_empty_record( gnutls_session session, ContentType type,
        opaque* erecord, unsigned int erecord_size)
 {
@@ -382,7 +382,7 @@ ssize_t _gnutls_send_int( gnutls_session session, ContentType type, HandshakeTyp
                /* now proceed to packet encryption
                 */
                cipher_size = data2send_size + MAX_RECORD_OVERHEAD;
-               cipher = gnutls_alloca( cipher_size);
+               cipher = gnutls_malloc( cipher_size);
                if (cipher==NULL) {
                        gnutls_assert();
                        return GNUTLS_E_MEMORY_ERROR;
@@ -394,7 +394,7 @@ ssize_t _gnutls_send_int( gnutls_session session, ContentType type, HandshakeTyp
                        gnutls_assert();
                        if (cipher_size==0) cipher_size = GNUTLS_E_ENCRYPTION_FAILED;
                        gnutls_afree( erecord);
-                       gnutls_afree( cipher);
+                       gnutls_free( cipher);
                        return cipher_size; /* error */
                }
 
@@ -407,13 +407,13 @@ ssize_t _gnutls_send_int( gnutls_session session, ContentType type, HandshakeTyp
                        _gnutls_session_invalidate( session);
                        gnutls_assert();
                        gnutls_afree( erecord);
-                       gnutls_afree( cipher);
+                       gnutls_free( cipher);
                        return GNUTLS_E_RECORD_LIMIT_REACHED;
                }
 
                ret = _gnutls_io_write_buffered2( session, erecord, erecord_size, cipher, cipher_size);
                gnutls_afree( erecord);
-               gnutls_afree( cipher);
+               gnutls_free( cipher);
        }
 
        if ( ret != cipher_size + erecord_size) {
@@ -682,7 +682,8 @@ static int _gnutls_record_check_type( gnutls_session session, ContentType recv_t
  * receive (if called by the user the Content is Userdata only)
  * It is intended to receive data, under the current session.
  */
-ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeType htype, char *data, size_t sizeofdata)
+ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeType htype, 
+       opaque *data, size_t sizeofdata)
 {
        uint8 *tmpdata;
        int tmplen;
@@ -797,7 +798,7 @@ ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeTyp
         * packet length (due to compression).
         */
        tmplen = MAX_RECORD_RECV_SIZE;
-       tmpdata = gnutls_alloca( tmplen);
+       tmpdata = gnutls_malloc( tmplen);
        if (tmpdata==NULL) {
                gnutls_assert();
                return GNUTLS_E_MEMORY_ERROR;
@@ -807,7 +808,7 @@ ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeTyp
        if (tmplen < 0) {
                _gnutls_session_unresumable( session);
                _gnutls_session_invalidate( session);
-               gnutls_afree(tmpdata);
+               gnutls_free(tmpdata);
                gnutls_assert();
                return tmplen;
        }
@@ -820,11 +821,11 @@ ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeTyp
 
                if ((size_t)tmplen!=sizeofdata) { /* sizeofdata should be 1 */
                        gnutls_assert();
-                       gnutls_afree(tmpdata);
+                       gnutls_free(tmpdata);
                        return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
                }
                memcpy( data, tmpdata, sizeofdata);
-               gnutls_afree(tmpdata);
+               gnutls_free(tmpdata);
 
                return tmplen;
        }
@@ -835,19 +836,19 @@ ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeTyp
        /* increase sequence number */
        if (_gnutls_uint64pp( &session->connection_state.read_sequence_number)!=0) {
                _gnutls_session_invalidate( session);
-               gnutls_afree(tmpdata);
+               gnutls_free(tmpdata);
                gnutls_assert();
                return GNUTLS_E_RECORD_LIMIT_REACHED;
        }
 
        if ( (ret=_gnutls_record_check_type( session, recv_type, type, htype, tmpdata, tmplen)) < 0) {
-               gnutls_afree(tmpdata);
+               gnutls_free(tmpdata);
 
                if (ret==GNUTLS_E_INT_RET_0) return 0;
                gnutls_assert();
                return ret;
        }
-       gnutls_afree(tmpdata);
+       gnutls_free(tmpdata);
 
        /* Get Application data from buffer 
         */

diff --git a/lib/gnutls_record.h b/lib/gnutls_record.h
index efa99204cfd95f1c079c4f7c9227c72fb9bfcb5a..8cecdbf6e40ed3de9ae72e6e59158c8d0555807b 100644 (file)
--- a/lib/gnutls_record.h
+++ b/lib/gnutls_record.h
@@ -1,4 +1,6 @@
-ssize_t _gnutls_send_int( gnutls_session session, ContentType type, HandshakeType htype, const void* data, size_t sizeofdata);
-ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, HandshakeType, char* data, size_t sizeofdata);
+ssize_t _gnutls_send_int( gnutls_session session, ContentType type, 
+       HandshakeType htype, const void* data, size_t sizeofdata);
+ssize_t _gnutls_recv_int( gnutls_session session, ContentType type, 
+       HandshakeType, opaque* data, size_t sizeofdata);
 ssize_t _gnutls_send_change_cipher_spec( gnutls_session session, int again);
 void gnutls_transport_set_lowat(gnutls_session session, int num);

diff --git a/lib/gnutls_state.c b/lib/gnutls_state.c
index 9a241ed196a0cf844e2d502e0b46a3af939c9c0f..9fecb2445429afeccc41f75b65400d1a9edfbb45 100644 (file)
--- a/lib/gnutls_state.c
+++ b/lib/gnutls_state.c
@@ -648,10 +648,11 @@ int i;
  * needed by the TLS specification. ret must have a least total_bytes
  * available.
  */
-int _gnutls_PRF( const opaque * secret, int secret_size, const uint8 * label, int label_size, opaque * seed, int seed_size, int total_bytes, void* ret)
+int _gnutls_PRF( const opaque * secret, int secret_size, const char * label, int label_size, 
+       opaque * seed, int seed_size, int total_bytes, void* ret)
 {
        int l_s, s_seed_size;
-       const char *s1, *s2;
+       const opaque *s1, *s2;
        opaque s_seed[MAX_SEED_SIZE];
        opaque o1[MAX_PRF_BYTES], o2[MAX_PRF_BYTES];
        int result;
@@ -672,6 +673,7 @@ int _gnutls_PRF( const opaque * secret, int secret_size, const uint8 * label, in
        memcpy(&s_seed[label_size], seed, seed_size);
 
        l_s = secret_size / 2;
+       
        s1 = &secret[0];
        s2 = &secret[l_s];
 

diff --git a/lib/gnutls_state.h b/lib/gnutls_state.h
index 99dccea36189d2f4775e569838e8443412511008..fe92c127bf12c9baa6d3215300c254b906284b9c 100644 (file)
--- a/lib/gnutls_state.h
+++ b/lib/gnutls_state.h
@@ -32,7 +32,7 @@ int _gnutls_session_is_export( gnutls_session session);
 
 int _gnutls_openpgp_send_fingerprint( gnutls_session session);
 
-int _gnutls_PRF( const opaque * secret, int secret_size, const uint8 * label, 
+int _gnutls_PRF( const opaque * secret, int secret_size, const char * label, 
    int label_size, opaque * seed, int seed_size, int total_bytes, void* ret);
 
 #define DEFAULT_CERT_TYPE GNUTLS_CRT_X509

diff --git a/lib/gnutls_v2_compat.c b/lib/gnutls_v2_compat.c
index 6e084c4b684de1ca763226c049e19ca04cb08134..0676b2dc1b04c8ca6cc8090d121a50856be500d5 100644 (file)
--- a/lib/gnutls_v2_compat.c
+++ b/lib/gnutls_v2_compat.c
@@ -43,7 +43,7 @@
 static int _gnutls_handshake_select_v2_suite(gnutls_session session, opaque *data, int datalen)
 {
        int i, j, ret;
-       char* _data;
+       opaque* _data;
        int _datalen;
        
        _data = gnutls_malloc( datalen);

diff --git a/lib/gnutls_x509.c b/lib/gnutls_x509.c
index 76848594a15201928998f937c8aa877538b56e2d..1bfadf9f051fa28fe490ff891cddc54f300968b7 100644 (file)
--- a/lib/gnutls_x509.c
+++ b/lib/gnutls_x509.c
@@ -202,7 +202,7 @@ uint pk = res->cert_list[res->ncerts-1][0].subject_pk_algorithm;
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_crt_mem( gnutls_cert** cert_list, int* ncerts, 
+static int parse_crt_mem( gnutls_cert** cert_list, uint* ncerts, 
        gnutls_x509_crt cert)
 {
        int i;
@@ -236,8 +236,8 @@ static int parse_crt_mem( gnutls_cert** cert_list, int* ncerts,
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_der_cert_mem( gnutls_cert** cert_list, int* ncerts, 
-       const char *input_cert, int input_cert_size)
+static int parse_der_cert_mem( gnutls_cert** cert_list, uint* ncerts, 
+       const void *input_cert, int input_cert_size)
 {
        gnutls_datum tmp;
        gnutls_x509_crt cert;
@@ -272,15 +272,15 @@ static int parse_der_cert_mem( gnutls_cert** cert_list, int* ncerts,
  * a gnutls_cert structure.
  * returns the number of certificate parsed
  */
-static int parse_pkcs7_cert_mem( gnutls_cert** cert_list, int* ncerts, const
-       char *input_cert, int input_cert_size, int flags)
+static int parse_pkcs7_cert_mem( gnutls_cert** cert_list, uint* ncerts, const
+       void *input_cert, int input_cert_size, int flags)
 {
 #ifdef ENABLE_PKI
        int i, j, count;
        gnutls_datum tmp, tmp2;
        int ret;
        opaque *pcert = NULL;
-       int pcert_size;
+       size_t pcert_size;
        gnutls_pkcs7 pkcs7;
        
        ret = gnutls_pkcs7_init( &pkcs7);
@@ -384,11 +384,11 @@ static int parse_pkcs7_cert_mem( gnutls_cert** cert_list, int* ncerts, const
 /* Reads a base64 encoded certificate list from memory and stores it to
  * a gnutls_cert structure. Returns the number of certificate parsed.
  */
-static int parse_pem_cert_mem( gnutls_cert** cert_list, int* ncerts, 
-       const char *input_cert, int input_cert_size)
+static int parse_pem_cert_mem( gnutls_cert** cert_list, uint* ncerts, 
+       const opaque *input_cert, int input_cert_size)
 {
        int size, siz2, i;
-       const char *ptr;
+       const opaque *ptr;
        opaque *ptr2;
        gnutls_datum tmp;
        int ret, count;
@@ -479,7 +479,7 @@ static int parse_pem_cert_mem( gnutls_cert** cert_list, int* ncerts,
 /* Reads a DER or PEM certificate from memory
  */
 static 
-int read_cert_mem(gnutls_certificate_credentials res, const char *cert, int cert_size, 
+int read_cert_mem(gnutls_certificate_credentials res, const void *cert, int cert_size, 
        gnutls_x509_crt_fmt type)
 {
        int ret;
@@ -561,7 +561,7 @@ int i;
  * 2002-01-26: Added ability to read DSA keys.
  * type indicates the certificate format.
  */
-static int read_key_mem(gnutls_certificate_credentials res, const char *key, int key_size, 
+static int read_key_mem(gnutls_certificate_credentials res, const void *key, int key_size, 
        gnutls_x509_crt_fmt type)
 {
        int ret;
@@ -753,8 +753,8 @@ static int read_key_file(gnutls_certificate_credentials res, const char *keyfile
 /**
   * gnutls_certificate_set_x509_key_mem - Used to set keys in a gnutls_certificate_credentials structure
   * @res: is an &gnutls_certificate_credentials structure.
-  * @CERT: contains a certificate list (path) for the specified private key
-  * @KEY: is the private key
+  * @cert: contains a certificate list (path) for the specified private key
+  * @key: is the private key
   * @type: is PEM or DER
   *
   * This function sets a certificate/private key pair in the 
@@ -776,17 +776,17 @@ static int read_key_file(gnutls_certificate_credentials res, const char *keyfile
   * then the strings that hold their values must be null terminated.
   *
   **/
-int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res, const gnutls_datum* CERT,
-                          const gnutls_datum* KEY, gnutls_x509_crt_fmt type)
+int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res, const gnutls_datum* cert,
+                          const gnutls_datum* key, gnutls_x509_crt_fmt type)
 {
        int ret;
 
        /* this should be first 
         */
-       if ((ret = read_key_mem( res, KEY->data, KEY->size, type)) < 0)
+       if ((ret = read_key_mem( res, key->data, key->size, type)) < 0)
                return ret;
 
-       if ((ret = read_cert_mem( res, CERT->data, CERT->size, type)) < 0)
+       if ((ret = read_cert_mem( res, cert->data, cert->size, type)) < 0)
                return ret;
 
        res->ncerts++;
@@ -804,7 +804,7 @@ int gnutls_certificate_set_x509_key_mem(gnutls_certificate_credentials res, cons
   * @res: is an &gnutls_certificate_credentials structure.
   * @cert_list: contains a certificate list (path) for the specified private key
   * @cert_list_size: holds the size of the certificate list
-  * @key: is a gnutls_x509_privkey  key
+  * @key: is a gnutls_x509_privkey key
   *
   * This function sets a certificate/private key pair in the 
   * gnutls_certificate_credentials structure. This function may be called
@@ -960,7 +960,7 @@ opaque *pdata;
                        return ret;
                }
 
-               _tmp.data = (char*) tmp.data;
+               _tmp.data = (opaque*) tmp.data;
                _tmp.size = tmp.size;
                _gnutls_write_datum16(pdata, _tmp);
                pdata += (2 + tmp.size);
@@ -1022,11 +1022,11 @@ int _gnutls_check_key_usage( const gnutls_cert* cert,
 
 
 
-static int parse_pem_ca_mem( gnutls_x509_crt** cert_list, int* ncerts, 
-       const char *input_cert, int input_cert_size)
+static int parse_pem_ca_mem( gnutls_x509_crt** cert_list, uint* ncerts, 
+       const opaque *input_cert, int input_cert_size)
 {
        int i, size;
-       const char *ptr;
+       const opaque *ptr;
        gnutls_datum tmp;
        int ret, count;
 
@@ -1062,7 +1062,7 @@ static int parse_pem_ca_mem( gnutls_x509_crt** cert_list, int* ncerts,
                        return ret;
                }
                
-               tmp.data = (char*)ptr;
+               tmp.data = (opaque*)ptr;
                tmp.size = size;
 
                ret =
@@ -1105,8 +1105,8 @@ static int parse_pem_ca_mem( gnutls_x509_crt** cert_list, int* ncerts,
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_der_ca_mem( gnutls_x509_crt** cert_list, int* ncerts, 
-       const char *input_cert, int input_cert_size)
+static int parse_der_ca_mem( gnutls_x509_crt** cert_list, uint* ncerts, 
+       const void *input_cert, int input_cert_size)
 {
        int i;
        gnutls_datum tmp;
@@ -1150,7 +1150,7 @@ static int parse_der_ca_mem( gnutls_x509_crt** cert_list, int* ncerts,
 /**
   * gnutls_certificate_set_x509_trust_mem - Used to add trusted CAs in a gnutls_certificate_credentials structure
   * @res: is an &gnutls_certificate_credentials structure.
-  * @CA: is a list of trusted CAs or a DER certificate
+  * @ca: is a list of trusted CAs or a DER certificate
   * @type: is DER or PEM
   *
   * This function adds the trusted CAs in order to verify client
@@ -1162,16 +1162,16 @@ static int parse_der_ca_mem( gnutls_x509_crt** cert_list, int* ncerts,
   *
   **/
 int gnutls_certificate_set_x509_trust_mem(gnutls_certificate_credentials res, 
-       const gnutls_datum *CA, gnutls_x509_crt_fmt type)
+       const gnutls_datum *ca, gnutls_x509_crt_fmt type)
 {
        int ret, ret2;
 
        if (type==GNUTLS_X509_FMT_DER)
                return parse_der_ca_mem( &res->x509_ca_list, &res->x509_ncas,
-                       CA->data, CA->size);
+                       ca->data, ca->size);
        else
                return parse_pem_ca_mem( &res->x509_ca_list, &res->x509_ncas,
-                       CA->data, CA->size);
+                       ca->data, ca->size);
 
        if ((ret2 = generate_rdn_seq(res)) < 0)
                return ret2;
@@ -1267,11 +1267,11 @@ int gnutls_certificate_set_x509_trust_file(gnutls_certificate_credentials res,
 
 #ifdef ENABLE_PKI
 
-static int parse_pem_crl_mem( gnutls_x509_crl** crl_list, int* ncrls, 
-       const char *input_crl, int input_crl_size)
+static int parse_pem_crl_mem( gnutls_x509_crl** crl_list, uint* ncrls, 
+       const opaque *input_crl, int input_crl_size)
 {
        int size, i;
-       const char *ptr;
+       const opaque *ptr;
        gnutls_datum tmp;
        int ret, count;
 
@@ -1343,8 +1343,8 @@ static int parse_pem_crl_mem( gnutls_x509_crl** crl_list, int* ncrls,
  * a gnutls_cert structure. This is only called if PKCS7 read fails.
  * returns the number of certificates parsed (1)
  */
-static int parse_der_crl_mem( gnutls_x509_crl** crl_list, int* ncrls, 
-       const char *input_crl, int input_crl_size)
+static int parse_der_crl_mem( gnutls_x509_crl** crl_list, uint* ncrls, 
+       const void *input_crl, int input_crl_size)
 {
        int i;
        gnutls_datum tmp;
@@ -1389,7 +1389,7 @@ static int parse_der_crl_mem( gnutls_x509_crl** crl_list, int* ncrls,
 /* Reads a DER or PEM CRL from memory
  */
 static 
-int read_crl_mem(gnutls_certificate_credentials res, const char *crl, int crl_size, 
+int read_crl_mem(gnutls_certificate_credentials res, const void *crl, int crl_size, 
        gnutls_x509_crt_fmt type)
 {
        int ret;

diff --git a/lib/x509/crl.c b/lib/x509/crl.c
index 114ec997fb206e9521055612b36d00cbedad36c6..69e76e865314c5e79568d6058c6016602a644937 100644 (file)
--- a/lib/x509/crl.c
+++ b/lib/x509/crl.c
@@ -97,7 +97,10 @@ int gnutls_x509_crl_import(gnutls_x509_crl crl, const gnutls_datum * data,
                           gnutls_x509_crt_fmt format)
 {
        int result = 0, need_free = 0;
-       gnutls_datum _data = { data->data, data->size };
+       gnutls_datum _data;
+       
+       _data.data = data->data;
+       _data.size = data->size;
 
        if (crl == NULL) {
                gnutls_assert();

diff --git a/lib/x509_b64.c b/lib/x509_b64.c
index fa76b07db42adbc84da2cb7dea08ecb1e757bc57..63a823f93eb148cc864280f13175c5d66143c921 100644 (file)
--- a/lib/x509_b64.c
+++ b/lib/x509_b64.c
@@ -55,7 +55,7 @@ static const uint8 asciitable[128] = {
        0xff, 0xff
 };
 
-inline static int encode(uint8 * result, const uint8 * data, int left)
+inline static int encode(char * result, const uint8 * data, int left)
 {
 
        int data_len;
@@ -103,7 +103,7 @@ inline static int encode(uint8 * result, const uint8 * data, int left)
  * result should be 3 bytes
  */
 #define TOASCII(c) (c < 127 ? asciitable[c] : 0xff)
-inline static int decode(uint8 * result, const uint8 * data)
+inline static int decode(uint8 * result, const opaque * data)
 {
        uint8 a1, a2;
        int ret = 3;

diff --git a/libextra/auth_srp.c b/libextra/auth_srp.c
index e6663e90572578718fcc65b1e7c741744abe2697..a3879ca8dc80b4d78d98d2d11ff2a54e78a74aa6 100644 (file)
--- a/libextra/auth_srp.c
+++ b/libextra/auth_srp.c
@@ -73,7 +73,8 @@ int _gnutls_gen_srp_server_kx(gnutls_session state, opaque ** data)
 {
        int ret;
        uint8 *data_n, *data_s;
-       uint8 *data_g, *username;
+       uint8 *data_g;
+       char *username;
        SRP_PWD_ENTRY *pwd_entry;
        SRP_SERVER_AUTH_INFO info;
        ssize_t data_size;

diff --git a/libextra/auth_srp_sb64.c b/libextra/auth_srp_sb64.c
index 4f6986033f62460d1855567ce5e0660292a32966..fc9df545a32f95be37f693c09373fe21f1d8a5d5 100644 (file)
--- a/libextra/auth_srp_sb64.c
+++ b/libextra/auth_srp_sb64.c
@@ -138,7 +138,7 @@ int _gnutls_sbase64_encode(uint8 * data, size_t data_size, uint8 ** result)
 {
        uint i,j;
        int ret, tmp;
-       char tmpres[4];
+       opaque tmpres[4];
        int mod = data_size % 3;
 
        ret = mod;

diff --git a/libextra/gnutls_openpgp.c b/libextra/gnutls_openpgp.c
index bce3ae1fef91a25feda4e627483a589b69a04abb..075b8666e7e68e3a958a4d9bbae17baf53e4a61e 100644 (file)
--- a/libextra/gnutls_openpgp.c
+++ b/libextra/gnutls_openpgp.c
@@ -71,7 +71,6 @@ _gnutls_map_cdk_rc( int rc )
     case CDK_Inv_Value: return GNUTLS_E_INVALID_REQUEST;
     default: return GNUTLS_E_INTERNAL_ERROR;
     }
-    return rc;
 }
 
 
@@ -786,7 +785,7 @@ gnutls_openpgp_add_keyring_file(gnutls_datum *keyring, const char *name)
  -*/
 int
 gnutls_openpgp_add_keyring_mem(gnutls_datum *keyring,
-                               const opaque *data, size_t len)
+                               const void *data, size_t len)
 {
     uint8 *blob;
     size_t nbytes = 0;

diff --git a/libextra/gnutls_openssl.c b/libextra/gnutls_openssl.c
index 0f034addae48ada8899fd9b89d0f44c378d519a1..373ca1c8f2f36fc9210737d717bcb490b10beb3e 100644 (file)
--- a/libextra/gnutls_openssl.c
+++ b/libextra/gnutls_openssl.c
@@ -18,8 +18,6 @@
 
 #include <config.h>
 
-#ifdef ENABLE_OPENSSL
-
 #include <gnutls/gnutls.h>
 #include <gcrypt.h>
 #include <stdio.h>
@@ -970,4 +968,3 @@ unsigned char *RIPEMD160(const unsigned char *buf, unsigned long len,
     return md;
 }
 
-#endif

diff --git a/libextra/openpgp/gnutls_openpgp.h b/libextra/openpgp/gnutls_openpgp.h
index 944523375ed25b8acafb3de2373a270f395e8e71..a6c5af575fbb1f5fbbba59a36a55a65c2a031661 100644 (file)
--- a/libextra/openpgp/gnutls_openpgp.h
+++ b/libextra/openpgp/gnutls_openpgp.h
@@ -39,7 +39,7 @@ int gnutls_openpgp_count_key_names(
      
 int gnutls_openpgp_add_keyring_mem(
     gnutls_datum *keyring,
-    const opaque *data,
+    const void *data,
     size_t len );
 
 int gnutls_openpgp_add_keyring_file(

diff --git a/libextra/openpgp/verify.c b/libextra/openpgp/verify.c
index 240874b838c91024e1535792f2ccd75582bc00d7..98eac30585167e5f298701f068ba7d8b8ca745d3 100644 (file)
--- a/libextra/openpgp/verify.c
+++ b/libextra/openpgp/verify.c
@@ -102,7 +102,7 @@ int gnutls_openpgp_key_verify_ring( gnutls_openpgp_key key,
                            unsigned int flags, unsigned int *verify)
 {
     int rc = 0;
-    unsigned int status = 0;
+    int status = 0;
   
     if( !key || !keyring ) {
         gnutls_assert();

diff --git a/src/common.h b/src/common.h
index 4b6ce0122baf7bf44fc4525b279e99d28a0c5812..6c8208803f33b447c21f047a10bc72319adb4c33 100644 (file)
--- a/src/common.h
+++ b/src/common.h
@@ -36,7 +36,7 @@ void parse_macs( char** macs, int nmacs, int *mac_priority);
 void parse_ciphers( char** ciphers, int nciphers, int* cipher_priority);
 void parse_protocols( char** protocols, int protocols_size, int* protocol_priority);
 
-void socket_init( void);
+void sockets_init( void);
 #ifndef HAVE_INET_NTOP
 const char *inet_ntop(int af, const void *src,
                              char *dst, size_t cnt);