Changeset 29:5ba91682f0bc in freeDiameter

Timestamp:

Oct 28, 2009, 3:19:50 PM (14 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Added a test for cnxctx (tbc) and fixed some bugs

Files:

• contrib/ca_script/Makefile (modified) (2 diffs)
• freeDiameter/cnxctx.c (modified) (12 diffs)
• freeDiameter/cnxctx.h (modified) (2 diffs)
• freeDiameter/fD.h (modified) (3 diffs)
• freeDiameter/p_psm.c (modified) (2 diffs)
• freeDiameter/peers.c (modified) (4 diffs)
• freeDiameter/sctp.c (modified) (33 diffs)
• freeDiameter/sctps.c (modified) (15 diffs)
• freeDiameter/server.c (modified) (2 diffs)
• freeDiameter/tests/CMakeLists.txt (modified) (1 diff)
• freeDiameter/tests/testcnx.c (added)
• freeDiameter/tests/tests.h (modified) (3 diffs)
• include/freeDiameter/libfreeDiameter.h (modified) (2 diffs)

contrib/ca_script/Makefile

@@ -32 +32 @@
 O = WIDE
 OU = "AAA WG"
+
+#Default lifetime
+DAYS = 365
 
 #Values for the CA
@@ -130 +133 @@
         @openssl ca $(CONFIG) -in $(DIR)/clients/csr/$(name).csr \
                 -out $(DIR)/clients/certs/$(name).cert \
+                -days $(DAYS) \
                 -batch
         @ln -s $(DIR)/clients/certs/$(name).cert $(DIR)/certs/`openssl x509 -noout -hash < $(DIR)/clients/certs/$(name).cert`.0

freeDiameter/cnxctx.c

@@ -397 +397 @@
 }
 
+/* Return the protocol of a connection */
+int fd_cnx_getproto(struct cnxctx * conn)
+{
+        CHECK_PARAMS_DO( conn, return 0 );
+        return conn->cc_proto;
+}
+
+/* Return the TLS state of a connection */
+int fd_cnx_getTLS(struct cnxctx * conn)
+{
+        CHECK_PARAMS_DO( conn, return 0 );
+        return conn->cc_tls;
+}
+
 /* Get the list of endpoints (IP addresses) of the local and remote peers on this connection */
 int fd_cnx_getendpoints(struct cnxctx * conn, struct fd_list * local, struct fd_list * remote)
@@ -474 +488 @@
         
         TRACE_ENTRY("%p", arg);
-        
         CHECK_PARAMS_DO(conn && (conn->cc_socket > 0), goto out);
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Receiver (%d) TCP/noTLS)", conn->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
         ASSERT( conn->cc_proto == IPPROTO_TCP );
         ASSERT( conn->cc_tls == 0 );
@@ -548 +569 @@
         
         TRACE_ENTRY("%p", arg);
-        
         CHECK_PARAMS_DO(conn && (conn->cc_socket > 0), goto out);
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Receiver (%d) SCTP/noTLS)", conn->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
         ASSERT( conn->cc_proto == IPPROTO_SCTP );
         ASSERT( conn->cc_tls == 0 );
@@ -607 +635 @@
 int fd_tls_rcvthr_core(struct cnxctx * conn, gnutls_session_t session)
 {
-        /* No guaranty that GnuTLS preserves the message boundaries, so we re-build it as in TCP */
+        /* No guarantee that GnuTLS preserves the message boundaries, so we re-build it as in TCP */
         do {
                 uint8_t header[4];
@@ -616 +644 @@
 
                 do {
-                        ret = fd_tls_recv_handle_error(conn, conn->cc_tls_para.session, &header[received], sizeof(header) - received);
+                        ret = fd_tls_recv_handle_error(conn, session, &header[received], sizeof(header) - received);
                         if (ret == 0) {
                                 /* The connection is closed */
@@ -640 +668 @@
                 while (received < length) {
                         pthread_cleanup_push(free, newmsg); /* In case we are canceled, clean the partialy built buffer */
-                        ret = fd_tls_recv_handle_error(conn, conn->cc_tls_para.session, newmsg + received, length - received);
+                        ret = fd_tls_recv_handle_error(conn, session, newmsg + received, length - received);
                         pthread_cleanup_pop(0);
 
@@ -664 +692 @@
         
         TRACE_ENTRY("%p", arg);
-        
         CHECK_PARAMS_DO(conn && (conn->cc_socket > 0), goto error);
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Receiver (%d) TLS/ single stream)", conn->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
         ASSERT( conn->cc_tls == 1 );
         ASSERT( Target_Queue(conn) );
@@ -709 +744 @@
 
 /* Prepare a gnutls session object for handshake */
-int fd_tls_prepare(gnutls_session_t * session, int mode, char * priority)
+int fd_tls_prepare(gnutls_session_t * session, int mode, char * priority, void * alt_creds)
 {
         /* Create the master session context */
@@ -724 +759 @@
 
         /* Set the credentials of this side of the connection */
-        CHECK_GNUTLS_DO( gnutls_credentials_set (*session, GNUTLS_CRD_CERTIFICATE, fd_g_config->cnf_sec_data.credentials), return EINVAL );
+        CHECK_GNUTLS_DO( gnutls_credentials_set (*session, GNUTLS_CRD_CERTIFICATE, alt_creds ?: fd_g_config->cnf_sec_data.credentials), return EINVAL );
 
         /* Request the remote credentials as well */
@@ -735 +770 @@
 
 /* TLS handshake a connection; no need to have called start_clear before. Reception is active if handhsake is successful */
-int fd_cnx_handshake(struct cnxctx * conn, int mode, char * priority)
+int fd_cnx_handshake(struct cnxctx * conn, int mode, char * priority, void * alt_creds)
 {
         TRACE_ENTRY( "%p %d", conn, mode);
@@ -750 +785 @@
         
         /* Prepare the master session credentials and priority */
-        CHECK_FCT( fd_tls_prepare(&conn->cc_tls_para.session, mode, priority) );
+        CHECK_FCT( fd_tls_prepare(&conn->cc_tls_para.session, mode, priority, alt_creds) );
 
         /* Special case: multi-stream TLS is not natively managed in GNU TLS, we use a wrapper library */
@@ -801 +836 @@
 #ifndef DISABLE_SCTP
                 /* Resume all additional sessions from the master one. */
-                CHECK_FCT(fd_sctps_handshake_others(conn, priority));
-                
+                CHECK_FCT(fd_sctps_handshake_others(conn, priority, alt_creds));
+                
+                /* Mark the connection as protected from here */
+                conn->cc_tls = 1;
+
                 /* Start decrypting the messages from all threads and queuing them in target queue */
                 CHECK_FCT(fd_sctps_startthreads(conn));
 #endif /* DISABLE_SCTP */
         } else {
+                /* Mark the connection as protected from here */
+                conn->cc_tls = 1;
+
                 /* Start decrypting the data */
                 CHECK_POSIX( pthread_create( &conn->cc_rcvthr, NULL, rcvthr_tls_single, conn ) );
         }
-
+        
         return 0;
 }

freeDiameter/cnxctx.h

@@ -79 +79 @@
 /* TLS */
 int fd_tls_rcvthr_core(struct cnxctx * conn, gnutls_session_t session);
-int fd_tls_prepare(gnutls_session_t * session, int mode, char * priority);
+int fd_tls_prepare(gnutls_session_t * session, int mode, char * priority, void * alt_creds);
 
 /* TCP */
@@ -114 +114 @@
 
 int fd_sctps_init(struct cnxctx * conn);
-int fd_sctps_handshake_others(struct cnxctx * conn, char * priority);
+int fd_sctps_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds);
 int fd_sctps_startthreads(struct cnxctx * conn);
 void fd_sctps_stopthreads(struct cnxctx * conn);

freeDiameter/fD.h

@@ -177 +177 @@
         (((int)(_e) >= FDEVP_DUMP_ALL) && ((int)(_e) <= FDEVP_PSM_TIMEOUT))
 
+/* The data structure for FDEVP_CNX_INCOMING events */
+struct cnx_incoming {
+        struct msg      * cer;          /* the CER message received on this connection */
+        struct cnxctx   * cnx;          /* The connection context */
+        int               validate;     /* The peer is new, it must be validated (by an extension) or error CEA to be sent */
+};
+
 /* Structure to store a sent request */
 struct sentreq {
@@ -190 +197 @@
 int  fd_peer_alloc(struct fd_peer ** ptr);
 int  fd_peer_free(struct fd_peer ** ptr);
-int fd_peer_handle_newCER( struct msg ** cer, struct cnxctx ** cnx, int tls_done );
+int fd_peer_handle_newCER( struct msg ** cer, struct cnxctx ** cnx );
 /* fd_peer_add declared in freeDiameter.h */
+int fd_peer_validate( struct fd_peer * peer );
 
 /* Peer expiry */
@@ -216 +224 @@
 struct cnxctx * fd_cnx_cli_connect_tcp(sSA * sa, socklen_t addrlen);
 struct cnxctx * fd_cnx_cli_connect_sctp(int no_ip6, uint16_t port, struct fd_list * list);
+int             fd_cnx_start_clear(struct cnxctx * conn, int loop);
+int             fd_cnx_handshake(struct cnxctx * conn, int mode, char * priority, void * alt_creds);
 char *          fd_cnx_getid(struct cnxctx * conn);
-int             fd_cnx_start_clear(struct cnxctx * conn, int loop);
-int             fd_cnx_handshake(struct cnxctx * conn, int mode, char * priority);
+int             fd_cnx_getproto(struct cnxctx * conn);
+int             fd_cnx_getTLS(struct cnxctx * conn);
 int             fd_cnx_getcred(struct cnxctx * conn, const gnutls_datum_t **cert_list, unsigned int *cert_list_size);
 int             fd_cnx_getendpoints(struct cnxctx * conn, struct fd_list * local, struct fd_list * remote);

freeDiameter/p_psm.c

@@ -209 +209 @@
         }
         
+        /* A new connection was established and CER containing this peer id was received */
+        if (event == FDEVP_CNX_INCOMING) {
+                struct cnx_incoming * params = ev_data;
+                ASSERT(params);
+                
+                switch (peer->p_hdr.info.pi_state) {
+                        case STATE_CLOSED:
+                                TODO("Handle the CER, validate the peer if needed (and set expiry), set the alt_fifo in the connection, reply a CEA, eventually handshake, move to OPEN or REOPEN state");
+                                break;
+                                
+                        case STATE_WAITCNXACK:
+                        case STATE_WAITCEA:
+                                TODO("Election");
+                                break;
+                                
+                        default:
+                                TODO("Reply with error CEA");
+                                TODO("Close the connection");
+                                /* reject_incoming_connection */
+                        
+                }
+                
+                free(ev_data);
+                goto psm_loop;
+        }
+        
         /* MSG_RECEIVED: fd_p_expi_update(struct fd_peer * peer ) */
         /* If timeout or OPEN : call cb if defined */
@@ -223 +249 @@
 psm_end:
         pthread_cleanup_pop(1); /* set STATE_ZOMBIE */
-        pthread_detach(peer->p_psm);
         peer->p_psm = (pthread_t)NULL;
+        pthread_detach(pthread_self());
         return NULL;
 }       

freeDiameter/peers.c

@@ -376 +376 @@
 
 /* Handle an incoming CER request on a new connection */
-int fd_peer_handle_newCER( struct msg ** cer, struct cnxctx ** cnx, int tls_done )
+int fd_peer_handle_newCER( struct msg ** cer, struct cnxctx ** cnx )
 {
         struct msg * msg;
@@ -385 +385 @@
         struct fd_list * li;
         int found = 0;
+        int ret = 0;
         struct fd_peer * peer;
-        
-        TRACE_ENTRY("%p %p %d", cer, cnx, tls_done);
+        struct cnx_incoming * ev_data;
+        
+        TRACE_ENTRY("%p %p", cer, cnx);
         CHECK_PARAMS(cer && *cer && cnx && *cnx);
         
@@ -411 +413 @@
         
         if (!found) {
-                
-                TODO("Create a new peer entry with this diameter id (pf_responder = 1)");
-                TODO("Upgrade the lock to wr");
-                TODO("Add the new peer in the list");
-                TODO("Release the wr lock");
-                TODO("Start the peer PSM, which will have to validate if this peer is authorized to connect, and so on");
-        }
-                
-        TODO("Send the new connection event to the peer SM with the appropriate data: msg, conn, tls_done, found");
-        /* FDEVP_CNX_INCOMING */
-        
-        /* Reset the "out" parameters, so that they are not cleanup on function return. */
-        *cer = NULL;
-        *cnx = NULL;
-        
+                /* Create a new peer entry for this new remote peer */
+                peer = NULL;
+                CHECK_FCT_DO( ret = fd_peer_alloc(&peer), goto out );
+                
+                /* Set the peer Diameter Id and the responder flag parameters */
+                CHECK_MALLOC_DO( peer->p_hdr.info.pi_diamid = malloc(avp_hdr->avp_value->os.len + 1), { ret = ENOMEM; goto out; } );
+                CHECK_MALLOC_DO( peer->p_dbgorig = strdup(fd_cnx_getid(*cnx)), { ret = ENOMEM; goto out; } );
+                peer->p_flags.pf_responder = 1;
+                
+                /* Upgrade the lock to write lock */
+                CHECK_POSIX_DO( ret = pthread_rwlock_wrlock(&fd_g_peers_rw), goto out );
+                
+                /* Insert the new peer in the list (the PSM will take care of setting the expiry after validation) */
+                fd_list_insert_before( li, &peer->p_hdr.chain );
+                
+                /* Release the write lock */
+                CHECK_POSIX_DO( ret = pthread_rwlock_unlock(&fd_g_peers_rw), goto out );
+                
+                /* Start the PSM, which will receive the event bellow */
+                CHECK_FCT_DO( ret = fd_psm_begin(peer), goto out );
+        }
+                
+        /* Send the new connection event to the PSM */
+        CHECK_MALLOC_DO( ev_data = malloc(sizeof(struct cnx_incoming)), { ret = ENOMEM; goto out; } );
+        memset(ev_data, 0, sizeof(ev_data));
+        
+        ev_data->cer = msg;
+        ev_data->cnx = *cnx;
+        ev_data->validate = !found;
+        
+        CHECK_FCT_DO( ret = fd_event_send(peer->p_events, FDEVP_CNX_INCOMING, sizeof(ev_data), ev_data), goto out );
+        
+out:    
         CHECK_POSIX( pthread_rwlock_unlock(&fd_g_peers_rw) );
 
-        
-        TODO("(later if not tls_done) handshake or start_clear(.., 1) ");
-        
-        return 0;
+        if (ret == 0) {
+                /* Reset the "out" parameters, so that they are not cleanup on function return. */
+                *cer = NULL;
+                *cnx = NULL;
+        }
+        
+        return ret;
 }
 
@@ -441 +464 @@
         return ENOTSUP;
 }
+
+/* Validate a peer by calling the callbacks in turn -- return 0 if the peer is validated, ! 0 in case of error or if the peer is rejected */
+int fd_peer_validate( struct fd_peer * peer )
+{
+        TODO("Default to reject");
+        TODO("Call all callbacks in turn");
+        TODO("Save cb2 in the peer if needed");
+        return ENOTSUP;
+}

freeDiameter/sctp.c

@@ -45 +45 @@
 #endif /* CMSG_BUF_LEN */
 
+/* Level of SCTP-specific traces */
+#ifdef DEBUG_SCTP
+#define SCTP_LEVEL      FULL
+#else /* DEBUG_SCTP */
+#define SCTP_LEVEL      ANNOYING
+#endif /* DEBUG_SCTP */
+
 /* Pre-binding socket options -- # streams read in config */
 static int fd_setsockopt_prebind(int sk)
 {
-        #ifdef DEBUG_SCTP
         socklen_t sz;
-        #endif /* DEBUG_SCTP */
         
         TRACE_ENTRY( "%d", sk);
@@ -74 +79 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(event)) );
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(event);
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_EVENTS, &event, &sz) );
-                if (sz != sizeof(event))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(event));
-                        return ENOTSUP;
-                }
-                
-                TRACE_DEBUG(FULL, "SCTP_EVENTS : sctp_data_io_event          : %hhu", event.sctp_data_io_event);
-                TRACE_DEBUG(FULL, "              sctp_association_event      : %hhu", event.sctp_association_event);
-                TRACE_DEBUG(FULL, "              sctp_address_event          : %hhu", event.sctp_address_event);
-                TRACE_DEBUG(FULL, "              sctp_send_failure_event     : %hhu", event.sctp_send_failure_event);
-                TRACE_DEBUG(FULL, "              sctp_peer_error_event       : %hhu", event.sctp_peer_error_event);
-                TRACE_DEBUG(FULL, "              sctp_shutdown_event         : %hhu", event.sctp_shutdown_event);
-                TRACE_DEBUG(FULL, "              sctp_partial_delivery_event : %hhu", event.sctp_partial_delivery_event);
-                TRACE_DEBUG(FULL, "              sctp_adaptation_layer_event : %hhu", event.sctp_adaptation_layer_event);
-                // TRACE_DEBUG(FULL, "             sctp_authentication_event    : %hhu", event.sctp_authentication_event);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(event);
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_EVENTS, &event, &sz) );
+                        if (sz != sizeof(event))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(event));
+                                return ENOTSUP;
+                        }
+
+                        fd_log_debug( "SCTP_EVENTS : sctp_data_io_event          : %hhu\n", event.sctp_data_io_event);
+                        fd_log_debug( "              sctp_association_event      : %hhu\n", event.sctp_association_event);
+                        fd_log_debug( "              sctp_address_event          : %hhu\n", event.sctp_address_event);
+                        fd_log_debug( "              sctp_send_failure_event     : %hhu\n", event.sctp_send_failure_event);
+                        fd_log_debug( "              sctp_peer_error_event       : %hhu\n", event.sctp_peer_error_event);
+                        fd_log_debug( "              sctp_shutdown_event         : %hhu\n", event.sctp_shutdown_event);
+                        fd_log_debug( "              sctp_partial_delivery_event : %hhu\n", event.sctp_partial_delivery_event);
+                        fd_log_debug( "              sctp_adaptation_layer_event : %hhu\n", event.sctp_adaptation_layer_event);
+                        // fd_log_debug( "             sctp_authentication_event    : %hhu\n", event.sctp_authentication_event);
+                }
                 
         }
@@ -101 +106 @@
                 memset(&init, 0, sizeof(init));
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(init);
-                
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, &sz)  );
-                if (sz != sizeof(init))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(init));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_INITMSG : sinit_num_ostreams   : %hu", init.sinit_num_ostreams);
-                TRACE_DEBUG(FULL, "                   sinit_max_instreams  : %hu", init.sinit_max_instreams);
-                TRACE_DEBUG(FULL, "                   sinit_max_attempts   : %hu", init.sinit_max_attempts);
-                TRACE_DEBUG(FULL, "                   sinit_max_init_timeo : %hu", init.sinit_max_init_timeo);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(init);
+
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, &sz)  );
+                        if (sz != sizeof(init))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(init));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_INITMSG : sinit_num_ostreams   : %hu\n", init.sinit_num_ostreams);
+                        fd_log_debug( "                   sinit_max_instreams  : %hu\n", init.sinit_max_instreams);
+                        fd_log_debug( "                   sinit_max_attempts   : %hu\n", init.sinit_max_attempts);
+                        fd_log_debug( "                   sinit_max_init_timeo : %hu\n", init.sinit_max_init_timeo);
+                }
 
                 /* Set the init options -- need to receive SCTP_COMM_UP to confirm the requested parameters */
@@ -124 +129 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, sizeof(init))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_INITMSG : sinit_num_ostreams   : %hu", init.sinit_num_ostreams);
-                TRACE_DEBUG(FULL, "                   sinit_max_instreams  : %hu", init.sinit_max_instreams);
-                TRACE_DEBUG(FULL, "                   sinit_max_attempts   : %hu", init.sinit_max_attempts);
-                TRACE_DEBUG(FULL, "                   sinit_max_init_timeo : %hu", init.sinit_max_init_timeo);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, &sz)  );
+                        fd_log_debug( "New SCTP_INITMSG : sinit_num_ostreams   : %hu\n", init.sinit_num_ostreams);
+                        fd_log_debug( "                   sinit_max_instreams  : %hu\n", init.sinit_max_instreams);
+                        fd_log_debug( "                   sinit_max_attempts   : %hu\n", init.sinit_max_attempts);
+                        fd_log_debug( "                   sinit_max_init_timeo : %hu\n", init.sinit_max_init_timeo);
+                }
         }
         
@@ -139 +144 @@
                 int nofrag;
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(nofrag);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, &sz)  );
-                if (sz != sizeof(nofrag))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(nofrag));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_DISABLE_FRAGMENTS value : %s", nofrag ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(nofrag);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, &sz)  );
+                        if (sz != sizeof(nofrag))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(nofrag));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_DISABLE_FRAGMENTS value : %s\n", nofrag ? "true" : "false");
+                }
 
                 nofrag = 0;     /* We turn ON the fragmentation */
@@ -156 +161 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, sizeof(nofrag))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_DISABLE_FRAGMENTS value : %s", nofrag ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, &sz)  );
+                        fd_log_debug( "New SCTP_DISABLE_FRAGMENTS value : %s\n", nofrag ? "true" : "false");
+                }
         }
         #else /* SCTP_DISABLE_FRAGMENTS */
@@ -173 +178 @@
                 memset(&rtoinfo, 0, sizeof(rtoinfo));
 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(rtoinfo);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, &sz)  );
-                if (sz != sizeof(rtoinfo))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(rtoinfo));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_RTOINFO : srto_initial : %u", rtoinfo.srto_initial);
-                TRACE_DEBUG(FULL, "                   srto_max     : %u", rtoinfo.srto_max);
-                TRACE_DEBUG(FULL, "                   srto_min     : %u", rtoinfo.srto_min);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(rtoinfo);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, &sz)  );
+                        if (sz != sizeof(rtoinfo))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(rtoinfo));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_RTOINFO : srto_initial : %u\n", rtoinfo.srto_initial);
+                        fd_log_debug( "                   srto_max     : %u\n", rtoinfo.srto_max);
+                        fd_log_debug( "                   srto_min     : %u\n", rtoinfo.srto_min);
+                }
 
                 rtoinfo.srto_max     = fd_g_config->cnf_timer_tw * 500 - 1000;  /* Maximum retransmit timer (in ms) (set to Tw / 2 - 1) */
@@ -192 +197 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, sizeof(rtoinfo))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_RTOINFO : srto_initial : %u", rtoinfo.srto_initial);
-                TRACE_DEBUG(FULL, "                   srto_max     : %u", rtoinfo.srto_max);
-                TRACE_DEBUG(FULL, "                   srto_min     : %u", rtoinfo.srto_min);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, &sz)  );
+                        fd_log_debug( "New SCTP_RTOINFO : srto_initial : %u\n", rtoinfo.srto_initial);
+                        fd_log_debug( "                   srto_max     : %u\n", rtoinfo.srto_max);
+                        fd_log_debug( "                   srto_min     : %u\n", rtoinfo.srto_min);
+                }
         }
         #else /* SCTP_RTOINFO */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_RTOINFO");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_RTOINFO");
         #endif /* SCTP_RTOINFO */
         
@@ -212 +215 @@
                 memset(&assoc, 0, sizeof(assoc));
 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(assoc);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, &sz)  );
-                if (sz != sizeof(assoc))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(assoc));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_ASSOCINFO : sasoc_asocmaxrxt               : %hu", assoc.sasoc_asocmaxrxt);
-                TRACE_DEBUG(FULL, "                     sasoc_number_peer_destinations : %hu", assoc.sasoc_number_peer_destinations);
-                TRACE_DEBUG(FULL, "                     sasoc_peer_rwnd                : %u" , assoc.sasoc_peer_rwnd);
-                TRACE_DEBUG(FULL, "                     sasoc_local_rwnd               : %u" , assoc.sasoc_local_rwnd);
-                TRACE_DEBUG(FULL, "                     sasoc_cookie_life              : %u" , assoc.sasoc_cookie_life);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(assoc);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, &sz)  );
+                        if (sz != sizeof(assoc))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(assoc));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_ASSOCINFO : sasoc_asocmaxrxt               : %hu\n", assoc.sasoc_asocmaxrxt);
+                        fd_log_debug( "                     sasoc_number_peer_destinations : %hu\n", assoc.sasoc_number_peer_destinations);
+                        fd_log_debug( "                     sasoc_peer_rwnd                : %u\n" , assoc.sasoc_peer_rwnd);
+                        fd_log_debug( "                     sasoc_local_rwnd               : %u\n" , assoc.sasoc_local_rwnd);
+                        fd_log_debug( "                     sasoc_cookie_life              : %u\n" , assoc.sasoc_cookie_life);
+                }
 
                 assoc.sasoc_asocmaxrxt = 5;     /* Maximum retransmission attempts: we want fast detection of errors */
@@ -233 +236 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, sizeof(assoc))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_ASSOCINFO : sasoc_asocmaxrxt               : %hu", assoc.sasoc_asocmaxrxt);
-                TRACE_DEBUG(FULL, "                     sasoc_number_peer_destinations : %hu", assoc.sasoc_number_peer_destinations);
-                TRACE_DEBUG(FULL, "                     sasoc_peer_rwnd                : %u" , assoc.sasoc_peer_rwnd);
-                TRACE_DEBUG(FULL, "                     sasoc_local_rwnd               : %u" , assoc.sasoc_local_rwnd);
-                TRACE_DEBUG(FULL, "                     sasoc_cookie_life              : %u" , assoc.sasoc_cookie_life);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, &sz)  );
+                        fd_log_debug( "New SCTP_ASSOCINFO : sasoc_asocmaxrxt               : %hu\n", assoc.sasoc_asocmaxrxt);
+                        fd_log_debug( "                     sasoc_number_peer_destinations : %hu\n", assoc.sasoc_number_peer_destinations);
+                        fd_log_debug( "                     sasoc_peer_rwnd                : %u\n" , assoc.sasoc_peer_rwnd);
+                        fd_log_debug( "                     sasoc_local_rwnd               : %u\n" , assoc.sasoc_local_rwnd);
+                        fd_log_debug( "                     sasoc_cookie_life              : %u\n" , assoc.sasoc_cookie_life);
+                }
         }
         #else /* SCTP_ASSOCINFO */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_ASSOCINFO");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_ASSOCINFO");
         #endif /* SCTP_ASSOCINFO */
         
@@ -256 +257 @@
                 memset(&linger, 0, sizeof(linger));
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(linger);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, &sz)  );
-                if (sz != sizeof(linger))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(linger));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SO_LINGER : l_onoff  : %d", linger.l_onoff);
-                TRACE_DEBUG(FULL, "                l_linger : %d", linger.l_linger);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(linger);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, &sz)  );
+                        if (sz != sizeof(linger))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(linger));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SO_LINGER : l_onoff  : %d\n", linger.l_onoff);
+                        fd_log_debug( "                l_linger : %d\n", linger.l_linger);
+                }
                 
                 linger.l_onoff  = 0;    /* Do not activate the linger */
@@ -275 +276 @@
                 CHECK_SYS(  setsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, &sz)  );
-                TRACE_DEBUG(FULL, "New SO_LINGER : l_onoff  : %d", linger.l_onoff);
-                TRACE_DEBUG(FULL, "                l_linger : %d", linger.l_linger);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, &sz)  );
+                        fd_log_debug( "New SO_LINGER : l_onoff  : %d\n", linger.l_onoff);
+                        fd_log_debug( "           l_linger : %d\n", linger.l_linger);
+                }
         }
         #else /* SO_LINGER */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SO_LINGER");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SO_LINGER");
         #endif /* SO_LINGER */
         
@@ -293 +292 @@
                 int nodelay;
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(nodelay);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, &sz)  );
-                if (sz != sizeof(nodelay))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(nodelay));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_NODELAY value : %s", nodelay ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(nodelay);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, &sz)  );
+                        if (sz != sizeof(nodelay))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(nodelay));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_NODELAY value : %s\n", nodelay ? "true" : "false");
+                }
 
                 nodelay = 0;    /* We turn ON the Nagle algorithm (probably the default already) */
@@ -310 +309 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, sizeof(nodelay))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_NODELAY value : %s", nodelay ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, &sz)  );
+                        fd_log_debug( "New SCTP_NODELAY value : %s\n", nodelay ? "true" : "false");
+                }
         }
         #else /* SCTP_NODELAY */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_NODELAY");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_NODELAY");
         #endif /* SCTP_NODELAY */
         
@@ -327 +324 @@
                 int interleave;
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(interleave);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, &sz)  );
-                if (sz != sizeof(interleave))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(interleave));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_FRAGMENT_INTERLEAVE value : %d", interleave);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(interleave);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, &sz)  );
+                        if (sz != sizeof(interleave))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(interleave));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_FRAGMENT_INTERLEAVE value : %d\n", interleave);
+                }
 
                 #if 0
@@ -348 +345 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, sizeof(interleave))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_FRAGMENT_INTERLEAVE value : %d", interleave);
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, &sz)  );
+                        fd_log_debug( "New SCTP_FRAGMENT_INTERLEAVE value : %d\n", interleave);
+                }
         }
         #else /* SCTP_FRAGMENT_INTERLEAVE */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_FRAGMENT_INTERLEAVE");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_FRAGMENT_INTERLEAVE");
         #endif /* SCTP_FRAGMENT_INTERLEAVE */
         
@@ -365 +360 @@
                 int v4mapped;
                 
-                #ifdef DEBUG_SCTP
-                sz = sizeof(v4mapped);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, &sz)  );
-                if (sz != sizeof(v4mapped))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(v4mapped));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_I_WANT_MAPPED_V4_ADDR value : %s", v4mapped ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        sz = sizeof(v4mapped);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, &sz)  );
+                        if (sz != sizeof(v4mapped))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(v4mapped));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_I_WANT_MAPPED_V4_ADDR value : %s\n", v4mapped ? "true" : "false");
+                }
 
 #ifndef SCTP_USE_MAPPED_ADDRESSES
@@ -386 +381 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, sizeof(v4mapped))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_I_WANT_MAPPED_V4_ADDR value : %s", v4mapped ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, &sz)  );
+                        fd_log_debug( "New SCTP_I_WANT_MAPPED_V4_ADDR value : %s\n", v4mapped ? "true" : "false");
+                }
         }
         #else /* SCTP_I_WANT_MAPPED_V4_ADDR */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_I_WANT_MAPPED_V4_ADDR");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_I_WANT_MAPPED_V4_ADDR");
         #endif /* SCTP_I_WANT_MAPPED_V4_ADDR */
                            
@@ -456 +449 @@
                 int asconf;
                 
-                #ifdef DEBUG_SCTP
-                socklen_t sz;
-                
-                sz = sizeof(asconf);
-                /* Read socket defaults */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, &sz)  );
-                if (sz != sizeof(asconf))
-                {
-                        TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(asconf));
-                        return ENOTSUP;
-                }
-                TRACE_DEBUG(FULL, "Def SCTP_AUTO_ASCONF value : %s", asconf ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        socklen_t sz;
+
+                        sz = sizeof(asconf);
+                        /* Read socket defaults */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, &sz)  );
+                        if (sz != sizeof(asconf))
+                        {
+                                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %d", sz, (socklen_t)sizeof(asconf));
+                                return ENOTSUP;
+                        }
+                        fd_log_debug( "Def SCTP_AUTO_ASCONF value : %s\n", asconf ? "true" : "false");
+                }
 
                 asconf = bound_to_default ? 1 : 0;      /* allow automatic use of added or removed addresses in the association (for bound-all sockets) */
@@ -475 +468 @@
                 CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, sizeof(asconf))  );
                 
-                #ifdef DEBUG_SCTP
-                /* Check new values */
-                CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, &sz)  );
-                TRACE_DEBUG(FULL, "New SCTP_AUTO_ASCONF value : %s", asconf ? "true" : "false");
-                #endif /* DEBUG_SCTP */
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        socklen_t sz = sizeof(asconf);
+                        /* Check new values */
+                        CHECK_SYS(  getsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, &sz)  );
+                        fd_log_debug( "New SCTP_AUTO_ASCONF value : %s\n", asconf ? "true" : "false");
+                }
         }
         #else /* SCTP_AUTO_ASCONF */
-        # ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "Skipping SCTP_AUTO_ASCONF");
-        # endif /* DEBUG_SCTP */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_AUTO_ASCONF");
         #endif /* SCTP_AUTO_ASCONF */
         
@@ -600 +592 @@
                 }
                 
-                # ifdef DEBUG_SCTP
-                if (TRACE_BOOL(FULL)) {
+                if (TRACE_BOOL(SCTP_LEVEL)) {
                         int i;
                         ptr.buf = sar.buf;
@@ -610 +601 @@
                         }
                 }
-                #endif /* DEBUG_SCTP */
                 
                 /* Bind to this array */
@@ -622 +612 @@
         CHECK_FCT( fd_setsockopt_postbind(*sock, bind_default) );
         
-        #ifdef DEBUG_SCTP
         /* Debug: show all local listening addresses */
-        if (TRACE_BOOL(FULL)) {
+        if (TRACE_BOOL(SCTP_LEVEL)) {
                 sSA *sar;
                 union {
@@ -640 +629 @@
                 sctp_freeladdrs(sar);
         }
-        #endif /* DEBUG_SCTP */
 
         return 0;
@@ -767 +755 @@
                 return ENOTSUP;
         }
-        #ifdef DEBUG_SCTP
-        TRACE_DEBUG(FULL, "SCTP_STATUS : sstat_state                  : %i" , status.sstat_state);
-        TRACE_DEBUG(FULL, "              sstat_rwnd                   : %u" , status.sstat_rwnd);
-        TRACE_DEBUG(FULL, "              sstat_unackdata              : %hu", status.sstat_unackdata);
-        TRACE_DEBUG(FULL, "              sstat_penddata               : %hu", status.sstat_penddata);
-        TRACE_DEBUG(FULL, "              sstat_instrms                : %hu", status.sstat_instrms);
-        TRACE_DEBUG(FULL, "              sstat_outstrms               : %hu", status.sstat_outstrms);
-        TRACE_DEBUG(FULL, "              sstat_fragmentation_point    : %u" , status.sstat_fragmentation_point);
-        TRACE_DEBUG_sSA(FULL, "          sstat_primary.spinfo_address : ", &status.sstat_primary.spinfo_address, NI_NUMERICHOST | NI_NUMERICSERV, "" );
-        TRACE_DEBUG(FULL, "              sstat_primary.spinfo_state   : %d" , status.sstat_primary.spinfo_state);
-        TRACE_DEBUG(FULL, "              sstat_primary.spinfo_cwnd    : %u" , status.sstat_primary.spinfo_cwnd);
-        TRACE_DEBUG(FULL, "              sstat_primary.spinfo_srtt    : %u" , status.sstat_primary.spinfo_srtt);
-        TRACE_DEBUG(FULL, "              sstat_primary.spinfo_rto     : %u" , status.sstat_primary.spinfo_rto);
-        TRACE_DEBUG(FULL, "              sstat_primary.spinfo_mtu     : %u" , status.sstat_primary.spinfo_mtu);
-        #endif /* DEBUG_SCTP */
+        if (TRACE_BOOL(SCTP_LEVEL)) {
+                fd_log_debug( "SCTP_STATUS : sstat_state                  : %i\n" , status.sstat_state);
+                fd_log_debug( "              sstat_rwnd                   : %u\n" , status.sstat_rwnd);
+                fd_log_debug( "              sstat_unackdata              : %hu\n", status.sstat_unackdata);
+                fd_log_debug( "              sstat_penddata               : %hu\n", status.sstat_penddata);
+                fd_log_debug( "              sstat_instrms                : %hu\n", status.sstat_instrms);
+                fd_log_debug( "              sstat_outstrms               : %hu\n", status.sstat_outstrms);
+                fd_log_debug( "              sstat_fragmentation_point    : %u\n" , status.sstat_fragmentation_point);
+                fd_log_debug( "              sstat_primary.spinfo_address : ");
+                sSA_DUMP_NODE_SERV(&status.sstat_primary.spinfo_address, NI_NUMERICHOST | NI_NUMERICSERV );
+                fd_log_debug( "\n" );
+                fd_log_debug( "              sstat_primary.spinfo_state   : %d\n" , status.sstat_primary.spinfo_state);
+                fd_log_debug( "              sstat_primary.spinfo_cwnd    : %u\n" , status.sstat_primary.spinfo_cwnd);
+                fd_log_debug( "              sstat_primary.spinfo_srtt    : %u\n" , status.sstat_primary.spinfo_srtt);
+                fd_log_debug( "              sstat_primary.spinfo_rto     : %u\n" , status.sstat_primary.spinfo_rto);
+                fd_log_debug( "              sstat_primary.spinfo_mtu     : %u\n" , status.sstat_primary.spinfo_mtu);
+        }
         
         *in = status.sstat_instrms;
@@ -936 +926 @@
         mhdr.msg_controllen = sizeof(anci);
         
-        #ifdef DEBUG_SCTP
         TRACE_DEBUG(FULL, "Sending %db data on stream %hu of socket %d", len, strid, sock);
-        #endif /* DEBUG_SCTP */
         
         CHECK_SYS( ret = sendmsg(sock, &mhdr, 0) );
@@ -1005 +993 @@
         }
         
+        TRACE_DEBUG(FULL, "Received %db data on socket %d", datasize, sock);
+        
         /* Handle the case where the data received is a notification */
         if (mhdr.msg_flags & MSG_NOTIFICATION) {
@@ -1012 +1002 @@
                         
                         case SCTP_ASSOC_CHANGE:
-                                #ifdef DEBUG_SCTP
                                 TRACE_DEBUG(FULL, "Received SCTP_ASSOC_CHANGE notification");
-                                TRACE_DEBUG(FULL, "    state : %hu", notif->sn_assoc_change.sac_state);
-                                TRACE_DEBUG(FULL, "    error : %hu", notif->sn_assoc_change.sac_error);
-                                TRACE_DEBUG(FULL, "    instr : %hu", notif->sn_assoc_change.sac_inbound_streams);
-                                TRACE_DEBUG(FULL, "   outstr : %hu", notif->sn_assoc_change.sac_outbound_streams);
-                                #endif /* DEBUG_SCTP */
+                                TRACE_DEBUG(SCTP_LEVEL, "    state : %hu", notif->sn_assoc_change.sac_state);
+                                TRACE_DEBUG(SCTP_LEVEL, "    error : %hu", notif->sn_assoc_change.sac_error);
+                                TRACE_DEBUG(SCTP_LEVEL, "    instr : %hu", notif->sn_assoc_change.sac_inbound_streams);
+                                TRACE_DEBUG(SCTP_LEVEL, "   outstr : %hu", notif->sn_assoc_change.sac_outbound_streams);
                                 
                                 *event = FDEVP_CNX_EP_CHANGE;
@@ -1024 +1012 @@
         
                         case SCTP_PEER_ADDR_CHANGE:
-                                #ifdef DEBUG_SCTP
                                 TRACE_DEBUG(FULL, "Received SCTP_PEER_ADDR_CHANGE notification");
-                                TRACE_DEBUG_sSA(FULL, "    intf_change : ", &(notif->sn_paddr_change.spc_aaddr), NI_NUMERICHOST | NI_NUMERICSERV, "" );
-                                TRACE_DEBUG(FULL, "          state : %d", notif->sn_paddr_change.spc_state);
-                                TRACE_DEBUG(FULL, "          error : %d", notif->sn_paddr_change.spc_error);
-                                #endif /* DEBUG_SCTP */
+                                TRACE_DEBUG_sSA(SCTP_LEVEL, "    intf_change : ", &(notif->sn_paddr_change.spc_aaddr), NI_NUMERICHOST | NI_NUMERICSERV, "" );
+                                TRACE_DEBUG(SCTP_LEVEL, "          state : %d", notif->sn_paddr_change.spc_state);
+                                TRACE_DEBUG(SCTP_LEVEL, "          error : %d", notif->sn_paddr_change.spc_error);
                                 
                                 *event = FDEVP_CNX_EP_CHANGE;
@@ -1035 +1021 @@
         
                         case SCTP_SEND_FAILED:
-                                #ifdef DEBUG_SCTP
                                 TRACE_DEBUG(FULL, "Received SCTP_SEND_FAILED notification");
-                                TRACE_DEBUG(FULL, "    len : %hu", notif->sn_send_failed.ssf_length);
-                                TRACE_DEBUG(FULL, "    err : %d",  notif->sn_send_failed.ssf_error);
-                                #endif /* DEBUG_SCTP */
+                                TRACE_DEBUG(SCTP_LEVEL, "    len : %hu", notif->sn_send_failed.ssf_length);
+                                TRACE_DEBUG(SCTP_LEVEL, "    err : %d",  notif->sn_send_failed.ssf_error);
                                 
                                 *event = FDEVP_CNX_ERROR;
@@ -1045 +1029 @@
                         
                         case SCTP_REMOTE_ERROR:
-                                #ifdef DEBUG_SCTP
                                 TRACE_DEBUG(FULL, "Received SCTP_REMOTE_ERROR notification");
-                                TRACE_DEBUG(FULL, "    err : %hu", ntohs(notif->sn_remote_error.sre_error));
-                                TRACE_DEBUG(FULL, "    len : %hu", ntohs(notif->sn_remote_error.sre_length));
-                                #endif /* DEBUG_SCTP */
+                                TRACE_DEBUG(SCTP_LEVEL, "    err : %hu", ntohs(notif->sn_remote_error.sre_error));
+                                TRACE_DEBUG(SCTP_LEVEL, "    len : %hu", ntohs(notif->sn_remote_error.sre_length));
                                 
                                 *event = FDEVP_CNX_ERROR;
@@ -1055 +1037 @@
         
                         case SCTP_SHUTDOWN_EVENT:
-                                #ifdef DEBUG_SCTP
                                 TRACE_DEBUG(FULL, "Received SCTP_SHUTDOWN_EVENT notification");
-                                #endif /* DEBUG_SCTP */
                                 
                                 *event = FDEVP_CNX_ERROR;
@@ -1096 +1076 @@
                         
                         sndrcv = (struct sctp_sndrcvinfo *) CMSG_DATA(hdr);
-                        #ifdef DEBUG_SCTP
-                        TRACE_DEBUG(FULL, "Anciliary block IPPROTO_SCTP / SCTP_SNDRCV");
-                        TRACE_DEBUG(FULL, "    sinfo_stream    : %hu", sndrcv->sinfo_stream);
-                        TRACE_DEBUG(FULL, "    sinfo_ssn       : %hu", sndrcv->sinfo_ssn);
-                        TRACE_DEBUG(FULL, "    sinfo_flags     : %hu", sndrcv->sinfo_flags);
-                        /* TRACE_DEBUG(FULL, "    sinfo_pr_policy : %hu", sndrcv->sinfo_pr_policy); */
-                        TRACE_DEBUG(FULL, "    sinfo_ppid      : %u" , sndrcv->sinfo_ppid);
-                        TRACE_DEBUG(FULL, "    sinfo_context   : %u" , sndrcv->sinfo_context);
-                        /* TRACE_DEBUG(FULL, "    sinfo_pr_value  : %u" , sndrcv->sinfo_pr_value); */
-                        TRACE_DEBUG(FULL, "    sinfo_tsn       : %u" , sndrcv->sinfo_tsn);
-                        TRACE_DEBUG(FULL, "    sinfo_cumtsn    : %u" , sndrcv->sinfo_cumtsn);
-                        #endif /* DEBUG_SCTP */
+                        if (TRACE_BOOL(SCTP_LEVEL)) {
+                                fd_log_debug( "Anciliary block IPPROTO_SCTP / SCTP_SNDRCV\n");
+                                fd_log_debug( "    sinfo_stream    : %hu\n", sndrcv->sinfo_stream);
+                                fd_log_debug( "    sinfo_ssn       : %hu\n", sndrcv->sinfo_ssn);
+                                fd_log_debug( "    sinfo_flags     : %hu\n", sndrcv->sinfo_flags);
+                                /* fd_log_debug( "    sinfo_pr_policy : %hu\n", sndrcv->sinfo_pr_policy); */
+                                fd_log_debug( "    sinfo_ppid      : %u\n" , sndrcv->sinfo_ppid);
+                                fd_log_debug( "    sinfo_context   : %u\n" , sndrcv->sinfo_context);
+                                /* fd_log_debug( "    sinfo_pr_value  : %u\n" , sndrcv->sinfo_pr_value); */
+                                fd_log_debug( "    sinfo_tsn       : %u\n" , sndrcv->sinfo_tsn);
+                                fd_log_debug( "    sinfo_cumtsn    : %u\n" , sndrcv->sinfo_cumtsn);
+                        }
 
                         *strid = sndrcv->sinfo_stream;

freeDiameter/sctps.c

@@ -73 +73 @@
         
         TRACE_ENTRY("%p", arg);
-        
         CHECK_PARAMS_DO(conn && (conn->cc_socket > 0), goto out);
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Demuxer (%d)", conn->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
         ASSERT( conn->cc_proto == IPPROTO_SCTP );
-        ASSERT( conn->cc_tls == 1 );
         ASSERT( Target_Queue(conn) );
         ASSERT( conn->cc_sctps_data.array );
@@ -115 +121 @@
         
         TRACE_ENTRY("%p", arg);
-        
         CHECK_PARAMS_DO(ctx && ctx->raw_recv && ctx->parent, goto error);
         cnx = ctx->parent;
         ASSERT( Target_Queue(cnx) );
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Decipher (%hu@%d)", ctx->strid, cnx->cc_socket);
+                fd_log_threadname ( buf );
+        }
         
         CHECK_FCT_DO(fd_tls_rcvthr_core(cnx, ctx->strid ? ctx->session : cnx->cc_tls_para.session), /* continue */);
@@ -209 +221 @@
         pthread_rwlock_t lock;
         struct cnxctx   *parent;
+        /* Add another list to chain in a global list to implement a garbage collector on sessions */
 };
 
@@ -219 +232 @@
 
 /* The level at which we debug session resuming */
-#define SR_LEVEL FULL
+#define SR_LEVEL (FULL + 1)
 
 /* Initialize the store area for a connection */
@@ -303 +316 @@
         
         CHECK_PARAMS_DO( sto && key.data && data.data, return -1 );
-        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session store [key ", key.data, key.size < 16 ? key.size : 16, "]");
         
         CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
+        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session store [key ", key.data, key.size, "]");
         
         li = find_or_next(sto, key, &match);
@@ -313 +326 @@
                 /* Check the data is the same */
                 if ((data.size != sr->data.size) || memcmp(data.data, sr->data.data, data.size)) {
-                        TRACE_DEBUG(INFO, "GnuTLS tried to store a session with same key and different data!");
+                        TRACE_DEBUG(SR_LEVEL, "GnuTLS tried to store a session with same key and different data!");
                         ret = -1;
+                } else {
+                        TRACE_DEBUG(SR_LEVEL, "GnuTLS tried to store a session with same key and same data, skipped.");
                 }
                 goto out;
@@ -350 +365 @@
         
         CHECK_PARAMS_DO( sto && key.data, return -1 );
-        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session delete [key ", key.data, key.size < 16 ? key.size : 16, "]");
         
         CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
+        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session delete [key ", key.data, key.size, "]");
         
         li = find_or_next(sto, key, &match);
@@ -382 +397 @@
 
         CHECK_PARAMS_DO( sto && key.data, return error );
-        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session fetch [key ", key.data, key.size < 16 ? key.size : 16, "]");
 
         CHECK_POSIX_DO( pthread_rwlock_rdlock(&sto->lock), return error );
+        TRACE_DEBUG_BUFFER(SR_LEVEL, "Session fetch [key ", key.data, key.size, "]");
         
         li = find_or_next(sto, key, &match);
@@ -394 +409 @@
         }
 out:    
+        TRACE_DEBUG(SR_LEVEL, "Fetched (%p, %d) from store %p", res.data, res.size, sto);
         CHECK_POSIX_DO( pthread_rwlock_unlock(&sto->lock), return error);
         return res;
@@ -417 +433 @@
         TRACE_ENTRY("%p", arg);
         
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "Handshake resume (%hu@%d)", ctx->strid, ctx->parent->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
         TRACE_DEBUG(FULL, "Starting TLS resumed handshake on stream %hu", ctx->strid);
         CHECK_GNUTLS_DO( gnutls_handshake( ctx->session ), return NULL);
                         
-        /* We can trace success of resuming handshake by using gnutls_session_is_resumed */
+        if (TRACE_BOOL(FULL)) {
+                int resumed = gnutls_session_is_resumed(ctx->session);
+                if (resumed) {
+                        fd_log_debug("Session was resumed successfully on stream %hu (conn: '%s')\n", ctx->strid, fd_cnx_getid(ctx->parent));
+                } else {
+                        fd_log_debug("Session was NOT resumed (full handshake) on stream %hu (conn: '%s')\n", ctx->strid, fd_cnx_getid(ctx->parent));
+                }
+        }
                         
         /* Finish */
@@ -467 +497 @@
 
 /* Handshake other streams, after full handshake on the master session */
-int fd_sctps_handshake_others(struct cnxctx * conn, char * priority)
+int fd_sctps_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds)
 {
         uint16_t i;
@@ -487 +517 @@
         for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
                 /* Set credentials and priority */
-                CHECK_FCT( fd_tls_prepare(&conn->cc_sctps_data.array[i].session, conn->cc_tls_para.mode, priority) );
+                CHECK_FCT( fd_tls_prepare(&conn->cc_sctps_data.array[i].session, conn->cc_tls_para.mode, priority, alt_creds) );
                 
                 /* For the client, copy data from master session; for the server, set session resuming pointers */
@@ -550 +580 @@
 }
 
+static void * bye_th(void * arg)
+{
+        struct sctps_ctx * ctx = (struct sctps_ctx *) arg;
+        TRACE_ENTRY("%p", arg);
+        
+        /* Set the thread name */
+        {
+                char buf[48];
+                snprintf(buf, sizeof(buf), "gnutls_bye (%hu@%d)", ctx->strid, ctx->parent->cc_socket);
+                fd_log_threadname ( buf );
+        }
+        
+        CHECK_GNUTLS_DO( gnutls_bye(ctx->session, GNUTLS_SHUT_RDWR), /* Continue */ );
+                        
+        /* Finish */
+        return arg;
+}
+
+
+
 /* Destroy a wrapper context */
 void fd_sctps_destroy(struct cnxctx * conn)
@@ -560 +610 @@
         fd_sctps_stopthreads(conn);
         
-        /* End all TLS sessions -- maybe we should do it in parallel ? */
-        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
-                CHECK_GNUTLS_DO( gnutls_bye(conn->cc_sctps_data.array[i].session, GNUTLS_SHUT_RDWR), /* Continue */ );
-        }
-        
+        /* End all TLS sessions, in parallel */
+        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
+                CHECK_POSIX_DO( pthread_create( &conn->cc_sctps_data.array[i].thr, NULL, bye_th, &conn->cc_sctps_data.array[i] ), break );
+        }
+        for (--i; i > 0; --i) {
+                CHECK_POSIX_DO( pthread_join( conn->cc_sctps_data.array[i].thr, NULL ), continue );
+        }
+skip:   
         /* Now, stop the demux thread */
         CHECK_FCT_DO( fd_thr_term(&conn->cc_rcvthr), /* continue */ );
@@ -572 +625 @@
                 fd_event_destroy( &conn->cc_sctps_data.array[i].raw_recv, free );
                 free(conn->cc_sctps_data.array[i].partial.buf);
-                gnutls_deinit(conn->cc_sctps_data.array[i].session);
+                if (i > 0)
+                        gnutls_deinit(conn->cc_sctps_data.array[i].session);
         }
         

freeDiameter/server.c

@@ -116 +116 @@
         /* Handshake if we are a secure server port, or start clear otherwise */
         if (s->secur) {
-                int ret = fd_cnx_handshake(c->conn, GNUTLS_SERVER, NULL);
+                int ret = fd_cnx_handshake(c->conn, GNUTLS_SERVER, NULL, NULL);
                 if (ret != 0) {
                         if (TRACE_BOOL(INFO)) {
@@ -153 +153 @@
         
         /* Finally, pass the information to the peers module which will handle it next */
-        CHECK_FCT_DO( fd_peer_handle_newCER( &msg, &c->conn, s->secur ), goto fatal_error );
+        pthread_cleanup_push((void *)fd_cnx_destroy, c->conn);
+        pthread_cleanup_push((void *)fd_msg_free, msg);
+        CHECK_FCT_DO( fd_peer_handle_newCER( &msg, &c->conn ), goto cleanup );
+        pthread_cleanup_pop(0);
+        pthread_cleanup_pop(0);
         
         /* The end, we cleanup the client structure */

freeDiameter/tests/CMakeLists.txt

@@ -18 +18 @@
         testsess
         testdisp
+        testcnx
 )
 

freeDiameter/tests/tests.h

@@ -46 +46 @@
 #include <pthread.h>
 #include <errno.h>
+#include <gcrypt.h>
 
 /* Test timeout duration, unless -n is passed on the command line */
 #ifndef TEST_TIMEOUT
-#define TEST_TIMEOUT    5       /* 5 seconds */
+#define TEST_TIMEOUT    30      /* in seconds */
 #endif /* TEST_TIMEOUT */
 
@@ -78 +79 @@
 struct fd_config * fd_g_config = &conf;
 
+/* gcrypt functions to support posix threads */
+GCRY_THREAD_OPTION_PTHREAD_IMPL;
+
 /* Define the standard check routines */
 #define CHECK( _val, _assert ){                         \
@@ -99 +103 @@
 
 /* Minimum inits */
-#define INIT_FD() {                                             \
-        memset(fd_g_config, 0, sizeof(struct fd_config));       \
-        CHECK( 0, fd_lib_init() );                              \
-        fd_log_threadname(basename(__FILE__));                  \
-        CHECK( 0, fd_conf_init() );                             \
-        CHECK( 0, fd_dict_base_protocol(fd_g_config->cnf_dict) );       \
-        parse_cmdline(argc, argv);                              \
+#define INIT_FD() {                                                             \
+        memset(fd_g_config, 0, sizeof(struct fd_config));                       \
+        CHECK( 0, fd_lib_init() );                                              \
+        fd_log_threadname(basename(__FILE__));                                  \
+        (void) gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);    \
+        (void) gcry_control (GCRYCTL_ENABLE_QUICK_RANDOM, 0);                   \
+        CHECK( 0, gnutls_global_init());                                        \
+        CHECK( 0, fd_conf_init() );                                             \
+        CHECK( 0, fd_dict_base_protocol(fd_g_config->cnf_dict) );               \
+        parse_cmdline(argc, argv);                                              \
 }
 

include/freeDiameter/libfreeDiameter.h

@@ -181 +181 @@
 /* Helper for function entry -- for very detailed trace of the execution */
 #define TRACE_ENTRY(_format,_args... ) \
-        TRACE_DEBUG(FCTS, "->%s (" #_args ") = (" _format ") >", __PRETTY_FUNCTION__, ##_args );
+        TRACE_DEBUG(FCTS, "[enter] %s(" _format ") {" #_args "}", __PRETTY_FUNCTION__, ##_args );
 
 /* Helper for debugging by adding traces -- for debuging a specific location of the code */
@@ -470 +470 @@
         
         if (th_ret != NULL) {
-                TRACE_DEBUG(FULL, "The thread returned the following value: %p (ignored)", th_ret);
+                TRACE_DEBUG(ANNOYING, "The thread returned the following value: %p (ignored)", th_ret);
         }