Navigation

Changeset 214:5a1b93f59f8f in freeDiameter


Ignore:
Timestamp:
Feb 18, 2010, 3:20:00 PM (14 years ago)
Author:
Sebastien Decugis <sdecugis@nict.go.jp>
Branch:
default
Phase:
public
Message:

Added trace facility for GNUTLS calls

Files:
4 edited

Legend:

Unmodified
Added
Removed

  • freeDiameter/cnxctx.c

    r211 r214  
    943943
    944944                /* print the key exchange's algorithm name */
    945                 kx = gnutls_kx_get (session);
    946                 tmp = gnutls_kx_get_name (kx);
     945                GNUTLS_TRACE( kx = gnutls_kx_get (session) );
     946                GNUTLS_TRACE( tmp = gnutls_kx_get_name (kx) );
    947947                fd_log_debug("\t - Key Exchange: %s\n", tmp);
    948948
    949949                /* Check the authentication type used and switch
    950950                * to the appropriate. */
    951                 cred = gnutls_auth_get_type (session);
     951                GNUTLS_TRACE( cred = gnutls_auth_get_type (session) );
    952952                switch (cred)
    953953                {
    … …  
    10321032                return EINVAL;
    10331033       
    1034         cert_list = gnutls_certificate_get_peers (session, &cert_list_size);
     1034        GNUTLS_TRACE( cert_list = gnutls_certificate_get_peers (session, &cert_list_size) );
    10351035        if (cert_list == NULL)
    10361036                return EINVAL;
    … …  
    10541054                        fd_log_debug(" Certificate %d info:\n", i);
    10551055
    1056                         expiration_time = gnutls_x509_crt_get_expiration_time (cert);
    1057                         activation_time = gnutls_x509_crt_get_activation_time (cert);
     1056                        GNUTLS_TRACE( expiration_time = gnutls_x509_crt_get_expiration_time (cert) );
     1057                        GNUTLS_TRACE( activation_time = gnutls_x509_crt_get_activation_time (cert) );
    10581058
    10591059                        fd_log_debug("\t - Certificate is valid since: %s", ctime (&activation_time));
    … …  
    10741074
    10751075                        /* Extract some of the public key algorithm's parameters */
    1076                         algo = gnutls_x509_crt_get_pk_algorithm (cert, &bits);
     1076                        GNUTLS_TRACE( algo = gnutls_x509_crt_get_pk_algorithm (cert, &bits) );
    10771077                        fd_log_debug("\t - Certificate public key: %s\n",
    10781078                              gnutls_pk_algorithm_get_name (algo));
    … …  
    10831083
    10841084                        size = sizeof (dn);
    1085                         gnutls_x509_crt_get_dn (cert, dn, &size);
     1085                        GNUTLS_TRACE( gnutls_x509_crt_get_dn (cert, dn, &size) );
    10861086                        fd_log_debug("\t - DN: %s\n", dn);
    10871087
    10881088                        size = sizeof (dn);
    1089                         gnutls_x509_crt_get_issuer_dn (cert, dn, &size);
     1089                        GNUTLS_TRACE( gnutls_x509_crt_get_issuer_dn (cert, dn, &size) );
    10901090                        fd_log_debug("\t - Issuer's DN: %s\n", dn);
    10911091
    1092                         gnutls_x509_crt_deinit (cert);
     1092                        GNUTLS_TRACE( gnutls_x509_crt_deinit (cert) );
    10931093                }
    10941094        }
    … …  
    11021102                CHECK_GNUTLS_DO( gnutls_x509_crt_import (cert, &cert_list[i], GNUTLS_X509_FMT_DER), return EINVAL);
    11031103               
    1104                 deadline = gnutls_x509_crt_get_expiration_time(cert);
     1104                GNUTLS_TRACE( deadline = gnutls_x509_crt_get_expiration_time(cert) );
    11051105                if ((deadline != (time_t)-1) && (deadline < now)) {
    11061106                        if (TRACE_BOOL(INFO)) {
    … …  
    11111111                }
    11121112               
    1113                 deadline = gnutls_x509_crt_get_activation_time(cert);
     1113                GNUTLS_TRACE( deadline = gnutls_x509_crt_get_activation_time(cert) );
    11141114                if ((deadline != (time_t)-1) && (deadline > now)) {
    11151115                        if (TRACE_BOOL(INFO)) {
    … …  
    11301130                }
    11311131               
    1132                 gnutls_x509_crt_deinit (cert);
     1132                GNUTLS_TRACE( gnutls_x509_crt_deinit (cert) );
    11331133        }
    11341134
    … …  
    11651165        } else {
    11661166                /* Set the transport pointer passed to push & pull callbacks */
    1167                 gnutls_transport_set_ptr( conn->cc_tls_para.session, (gnutls_transport_ptr_t) conn );
     1167                GNUTLS_TRACE( gnutls_transport_set_ptr( conn->cc_tls_para.session, (gnutls_transport_ptr_t) conn ) );
    11681168
    11691169                /* Set the push and pull callbacks */
    1170                 gnutls_transport_set_pull_function(conn->cc_tls_para.session, (void *)fd_cnx_s_recv);
    1171                 gnutls_transport_set_push_function(conn->cc_tls_para.session, (void *)fd_cnx_s_send);
     1170                GNUTLS_TRACE( gnutls_transport_set_pull_function(conn->cc_tls_para.session, (void *)fd_cnx_s_recv) );
     1171                GNUTLS_TRACE( gnutls_transport_set_push_function(conn->cc_tls_para.session, (void *)fd_cnx_s_send) );
    11721172        }
    11731173
    … …  
    12221222        CHECK_PARAMS( gnutls_certificate_type_get (conn->cc_tls_para.session) == GNUTLS_CRT_X509 );
    12231223       
    1224         *cert_list = gnutls_certificate_get_peers (conn->cc_tls_para.session, cert_list_size);
     1224        GNUTLS_TRACE( *cert_list = gnutls_certificate_get_peers (conn->cc_tls_para.session, cert_list_size) );
    12251225        if (*cert_list == NULL) {
    12261226                TRACE_DEBUG(INFO, "No certificate was provided by remote peer / an error occurred.");
    … …  
    14071407                        fd_sctps_gnutls_deinit_others(conn);
    14081408                        if (conn->cc_tls_para.session) {
    1409                                 gnutls_deinit(conn->cc_tls_para.session);
     1409                                GNUTLS_TRACE( gnutls_deinit(conn->cc_tls_para.session) );
    14101410                                conn->cc_tls_para.session = NULL;
    14111411                        }
    … …  
    14351435                        /* Free the resources of the TLS session */
    14361436                        if (conn->cc_tls_para.session) {
    1437                                 gnutls_deinit(conn->cc_tls_para.session);
     1437                                GNUTLS_TRACE( gnutls_deinit(conn->cc_tls_para.session) );
    14381438                                conn->cc_tls_para.session = NULL;
    14391439                        }

  • freeDiameter/main.c

    r213 r214  
    7575       
    7676        /* Initialize gcrypt and gnutls */
    77         (void) gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
    78         (void) gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);
    79         (void) gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0);
     77        GNUTLS_TRACE( (void) gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread) );
     78        GNUTLS_TRACE( (void) gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0) );
     79        GNUTLS_TRACE( (void) gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0) );
    8080        CHECK_GNUTLS_DO( gnutls_global_init(), return EINVAL );
    8181        if ( ! gnutls_check_version(GNUTLS_VERSION) ) {
    … …  
    173173        CHECK_FCT_DO( fd_thr_term(&sig_th), /* reclaim resources of the signal thread */ );
    174174       
    175         gnutls_global_deinit();
     175        GNUTLS_TRACE( gnutls_global_deinit() );
    176176       
    177177        fd_log_debug(FD_PROJECT_BINARY " daemon is terminated.\n");

  • freeDiameter/sctps.c

    r209 r214  
    212212{
    213213        /* Set the transport pointer passed to push & pull callbacks */
    214         gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t) ctx );
     214        GNUTLS_TRACE( gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t) ctx ) );
    215215       
    216216        /* Reset the low water value, since we don't use sockets */
    217         gnutls_transport_set_lowat( session, 0 );
     217        GNUTLS_TRACE( gnutls_transport_set_lowat( session, 0 ) );
    218218       
    219219        /* Set the push and pull callbacks */
    220         gnutls_transport_set_pull_function(session, sctps_pull);
    221         gnutls_transport_set_push_function(session, sctps_push);
     220        GNUTLS_TRACE( gnutls_transport_set_pull_function(session, sctps_pull) );
     221        GNUTLS_TRACE( gnutls_transport_set_push_function(session, sctps_push) );
    222222
    223223        return;
    … …  
    242242};
    243243
    244 /* The level at which we debug session resuming */
    245 #define SR_LEVEL (FULL + 1)
    246 
    247244/* Initialize the store area for a connection */
    248245static int store_init(struct cnxctx * conn)
    … …  
    326323        int ret = 0;
    327324       
     325        TRACE_DEBUG( GNUTLS_DBG_LEVEL, "Callback: %s", __PRETTY_FUNCTION__ );
    328326        CHECK_PARAMS_DO( sto && key.data && data.data, return -1 );
    329327       
    330328        CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
    331         TRACE_DEBUG_BUFFER(SR_LEVEL, "Session store [key ", key.data, key.size, "]");
     329        TRACE_DEBUG_BUFFER(GNUTLS_DBG_LEVEL, "Session store [key ", key.data, key.size, "]");
    332330       
    333331        li = find_or_next(sto, key, &match);
    … …  
    340338                        ret = -1;
    341339                } else {
    342                         TRACE_DEBUG(SR_LEVEL, "GnuTLS tried to store a session with same key and same data, skipped.");
     340                        TRACE_DEBUG(GNUTLS_DBG_LEVEL, "GnuTLS tried to store a session with same key and same data, skipped.");
    343341                }
    344342                goto out;
    … …  
    375373        int ret = 0;
    376374       
     375        TRACE_DEBUG( GNUTLS_DBG_LEVEL, "Callback: %s", __PRETTY_FUNCTION__ );
    377376        CHECK_PARAMS_DO( sto && key.data, return -1 );
    378377       
    379378        CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
    380         TRACE_DEBUG_BUFFER(SR_LEVEL, "Session delete [key ", key.data, key.size, "]");
     379        TRACE_DEBUG_BUFFER(GNUTLS_DBG_LEVEL, "Session delete [key ", key.data, key.size, "]");
    381380       
    382381        li = find_or_next(sto, key, &match);
    … …  
    407406        gnutls_datum_t error = { NULL, 0 };
    408407
     408        TRACE_DEBUG( GNUTLS_DBG_LEVEL, "Callback: %s", __PRETTY_FUNCTION__ );
    409409        CHECK_PARAMS_DO( sto && key.data, return error );
    410410
    411411        CHECK_POSIX_DO( pthread_rwlock_rdlock(&sto->lock), return error );
    412         TRACE_DEBUG_BUFFER(SR_LEVEL, "Session fetch [key ", key.data, key.size, "]");
     412        TRACE_DEBUG_BUFFER(GNUTLS_DBG_LEVEL, "Session fetch [key ", key.data, key.size, "]");
    413413       
    414414        li = find_or_next(sto, key, &match);
    415415        if (match) {
    416416                sr = (struct sr_data *)li;
    417                 CHECK_MALLOC_DO(res.data = gnutls_malloc(sr->data.size), goto out );
     417                GNUTLS_TRACE( CHECK_MALLOC_DO(res.data = gnutls_malloc(sr->data.size), goto out ) );
    418418                res.size = sr->data.size;
    419419                memcpy(res.data, sr->data.data, res.size);
    420420        }
    421421out:   
    422         TRACE_DEBUG(SR_LEVEL, "Fetched (%p, %d) from store %p", res.data, res.size, sto);
     422        TRACE_DEBUG(GNUTLS_DBG_LEVEL, "Fetched (%p, %d) from store %p", res.data, res.size, sto);
    423423        CHECK_POSIX_DO( pthread_rwlock_unlock(&sto->lock), return error);
    424424        return res;
    … …  
    430430        TRACE_ENTRY("%p", conn);
    431431       
    432         gnutls_db_set_retrieve_function(session, sr_fetch);
    433         gnutls_db_set_remove_function  (session, sr_remove);
    434         gnutls_db_set_store_function   (session, sr_store);
    435         gnutls_db_set_ptr              (session, conn->cc_sctps_data.sess_store);
     432        GNUTLS_TRACE( gnutls_db_set_retrieve_function(session, sr_fetch));
     433        GNUTLS_TRACE( gnutls_db_set_remove_function  (session, sr_remove));
     434        GNUTLS_TRACE( gnutls_db_set_store_function   (session, sr_store));
     435        GNUTLS_TRACE( gnutls_db_set_ptr              (session, conn->cc_sctps_data.sess_store));
    436436       
    437437        return;
    … …  
    456456        CHECK_GNUTLS_DO( gnutls_handshake( ctx->session ), return NULL);
    457457                       
    458         resumed = gnutls_session_is_resumed(ctx->session);
     458        GNUTLS_TRACE( resumed = gnutls_session_is_resumed(ctx->session) );
    459459        if (!resumed) {
    460460                /* Check the credentials here also */
    … …  
    530530                CHECK_GNUTLS_DO( gnutls_session_get_data2(conn->cc_tls_para.session, &master_data), return ENOMEM );
    531531                /* For debug: */
    532                 if (TRACE_BOOL(SR_LEVEL)) {
     532                if (TRACE_BOOL(GNUTLS_DBG_LEVEL)) {
    533533                        uint8_t  id[256];
    534534                        size_t   ids = sizeof(id);
    535535                        CHECK_GNUTLS_DO( gnutls_session_get_id(conn->cc_tls_para.session, id, &ids), /* continue */ );
    536                         TRACE_DEBUG_BUFFER(SR_LEVEL, "Master session id: [", id, ids, "]");
     536                        TRACE_DEBUG_BUFFER(GNUTLS_DBG_LEVEL, "Master session id: [", id, ids, "]");
    537537                }
    538538        }
    … …  
    559559        /* We can now release the memory of master session data if any */
    560560        if (conn->cc_tls_para.mode == GNUTLS_CLIENT) {
    561                 gnutls_free(master_data.data);
     561                GNUTLS_TRACE( gnutls_free(master_data.data) );
    562562        }
    563563       
    … …  
    639639        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    640640                if (conn->cc_sctps_data.array[i].session) {
    641                         gnutls_deinit(conn->cc_sctps_data.array[i].session);
     641                        GNUTLS_TRACE( gnutls_deinit(conn->cc_sctps_data.array[i].session) );
    642642                        conn->cc_sctps_data.array[i].session = NULL;
    643643                }
    … …  
    679679                free(conn->cc_sctps_data.array[i].partial.buf);
    680680                if (conn->cc_sctps_data.array[i].session) {
    681                         gnutls_deinit(conn->cc_sctps_data.array[i].session);
     681                        GNUTLS_TRACE( gnutls_deinit(conn->cc_sctps_data.array[i].session) );
    682682                        conn->cc_sctps_data.array[i].session = NULL;
    683683                }

  • include/freeDiameter/freeDiameter.h

    r162 r214  
    4747#endif /* GNUTLS_VERSION */
    4848
     49/* GNUTLS calls debug level */
     50#ifndef GNUTLS_DBG_LEVEL
     51#define GNUTLS_DBG_LEVEL ANNOYING
     52#endif /* GNUTLS_DBG_LEVEL */
     53
    4954/* Check the return value of a GNUTLS function, log and propagate */
    5055#define CHECK_GNUTLS_DO( __call__, __fallback__ ) {                                             \
    5156        int __ret__;                                                                            \
    52         TRACE_DEBUG_ALL( "Check FCT: " #__call__ );                                             \
     57        TRACE_DEBUG(GNUTLS_DBG_LEVEL, "GNUTLS call: " #__call__ );                              \
    5358        __ret__ = (__call__);                                                                   \
    5459        if (__ret__ < 0) {                                                                      \
    … …  
    5762        }                                                                                       \
    5863}
     64
     65/* For GNUTLS routines that do not return a value */
     66#define GNUTLS_TRACE( __call__) {                                       \
     67        TRACE_DEBUG(GNUTLS_DBG_LEVEL, "GNUTLS call: " #__call__ );      \
     68        (__call__);                                                     \
     69}
     70
    5971
    6072
Note: See TracChangeset for help on using the changeset viewer.