Changes in / [20:277ec00d793e:30:bca243c65b56] in freeDiameter

Files:

• contrib/ca_script/Makefile (modified) (2 diffs)
• doc/freediameter.conf.sample (modified) (4 diffs)
• extensions/dbg_monitor/monitor.c (modified) (2 diffs)
• freeDiameter/CMakeLists.txt (modified) (2 diffs)
• freeDiameter/cnxctx.c (modified) (3 diffs)
• freeDiameter/cnxctx.h (added)
• freeDiameter/config.c (modified) (3 diffs)
• freeDiameter/endpoints.c (added)
• freeDiameter/fD.h (modified) (3 diffs)
• freeDiameter/fdd.y (modified) (5 diffs)
• freeDiameter/main.c (modified) (5 diffs)
• freeDiameter/p_expiry.c (modified) (6 diffs)
• freeDiameter/p_psm.c (modified) (7 diffs)
• freeDiameter/peers.c (modified) (6 diffs)
• freeDiameter/sctp.c (modified) (1 diff)
• freeDiameter/sctps.c (added)
• freeDiameter/server.c (modified) (8 diffs)
• freeDiameter/tcp.c (added)
• freeDiameter/tests/CMakeLists.txt (modified) (1 diff)
• freeDiameter/tests/testcnx.c (added)
• freeDiameter/tests/tests.h (modified) (3 diffs)
• include/freeDiameter/CMakeLists.txt (modified) (1 diff)
• include/freeDiameter/freeDiameter-host.h.in (modified) (1 diff)
• include/freeDiameter/freeDiameter.h (modified) (6 diffs)
• include/freeDiameter/libfreeDiameter.h (modified) (9 diffs)
• libfreeDiameter/fifo.c (modified) (4 diffs)
• libfreeDiameter/lists.c (modified) (1 diff)
• libfreeDiameter/log.c (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

doc/freediameter.conf.sample

@@ -68 +68 @@
 #ListenOn = "202.249.37.5";
 #ListenOn = "2001:200:903:2::202:1";
+#ListenOn = "fe80::21c:5ff:fe98:7d62%eth0";
 
 ##############################################################
@@ -184 +185 @@
 #  No_TLS;       # assume transparent security instead of TLS
 #  Port = 3868;  # The port to connect to
-#  SCTP_streams = 30;
 #  TcTimer = 30;
 #  TwTimer = 30;
 #  ConnectTo = "202.249.37.5";
 #  ConnectTo = "2001:200:903:2::202:1";
+#  TLS_Prio = "NORMAL";
 # Examples:
 #ConnectPeer = "aaa.wide.ad.jp";
@@ -201 +202 @@
 SecPort = 3867;
 TLS_old_method;
-No_IP;
-Prefer_TCP;
 SCTP_streams = 50;
-ListenOn = "202.249.37.5";
-ListenOn = "2001:200:903:2::202:1";
 TcTimer = 60;
 TwTimer = 6;
+#ListenOn = "133.243.146.201";
+#ListenOn = "fe80::21d:9ff:fe89:7d68%eth0";
 NoRelay;
 LoadExtension = "extensions/dbg_monitor.fdx";
@@ -213 +212 @@
 LoadExtension = "extensions/dict_eap.fdx";
 ConnectPeer = "jules.nautilus6.org" ;
-ConnectPeer = "aaa.nautilus6.org" { No_TLS; No_IP; No_TCP; SCTP_streams = 60; } ;
-TLS_Cred = "/etc/openssl-ca/clients/certs/fdtest.cert" , "/etc/openssl-ca/clients/privkeys/fdtest.key.pem";
+ConnectPeer = "aaa.nautilus6.org" { No_TLS; No_IP; } ;
+TLS_Cred = "/etc/openssl-ca/clients/certs/test.cert" , "/etc/openssl-ca/clients/privkeys/test.key.pem";
 TLS_CA = "/etc/openssl-ca/public-www/cacert.pem";
 # TLS_CRL = "/etc/openssl-ca/public-www/crl.pem";

extensions/dbg_monitor/monitor.c

@@ -49 +49 @@
 static void got_sig(int signal)
 {
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_DICT, NULL), /* continue */);
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_CONFIG, NULL), /* continue */);
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_EXT, NULL), /* continue */);
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_DICT, 0, NULL), /* continue */);
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_CONFIG, 0, NULL), /* continue */);
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_EXT, 0, NULL), /* continue */);
 }
 /* Thread to display periodical debug information */
@@ -77 +77 @@
                 #endif /* DEBUG */
                 TRACE_DEBUG(NONE, "Monitor information");
-                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_QUEUES, NULL), /* continue */);
-                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_PEERS, NULL), /* continue */);
+                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_QUEUES, 0, NULL), /* continue */);
+                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_SERV, 0, NULL), /* continue */);
+                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_PEERS, 0, NULL), /* continue */);
                 pthread_testcancel();
         }

freeDiameter/CMakeLists.txt

@@ -10 +10 @@
 SET(FD_COMMON_SRC
         fD.h
+        cnxctx.h
         config.c
         cnxctx.c
         dispatch.c
+        endpoints.c
         extensions.c
         dict_base_proto.c
@@ -21 +23 @@
         p_psm.c
         server.c
+        tcp.c
         )
 
 IF(NOT DISABLE_SCTP)
-        SET(FD_COMMON_SRC ${FD_COMMON_SRC} sctp.c)
+        SET(FD_COMMON_SRC ${FD_COMMON_SRC} sctp.c sctps.c)
 ENDIF(NOT DISABLE_SCTP)
 

freeDiameter/cnxctx.c

@@ -35 +35 @@
 
 #include "fD.h"
-
-/* Initialize a connection context */
-struct cnxctx * fd_cnx_init(int sock, int proto)
+#include "cnxctx.h"
+
+/* The maximum size of Diameter message we accept to receive (<= 2^24) to avoid too big mallocs in case of trashed headers */
+#ifndef DIAMETER_MSG_SIZE_MAX
+#define DIAMETER_MSG_SIZE_MAX   65535   /* in bytes */
+#endif /* DIAMETER_MSG_SIZE_MAX */
+
+/* Connections contexts (cnxctx) in freeDiameter are wrappers around the sockets and TLS operations .
+ * They are used to hide the details of the processing to the higher layers of the daemon.
+ * They are always oriented on connections (TCP or SCTP), connectionless modes (UDP or SCTP) are not supported.
+ */
+
+/* Note: this file could be moved to libfreeDiameter instead, but since it uses gnuTLS we prefer to keep it in the daemon */
+
+/* Lifetime of a cnxctx object:
+ * 1) Creation
+ *    a) a server socket:
+ *       - create the object with fd_cnx_serv_tcp or fd_cnx_serv_sctp
+ *       - start listening incoming connections: fd_cnx_serv_listen
+ *       - accept new clients with fd_cnx_serv_accept.
+ *    b) a client socket:
+ *       - connect to a remote server with fd_cnx_cli_connect
+ *
+ * 2) Initialization
+ *    - if TLS is started first, call fd_cnx_handshake
+ *    - otherwise to receive clear messages, call fd_cnx_start_clear. fd_cnx_handshake can be called later.
+ *
+ * 3) Usage
+ *    - fd_cnx_receive, fd_cnx_send : exchange messages on this connection (send is synchronous, receive is not, but blocking).
+ *    - fd_cnx_recv_setaltfifo : when a message is received, the event is sent to an external fifo list. fd_cnx_receive does not work when the alt_fifo is set.
+ *    - fd_cnx_getid : retrieve a descriptive string for the connection (for debug)
+ *    - fd_cnx_getremoteid : identification of the remote peer (IP address or fqdn)
+ *    - fd_cnx_getcred : get the remote peer TLS credentials, after handshake
+ *    - fd_cnx_getendpoints : get the endpoints (IP) of the connection
+ *
+ * 4) End
+ *    - fd_cnx_destroy
+ */
+
+
+/*******************************************/
+/*     Creation of a connection object     */
+/*******************************************/
+
+/* Initialize a context structure */
+static struct cnxctx * fd_cnx_init(int full)
 {
         struct cnxctx * conn = NULL;
-        
-        TRACE_ENTRY("%d %d", sock, proto);
-        CHECK_PARAMS_DO( (proto == IPPROTO_TCP) || (proto == IPPROTO_SCTP), return NULL);
-        
+
+        TRACE_ENTRY("%d", full);
+
         CHECK_MALLOC_DO( conn = malloc(sizeof(struct cnxctx)), return NULL );
         memset(conn, 0, sizeof(struct cnxctx));
-        
-        conn->cc_socket = sock;
-        conn->cc_proto  = proto;
-        
-        fd_list_init(&conn->cc_ep_remote, conn);
-        fd_list_init(&conn->cc_ep_local, conn);
-        
-        if (proto == IPPROTO_SCTP) {
+
+        if (full) {
+                CHECK_FCT_DO( fd_fifo_new ( &conn->cc_incoming ), return NULL );
+        }
+
+        return conn;
+}
+
+/* Create and bind a server socket to the given endpoint and port */
+struct cnxctx * fd_cnx_serv_tcp(uint16_t port, int family, struct fd_endpoint * ep)
+{
+        struct cnxctx * cnx = NULL;
+        sSS dummy;
+        sSA * sa = (sSA *) &dummy;
+
+        TRACE_ENTRY("%hu %d %p", port, family, ep);
+
+        CHECK_PARAMS_DO( port, return NULL );
+        CHECK_PARAMS_DO( ep || family, return NULL );
+        CHECK_PARAMS_DO( (! family) || (family == AF_INET) || (family == AF_INET6), return NULL );
+        CHECK_PARAMS_DO( (! ep) || (!family) || (ep->ss.ss_family == family), return NULL );
+
+        /* The connection object */
+        CHECK_MALLOC_DO( cnx = fd_cnx_init(0), return NULL );
+
+        /* Prepare the socket address information */
+        if (ep) {
+                memcpy(sa, &ep->ss, sizeof(sSS));
+        } else {
+                memset(&dummy, 0, sizeof(dummy));
+                sa->sa_family = family;
+        }
+        if (sa->sa_family == AF_INET) {
+                ((sSA4 *)sa)->sin_port = htons(port);
+        } else {
+                ((sSA6 *)sa)->sin6_port = htons(port);
+        }
+
+        /* Create the socket */
+        CHECK_FCT_DO( fd_tcp_create_bind_server( &cnx->cc_socket, sa, sizeof(sSS) ), goto error );
+
+        /* Generate the name for the connection object */
+        {
+                char addrbuf[INET6_ADDRSTRLEN];
+                int  rc;
+                rc = getnameinfo(sa, sizeof(sSS), addrbuf, sizeof(addrbuf), NULL, 0, NI_NUMERICHOST);
+                if (rc)
+                        snprintf(addrbuf, sizeof(addrbuf), "[err:%s]", gai_strerror(rc));
+                snprintf(cnx->cc_id, sizeof(cnx->cc_id), "Srv TCP [%s]:%hu (%d)", addrbuf, port, cnx->cc_socket);
+        }
+
+        cnx->cc_proto = IPPROTO_TCP;
+
+        return cnx;
+
+error:
+        fd_cnx_destroy(cnx);
+        return NULL;
+}
+
+/* Same function for SCTP, with a list of local endpoints to bind to */
+struct cnxctx * fd_cnx_serv_sctp(uint16_t port, struct fd_list * ep_list)
+{
+#ifdef DISABLE_SCTP
+        TRACE_DEBUG(INFO, "This function should never been called when SCTP is disabled...");
+        ASSERT(0);
+        CHECK_FCT_DO( ENOTSUP, return NULL);
+#else /* DISABLE_SCTP */
+        struct cnxctx * cnx = NULL;
+        sSS dummy;
+        sSA * sa = (sSA *) &dummy;
+
+        TRACE_ENTRY("%hu %p", port, ep_list);
+
+        CHECK_PARAMS_DO( port, return NULL );
+
+        /* The connection object */
+        CHECK_MALLOC_DO( cnx = fd_cnx_init(0), return NULL );
+
+        /* Create the socket */
+        CHECK_FCT_DO( fd_sctp_create_bind_server( &cnx->cc_socket, ep_list, port ), goto error );
+
+        /* Generate the name for the connection object */
+        snprintf(cnx->cc_id, sizeof(cnx->cc_id), "Srv SCTP :%hu (%d)", port, cnx->cc_socket);
+
+        cnx->cc_proto = IPPROTO_SCTP;
+
+        return cnx;
+
+error:
+        fd_cnx_destroy(cnx);
+        return NULL;
+#endif /* DISABLE_SCTP */
+}
+
+/* Allow clients to connect on the server socket */
+int fd_cnx_serv_listen(struct cnxctx * conn)
+{
+        CHECK_PARAMS( conn );
+
+        switch (conn->cc_proto) {
+                case IPPROTO_TCP:
+                        CHECK_FCT(fd_tcp_listen(conn->cc_socket));
+                        break;
+
 #ifndef DISABLE_SCTP
-                CHECK_FCT_DO( fd_sctp_get_str_info( sock, &conn->cc_sctp_para.str_in, &conn->cc_sctp_para.str_out ),
-                                { free(conn); return NULL; } );
-                conn->cc_sctp_para.pairs = (conn->cc_sctp_para.str_out < conn->cc_sctp_para.str_in) ? conn->cc_sctp_para.str_out : conn->cc_sctp_para.str_in;
+                case IPPROTO_SCTP:
+                        CHECK_FCT(fd_sctp_listen(conn->cc_socket));
+                        break;
+#endif /* DISABLE_SCTP */
+
+                default:
+                        CHECK_PARAMS(0);
+        }
+
+        return 0;
+}
+
+/* Accept a client (blocking until a new client connects) -- cancelable */
+struct cnxctx * fd_cnx_serv_accept(struct cnxctx * serv)
+{
+        struct cnxctx * cli = NULL;
+        sSS ss;
+        socklen_t ss_len = sizeof(ss);
+        int cli_sock = 0;
+        struct fd_endpoint * ep;
+
+        TRACE_ENTRY("%p", serv);
+        CHECK_PARAMS_DO(serv, return NULL);
+        
+        /* Accept the new connection -- this is blocking until new client enters or cancellation */
+        CHECK_SYS_DO( cli_sock = accept(serv->cc_socket, (sSA *)&ss, &ss_len), return NULL );
+        
+        if (TRACE_BOOL(INFO)) {
+                fd_log_debug("%s : accepted new client [", fd_cnx_getid(serv));
+                sSA_DUMP_NODE( &ss, NI_NUMERICHOST );
+                fd_log_debug("].\n");
+        }
+        
+        CHECK_MALLOC_DO( cli = fd_cnx_init(1), { shutdown(cli_sock, SHUT_RDWR); return NULL; } );
+        cli->cc_socket = cli_sock;
+        cli->cc_proto = serv->cc_proto;
+        
+        /* Generate the name for the connection object */
+        {
+                char addrbuf[INET6_ADDRSTRLEN];
+                char portbuf[10];
+                int  rc;
+                
+                /* Numeric values for debug */
+                rc = getnameinfo((sSA *)&ss, sizeof(sSS), addrbuf, sizeof(addrbuf), portbuf, sizeof(portbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+                if (rc) {
+                        snprintf(addrbuf, sizeof(addrbuf), "[err:%s]", gai_strerror(rc));
+                        portbuf[0] = '\0';
+                }
+                
+                snprintf(cli->cc_id, sizeof(cli->cc_id), "Incoming %s [%s]:%s (%d) @ serv (%d)", 
+                                IPPROTO_NAME(cli->cc_proto), 
+                                addrbuf, portbuf, 
+                                cli->cc_socket, serv->cc_socket);
+                
+                /* Name for log messages */
+                rc = getnameinfo((sSA *)&ss, sizeof(sSS), cli->cc_remid, sizeof(cli->cc_remid), NULL, 0, 0);
+                if (rc)
+                        snprintf(cli->cc_remid, sizeof(cli->cc_remid), "[err:%s]", gai_strerror(rc));
+        }
+
+#ifndef DISABLE_SCTP
+        /* SCTP-specific handlings */
+        if (cli->cc_proto == IPPROTO_SCTP) {
+                /* Retrieve the number of streams */
+                CHECK_FCT_DO( fd_sctp_get_str_info( cli->cc_socket, &cli->cc_sctp_para.str_in, &cli->cc_sctp_para.str_out, NULL ), goto error );
+                if (cli->cc_sctp_para.str_out > cli->cc_sctp_para.str_in)
+                        cli->cc_sctp_para.pairs = cli->cc_sctp_para.str_out;
+                else
+                        cli->cc_sctp_para.pairs = cli->cc_sctp_para.str_in;
+        }
+#endif /* DISABLE_SCTP */
+
+        return cli;
+error:
+        fd_cnx_destroy(cli);
+        return NULL;
+}
+
+/* Client side: connect to a remote server -- cancelable */
+struct cnxctx * fd_cnx_cli_connect_tcp(sSA * sa /* contains the port already */, socklen_t addrlen)
+{
+        int sock;
+        struct cnxctx * cnx = NULL;
+        
+        TRACE_ENTRY("%p %d", sa, addrlen);
+        CHECK_PARAMS_DO( sa && addrlen, return NULL );
+        
+        /* Create the socket and connect, which can take some time and/or fail */
+        CHECK_FCT_DO( fd_tcp_client( &sock, sa, addrlen ), return NULL );
+        
+        if (TRACE_BOOL(INFO)) {
+                fd_log_debug("Connection established to server '");
+                sSA_DUMP_NODE_SERV( sa, NI_NUMERICSERV);
+                fd_log_debug("' (TCP:%d).\n", sock);
+        }
+        
+        /* Once the socket is created successfuly, prepare the remaining of the cnx */
+        CHECK_MALLOC_DO( cnx = fd_cnx_init(1), { shutdown(sock, SHUT_RDWR); return NULL; } );
+        
+        cnx->cc_socket = sock;
+        cnx->cc_proto  = IPPROTO_TCP;
+        
+        /* Generate the names for the object */
+        {
+                char addrbuf[INET6_ADDRSTRLEN];
+                char portbuf[10];
+                int  rc;
+                
+                /* Numeric values for debug */
+                rc = getnameinfo(sa, addrlen, addrbuf, sizeof(addrbuf), portbuf, sizeof(portbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+                if (rc) {
+                        snprintf(addrbuf, sizeof(addrbuf), "[err:%s]", gai_strerror(rc));
+                        portbuf[0] = '\0';
+                }
+                
+                snprintf(cnx->cc_id, sizeof(cnx->cc_id), "Client of TCP server [%s]:%s (%d)", addrbuf, portbuf, cnx->cc_socket);
+                
+                /* Name for log messages */
+                rc = getnameinfo(sa, addrlen, cnx->cc_remid, sizeof(cnx->cc_remid), NULL, 0, 0);
+                if (rc)
+                        snprintf(cnx->cc_remid, sizeof(cnx->cc_remid), "[err:%s]", gai_strerror(rc));
+        }
+        
+        return cnx;
+
+error:
+        fd_cnx_destroy(cnx);
+        return NULL;
+}
+
+/* Same for SCTP, accepts a list of remote addresses to connect to (see sctp_connectx for how they are used) */
+struct cnxctx * fd_cnx_cli_connect_sctp(int no_ip6, uint16_t port, struct fd_list * list)
+{
+#ifdef DISABLE_SCTP
+        TRACE_DEBUG(INFO, "This function should never been called when SCTP is disabled...");
+        ASSERT(0);
+        CHECK_FCT_DO( ENOTSUP, return NULL);
 #else /* DISABLE_SCTP */
-                ASSERT(0);
+        int sock;
+        struct cnxctx * cnx = NULL;
+        sSS primary;
+        
+        TRACE_ENTRY("%p", list);
+        CHECK_PARAMS_DO( list && !FD_IS_LIST_EMPTY(list), return NULL );
+        
+        CHECK_FCT_DO( fd_sctp_client( &sock, no_ip6, port, list ), return NULL );
+        
+        /* Once the socket is created successfuly, prepare the remaining of the cnx */
+        CHECK_MALLOC_DO( cnx = fd_cnx_init(1), { shutdown(sock, SHUT_RDWR); return NULL; } );
+        
+        cnx->cc_socket = sock;
+        cnx->cc_proto  = IPPROTO_SCTP;
+        
+        /* Retrieve the number of streams and primary address */
+        CHECK_FCT_DO( fd_sctp_get_str_info( sock, &cnx->cc_sctp_para.str_in, &cnx->cc_sctp_para.str_out, &primary ), goto error );
+        if (cnx->cc_sctp_para.str_out > cnx->cc_sctp_para.str_in)
+                cnx->cc_sctp_para.pairs = cnx->cc_sctp_para.str_out;
+        else
+                cnx->cc_sctp_para.pairs = cnx->cc_sctp_para.str_in;
+        
+        if (TRACE_BOOL(INFO)) {
+                fd_log_debug("Connection established to server '");
+                sSA_DUMP_NODE_SERV( &primary, NI_NUMERICSERV);
+                fd_log_debug("' (SCTP:%d, %d/%d streams).\n", sock, cnx->cc_sctp_para.str_in, cnx->cc_sctp_para.str_out);
+        }
+        
+        /* Generate the names for the object */
+        {
+                char addrbuf[INET6_ADDRSTRLEN];
+                char portbuf[10];
+                int  rc;
+                
+                /* Numeric values for debug */
+                rc = getnameinfo((sSA *)&primary, sizeof(sSS), addrbuf, sizeof(addrbuf), portbuf, sizeof(portbuf), NI_NUMERICHOST | NI_NUMERICSERV);
+                if (rc) {
+                        snprintf(addrbuf, sizeof(addrbuf), "[err:%s]", gai_strerror(rc));
+                        portbuf[0] = '\0';
+                }
+                
+                snprintf(cnx->cc_id, sizeof(cnx->cc_id), "Client of SCTP server [%s]:%s (%d)", addrbuf, portbuf, cnx->cc_socket);
+                
+                /* Name for log messages */
+                rc = getnameinfo((sSA *)&primary, sizeof(sSS), cnx->cc_remid, sizeof(cnx->cc_remid), NULL, 0, 0);
+                if (rc)
+                        snprintf(cnx->cc_remid, sizeof(cnx->cc_remid), "[err:%s]", gai_strerror(rc));
+        }
+        
+        return cnx;
+
+error:
+        fd_cnx_destroy(cnx);
+        return NULL;
 #endif /* DISABLE_SCTP */
-        }
-        
-        return conn;
-}
-
-/* TLS handshake the connection */
-int fd_cnx_handshake(struct cnxctx * conn, int mode)
+}
+
+/* Return a string describing the connection, for debug */
+char * fd_cnx_getid(struct cnxctx * conn)
+{
+        CHECK_PARAMS_DO( conn, return "" );
+        return conn->cc_id;
+}
+
+/* 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)
+{
+        TRACE_ENTRY("%p %p %p", conn, local, remote);
+        CHECK_PARAMS(conn);
+        
+        if (local) {
+                /* Retrieve the local endpoint(s) of the connection */
+                switch (conn->cc_proto) {
+                        case IPPROTO_TCP: {
+                                sSS ss;
+                                socklen_t sl;
+                                CHECK_FCT(fd_tcp_get_local_ep(conn->cc_socket, &ss, &sl));
+                                CHECK_FCT(fd_ep_add_merge( local, (sSA *)&ss, sl, EP_FL_LL | EP_FL_PRIMARY));
+                        }
+                        break;
+
+                        #ifndef DISABLE_SCTP
+                        case IPPROTO_SCTP: {
+                                CHECK_FCT(fd_sctp_get_local_ep(conn->cc_socket, local));
+                        }
+                        break;
+                        #endif /* DISABLE_SCTP */
+
+                        default:
+                                CHECK_PARAMS(0);
+                }
+        }
+        
+        if (remote) {
+                /* Check we have a full connection object, not a listening socket (with no remote) */
+                CHECK_PARAMS( conn->cc_incoming );
+                
+                /* Retrieve the peer endpoint(s) of the connection */
+                switch (conn->cc_proto) {
+                        case IPPROTO_TCP: {
+                                sSS ss;
+                                socklen_t sl;
+                                CHECK_FCT(fd_tcp_get_remote_ep(conn->cc_socket, &ss, &sl));
+                                CHECK_FCT(fd_ep_add_merge( remote, (sSA *)&ss, sl, EP_FL_LL | EP_FL_PRIMARY ));
+                        }
+                        break;
+
+                        #ifndef DISABLE_SCTP
+                        case IPPROTO_SCTP: {
+                                CHECK_FCT(fd_sctp_get_remote_ep(conn->cc_socket, remote));
+                        }
+                        break;
+                        #endif /* DISABLE_SCTP */
+
+                        default:
+                                CHECK_PARAMS(0);
+                }
+        }
+
+        return 0;
+}
+
+
+/* Get a string describing the remote peer address (ip address or fqdn) */
+char * fd_cnx_getremoteid(struct cnxctx * conn)
+{
+        CHECK_PARAMS_DO( conn, return "" );
+        return conn->cc_remid;
+}
+
+
+/**************************************/
+/*     Use of a connection object     */
+/**************************************/
+
+/* Receiver thread (TCP & noTLS) : incoming message is directly saved into the target queue */
+static void * rcvthr_notls_tcp(void * arg)
+{
+        struct cnxctx * conn = arg;
+        
+        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 );
+        ASSERT( Target_Queue(conn) );
+        
+        /* Receive from a TCP connection: we have to rebuild the message boundaries */
+        do {
+                uint8_t header[4];
+                uint8_t * newmsg;
+                size_t  length;
+                ssize_t ret = 0;
+                size_t  received = 0;
+
+                do {
+                        ret = recv(conn->cc_socket, &header[received], sizeof(header) - received, 0);
+                        if (ret <= 0) {
+                                CHECK_SYS_DO(ret, /* continue */);
+                                goto error; /* Stop the thread, the recipient of the event will cleanup */
+                        }
+
+                        received += ret;
+                } while (received < sizeof(header));
+
+                length = ((size_t)header[1] << 16) + ((size_t)header[2] << 8) + (size_t)header[3];
+
+                /* Check the received word is a valid begining of a Diameter message */
+                if ((header[0] != DIAMETER_VERSION)     /* defined in <libfreeDiameter.h> */
+                   || (length > DIAMETER_MSG_SIZE_MAX)) { /* to avoid too big mallocs */
+                        /* The message is suspect */
+                        TRACE_DEBUG(INFO, "Received suspect header [ver: %d, size: %zd], assume disconnection", (int)header[0], length);
+                        goto error; /* Stop the thread, the recipient of the event will cleanup */
+                }
+
+                /* Ok, now we can really receive the data */
+                CHECK_MALLOC_DO(  newmsg = malloc( length ), goto error );
+                memcpy(newmsg, header, sizeof(header));
+
+                while (received < length) {
+                        pthread_cleanup_push(free, newmsg); /* In case we are canceled, clean the partialy built buffer */
+                        ret = recv(conn->cc_socket, newmsg + received, length - received, 0);
+                        pthread_cleanup_pop(0);
+
+                        if (ret <= 0) {
+                                CHECK_SYS_DO(ret, /* continue */);
+                                free(newmsg);
+                                goto error; /* Stop the thread, the recipient of the event will cleanup */
+                        }
+                        received += ret;
+                }
+                
+                /* We have received a complete message, send it */
+                CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_MSG_RECV, length, newmsg), /* continue or destroy everything? */);
+                
+        } while (conn->cc_loop);
+        
+out:
+        TRACE_DEBUG(FULL, "Thread terminated"); 
+        return NULL;
+error:
+        CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_ERROR, 0, NULL), /* continue or destroy everything? */);
+        goto out;
+}
+
+#ifndef DISABLE_SCTP
+/* Receiver thread (SCTP & noTLS) : incoming message is directly saved into cc_incoming, no need to care for the stream ID */
+static void * rcvthr_notls_sctp(void * arg)
+{
+        struct cnxctx * conn = arg;
+        uint8_t * buf;
+        size_t    bufsz;
+        int       event;
+        
+        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 );
+        ASSERT( Target_Queue(conn) );
+        
+        do {
+                CHECK_FCT_DO( fd_sctp_recvmeta(conn->cc_socket, NULL, &buf, &bufsz, &event), goto error );
+                if (event == FDEVP_CNX_ERROR) {
+                        goto error;
+                }
+                
+                CHECK_FCT_DO( fd_event_send( Target_Queue(conn), event, bufsz, buf), goto error );
+                
+        } while (conn->cc_loop);
+        
+out:
+        TRACE_DEBUG(FULL, "Thread terminated"); 
+        return NULL;
+error:
+        CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_ERROR, 0, NULL), /* continue or destroy everything? */);
+        goto out;
+}
+#endif /* DISABLE_SCTP */
+
+/* Returns 0 on error, received data size otherwise (always >= 0) */
+static ssize_t fd_tls_recv_handle_error(struct cnxctx * conn, gnutls_session_t session, void * data, size_t sz)
+{
+        ssize_t ret;
+again:  
+        CHECK_GNUTLS_DO( ret = gnutls_record_recv(session, data, sz),
+                {
+                        switch (ret) {
+                                case GNUTLS_E_REHANDSHAKE: 
+                                        CHECK_GNUTLS_DO( ret = gnutls_handshake(session),
+                                                {
+                                                        if (TRACE_BOOL(INFO)) {
+                                                                fd_log_debug("TLS re-handshake failed on socket %d (%s) : %s\n", conn->cc_socket, conn->cc_id, gnutls_strerror(ret));
+                                                        }
+                                                        ret = 0;
+                                                        goto end;
+                                                } );
+
+                                case GNUTLS_E_AGAIN:
+                                case GNUTLS_E_INTERRUPTED:
+                                        goto again;
+
+                                default:
+                                        TRACE_DEBUG(INFO, "This TLS error is not handled, assume unrecoverable error");
+                                        ret = 0;
+                        }
+                } );
+end:    
+        return ret;
+}
+
+/* The function that receives TLS data and re-builds a Diameter message -- it exits only on error or cancelation */
+int fd_tls_rcvthr_core(struct cnxctx * conn, gnutls_session_t session)
+{
+        /* No guarantee that GnuTLS preserves the message boundaries, so we re-build it as in TCP */
+        do {
+                uint8_t header[4];
+                uint8_t * newmsg;
+                size_t  length;
+                ssize_t ret = 0;
+                size_t  received = 0;
+
+                do {
+                        ret = fd_tls_recv_handle_error(conn, session, &header[received], sizeof(header) - received);
+                        if (ret == 0) {
+                                /* The connection is closed */
+                                goto out;
+                        }
+                        received += ret;
+                } while (received < sizeof(header));
+
+                length = ((size_t)header[1] << 16) + ((size_t)header[2] << 8) + (size_t)header[3];
+
+                /* Check the received word is a valid beginning of a Diameter message */
+                if ((header[0] != DIAMETER_VERSION)     /* defined in <libfreeDiameter.h> */
+                   || (length > DIAMETER_MSG_SIZE_MAX)) { /* to avoid too big mallocs */
+                        /* The message is suspect */
+                        TRACE_DEBUG(INFO, "Received suspect header [ver: %d, size: %zd], assume disconnection", (int)header[0], length);
+                        goto out;
+                }
+
+                /* Ok, now we can really receive the data */
+                CHECK_MALLOC(  newmsg = malloc( length ) );
+                memcpy(newmsg, header, sizeof(header));
+
+                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, session, newmsg + received, length - received);
+                        pthread_cleanup_pop(0);
+
+                        if (ret == 0) {
+                                free(newmsg);
+                                goto out; /* Stop the thread, the recipient of the event will cleanup */
+                        }
+                        received += ret;
+                }
+                
+                /* We have received a complete message, send it */
+                CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_MSG_RECV, length, newmsg), /* continue or destroy everything? */);
+                
+        } while (1);
+out:
+        return ENOTCONN;
+}
+
+/* Receiver thread (TLS & 1 stream SCTP or TCP) : gnutls directly handles the socket, save records into the target queue */
+static void * rcvthr_tls_single(void * arg)
+{
+        struct cnxctx * conn = arg;
+        
+        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) );
+        
+        CHECK_FCT_DO(fd_tls_rcvthr_core(conn, conn->cc_tls_para.session), /* continue */);
+error:
+        CHECK_FCT_DO( fd_event_send( Target_Queue(conn), FDEVP_CNX_ERROR, 0, NULL), /* continue or destroy everything? */);
+        TRACE_DEBUG(FULL, "Thread terminated"); 
+        return NULL;
+}
+
+/* Start receving messages in clear (no TLS) on the connection */
+int fd_cnx_start_clear(struct cnxctx * conn, int loop)
+{
+        TRACE_ENTRY("%p %i", conn, loop);
+        
+        CHECK_PARAMS( conn && Target_Queue(conn) && (!conn->cc_tls) && (!conn->cc_loop));
+        
+        /* Save the loop request */
+        conn->cc_loop = loop;
+        
+        /* Release resources in case of a previous call was already made */
+        CHECK_FCT_DO( fd_thr_term(&conn->cc_rcvthr), /* continue */);
+        
+        switch (conn->cc_proto) {
+                case IPPROTO_TCP:
+                        /* Start the tcp_notls thread */
+                        CHECK_POSIX( pthread_create( &conn->cc_rcvthr, NULL, rcvthr_notls_tcp, conn ) );
+                        break;
+#ifndef DISABLE_SCTP
+                case IPPROTO_SCTP:
+                        /* Start the tcp_notls thread */
+                        CHECK_POSIX( pthread_create( &conn->cc_rcvthr, NULL, rcvthr_notls_sctp, conn ) );
+                        break;
+#endif /* DISABLE_SCTP */
+                default:
+                        TRACE_DEBUG(INFO, "Unknown protocol: %d", conn->cc_proto);
+                        return ENOTSUP;
+        }
+                        
+        return 0;
+}
+
+/* Prepare a gnutls session object for handshake */
+int fd_tls_prepare(gnutls_session_t * session, int mode, char * priority, void * alt_creds)
+{
+        /* Create the master session context */
+        CHECK_GNUTLS_DO( gnutls_init (session, mode), return ENOMEM );
+
+        /* Set the algorithm suite */
+        if (priority) {
+                const char * errorpos;
+                CHECK_GNUTLS_DO( gnutls_priority_set_direct( *session, priority, &errorpos ), 
+                        { TRACE_DEBUG(INFO, "Error in priority string '%s' at position: '%s'\n", priority, errorpos); return EINVAL; } );
+        } else {
+                CHECK_GNUTLS_DO( gnutls_priority_set( *session, fd_g_config->cnf_sec_data.prio_cache ), return EINVAL );
+        }
+
+        /* Set the credentials of this side of the connection */
+        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 */
+        if (mode == GNUTLS_SERVER) {
+                gnutls_certificate_server_set_request (*session, GNUTLS_CERT_REQUIRE);
+        }
+        
+        return 0;
+}
+
+/* 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, void * alt_creds)
 {
         TRACE_ENTRY( "%p %d", conn, mode);
-        CHECK_PARAMS( conn && ( (mode == GNUTLS_CLIENT) || (mode == GNUTLS_SERVER) ) );
-        
+        CHECK_PARAMS( conn && (!conn->cc_tls) && ( (mode == GNUTLS_CLIENT) || (mode == GNUTLS_SERVER) ) && (!conn->cc_loop) );
+
         /* Save the mode */
         conn->cc_tls_para.mode = mode;
         
-        /* Create the master session context */
-        CHECK_GNUTLS_DO( gnutls_init (&conn->cc_tls_para.session, mode), return ENOMEM );
-        
-        /* Set the algorithm suite */
-        CHECK_GNUTLS_DO( gnutls_priority_set( conn->cc_tls_para.session, fd_g_config->cnf_sec_data.prio_cache ), return EINVAL );
-        
-        /* Set the credentials of this side of the connection */
-        CHECK_GNUTLS_DO( gnutls_credentials_set (conn->cc_tls_para.session, GNUTLS_CRD_CERTIFICATE, fd_g_config->cnf_sec_data.credentials), return EINVAL );
-        
-        /* Request the remote credentials as well */
-        if (mode == GNUTLS_SERVER) {
-                gnutls_certificate_server_set_request (conn->cc_tls_para.session, GNUTLS_CERT_REQUIRE);
-        }
-
-        /* Set the socket info in the session */
-        gnutls_transport_set_ptr (conn->cc_tls_para.session, (gnutls_transport_ptr_t) conn->cc_socket);
+        /* Cancel receiving thread if any -- it should already be terminated anyway, we just release the resources */
+        CHECK_FCT_DO( fd_thr_term(&conn->cc_rcvthr), /* continue */);
+        
+        /* Once TLS handshake is done, we don't stop after the first message */
+        conn->cc_loop = 1;
+        
+        /* Prepare the master session credentials and 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 */
-        if ((conn->cc_proto == IPPROTO_SCTP) && (conn->cc_sctp_para.pairs > 0)) {
-#ifndef DISABLE_SCTP
-                TODO("Initialize the SCTP TLS wrapper");
-                TODO("Set the lowat, push and pull functions");
+        if (conn->cc_sctp_para.pairs > 1) {
+#ifdef DISABLE_SCTP
+                ASSERT(0);
+                CHECK_FCT( ENOTSUP );
 #else /* DISABLE_SCTP */
-                ASSERT(0);
+                /* Initialize the wrapper, start the demux thread */
+                CHECK_FCT( fd_sctps_init(conn) );
 #endif /* DISABLE_SCTP */
-        }
-        
+        } else {
+                /* Set the socket info in the session */
+                gnutls_transport_set_ptr (conn->cc_tls_para.session, (gnutls_transport_ptr_t) conn->cc_socket);
+        }
+
         /* Handshake master session */
         {
@@ -108 +807 @@
                         {
                                 if (TRACE_BOOL(INFO)) {
-                                        fd_log_debug("TLS Handshake failed on socket %d : %s\n", conn->cc_socket, gnutls_strerror(ret));
+                                        fd_log_debug("TLS Handshake failed on socket %d (%s) : %s\n", conn->cc_socket, conn->cc_id, gnutls_strerror(ret));
                                 }
                                 return EINVAL;
                         } );
-                
+
                 /* Now verify the remote credentials are valid -- only simple test here */
                 CHECK_GNUTLS_DO( gnutls_certificate_verify_peers2 (conn->cc_tls_para.session, &ret), return EINVAL );
                 if (ret) {
                         if (TRACE_BOOL(INFO)) {
-                                fd_log_debug("TLS: Remote certificate invalid on socket %d :\n", conn->cc_socket);
+                                fd_log_debug("TLS: Remote certificate invalid on socket %d (%s) :\n", conn->cc_socket, conn->cc_id);
                                 if (ret & GNUTLS_CERT_INVALID)
                                         fd_log_debug(" - The certificate is not trusted (unknown CA?)\n");
@@ -132 +831 @@
                 }
         }
-        
-        /* Other sessions in case of multi-stream SCTP are resumed from the master */
-        if ((conn->cc_proto == IPPROTO_SCTP) && (conn->cc_sctp_para.pairs > 0)) {
+
+        /* Multi-stream TLS: handshake other streams as well */
+        if (conn->cc_sctp_para.pairs > 1) {
 #ifndef DISABLE_SCTP
-                TODO("Init and resume all additional sessions from the master one.");
+                /* Resume all additional sessions from the master one. */
+                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;
 }
+
+/* Retrieve TLS credentials of the remote peer, after handshake */
+int fd_cnx_getcred(struct cnxctx * conn, const gnutls_datum_t **cert_list, unsigned int *cert_list_size)
+{
+        TRACE_ENTRY("%p %p %p", conn, cert_list, cert_list_size);
+        CHECK_PARAMS( conn && (conn->cc_tls) && cert_list && cert_list_size );
+        
+        /* This function only works for X.509 certificates. */
+        CHECK_PARAMS( gnutls_certificate_type_get (conn->cc_tls_para.session) == GNUTLS_CRT_X509 );
+        
+        *cert_list = gnutls_certificate_get_peers (conn->cc_tls_para.session, cert_list_size);
+        if (*cert_list == NULL) {
+                TRACE_DEBUG(INFO, "No certificate was provided by remote peer / an error occurred.");
+                return EINVAL;
+        }
+
+        TRACE_DEBUG( FULL, "Remote peer provided %d certificates.\n", *cert_list_size);
+        
+        return 0;
+}
+
+/* Receive next message. if timeout is not NULL, wait only until timeout. This function only pulls from a queue, mgr thread is filling that queue aynchrounously. */
+int fd_cnx_receive(struct cnxctx * conn, struct timespec * timeout, unsigned char **buf, size_t * len)
+{
+        int    ev;
+        size_t ev_sz;
+        void * ev_data;
+        
+        TRACE_ENTRY("%p %p %p %p", conn, timeout, buf, len);
+        CHECK_PARAMS(conn && (conn->cc_socket > 0) && buf && len);
+        CHECK_PARAMS(conn->cc_rcvthr != (pthread_t)NULL);
+        CHECK_PARAMS(conn->cc_alt == NULL);
+
+        /* Now, pull the first event */
+get_next:
+        if (timeout) {
+                CHECK_FCT( fd_event_timedget(conn->cc_incoming, timeout, FDEVP_PSM_TIMEOUT, &ev, &ev_sz, &ev_data) );
+        } else {
+                CHECK_FCT( fd_event_get(conn->cc_incoming, &ev, &ev_sz, &ev_data) );
+        }
+        
+        switch (ev) {
+                case FDEVP_CNX_MSG_RECV:
+                        /* We got one */
+                        *len = ev_sz;
+                        *buf = ev_data;
+                        return 0;
+                        
+                case FDEVP_PSM_TIMEOUT:
+                        TRACE_DEBUG(FULL, "Timeout event received");
+                        return ETIMEDOUT;
+                        
+                case FDEVP_CNX_EP_CHANGE:
+                        /* We ignore this event */
+                        goto get_next;
+                        
+                case FDEVP_CNX_ERROR:
+                        TRACE_DEBUG(FULL, "Received ERROR event on the connection");
+                        return ENOTCONN;
+        }
+        
+        TRACE_DEBUG(INFO, "Received unexpected event %d (%s)", ev, fd_pev_str(ev));
+        return EINVAL;
+}
+
+/* Set an alternate FIFO list to send FDEVP_CNX_* events to */
+int fd_cnx_recv_setaltfifo(struct cnxctx * conn, struct fifo * alt_fifo)
+{
+        TRACE_ENTRY( "%p %p", conn, alt_fifo );
+        CHECK_PARAMS( conn && alt_fifo && conn->cc_incoming );
+        
+        /* The magic function does it all */
+        CHECK_FCT( fd_fifo_move( &conn->cc_incoming, alt_fifo, &conn->cc_alt ) );
+        
+        return 0;
+}
+
+/* Wrapper around gnutls_record_recv to handle some error codes */
+static ssize_t fd_tls_send_handle_error(struct cnxctx * conn, gnutls_session_t session, void * data, size_t sz)
+{
+        ssize_t ret;
+again:  
+        CHECK_GNUTLS_DO( ret = gnutls_record_send(session, data, sz),
+                {
+                        switch (ret) {
+                                case GNUTLS_E_REHANDSHAKE: 
+                                        CHECK_GNUTLS_DO( ret = gnutls_handshake(session),
+                                                {
+                                                        if (TRACE_BOOL(INFO)) {
+                                                                fd_log_debug("TLS re-handshake failed on socket %d (%s) : %s\n", conn->cc_socket, conn->cc_id, gnutls_strerror(ret));
+                                                        }
+                                                        goto end;
+                                                } );
+
+                                case GNUTLS_E_AGAIN:
+                                case GNUTLS_E_INTERRUPTED:
+                                        goto again;
+
+                                default:
+                                        TRACE_DEBUG(INFO, "This TLS error is not handled, assume unrecoverable error");
+                        }
+                } );
+end:    
+        return ret;
+}
+
+
+
+/* Send function when no multi-stream is involved, or sending on stream #0 (send() always use stream 0)*/
+static int send_simple(struct cnxctx * conn, unsigned char * buf, size_t len)
+{
+        ssize_t ret;
+        size_t sent = 0;
+        TRACE_ENTRY("%p %p %zd", conn, buf, len);
+        do {
+                if (conn->cc_tls) {
+                        CHECK_GNUTLS_DO( ret = fd_tls_send_handle_error(conn, conn->cc_tls_para.session, buf + sent, len - sent), return ENOTCONN );
+                } else {
+                        CHECK_SYS( ret = send(conn->cc_socket, buf + sent, len - sent, 0) ); /* better to replace with sendmsg for atomic sending? */
+                }
+                sent += ret;
+        } while ( sent < len );
+        return 0;
+}
+
+/* Send a message -- this is synchronous -- and we assume it's never called by several threads at the same time, so we don't protect. */
+int fd_cnx_send(struct cnxctx * conn, unsigned char * buf, size_t len)
+{
+        TRACE_ENTRY("%p %p %zd", conn, buf, len);
+        
+        CHECK_PARAMS(conn && (conn->cc_socket > 0) && buf && len);
+
+        TRACE_DEBUG(FULL, "Sending %zdb %sdata on connection %s", len, conn->cc_tls ? "TLS-protected ":"", conn->cc_id);
+        
+        switch (conn->cc_proto) {
+                case IPPROTO_TCP:
+                        CHECK_FCT( send_simple(conn, buf, len) );
+                        break;
+                
+#ifndef DISABLE_SCTP
+                case IPPROTO_SCTP: {
+                        int multistr = 0;
+                        
+                        if ((conn->cc_sctp_para.str_out > 1) && ((! conn->cc_tls) || (conn->cc_sctp_para.pairs > 1)))  {
+                                /* Update the id of the stream we will send this message on */
+                                conn->cc_sctp_para.next += 1;
+                                conn->cc_sctp_para.next %= (conn->cc_tls ? conn->cc_sctp_para.pairs : conn->cc_sctp_para.str_out);
+                                multistr = 1;
+                        }
+                        
+                        if ((!multistr) || (conn->cc_sctp_para.next == 0)) {
+                                CHECK_FCT( send_simple(conn, buf, len) );
+                        } else {
+                                if (!conn->cc_tls) {
+                                        CHECK_FCT( fd_sctp_sendstr(conn->cc_socket, conn->cc_sctp_para.next, buf, len) );
+                                } else {
+                                        /* push the record to the appropriate session */
+                                        ssize_t ret;
+                                        size_t sent = 0;
+                                        ASSERT(conn->cc_sctps_data.array != NULL);
+                                        do {
+                                                CHECK_GNUTLS_DO( ret = fd_tls_send_handle_error(conn, conn->cc_sctps_data.array[conn->cc_sctp_para.next].session, buf + sent, len - sent), return ENOTCONN );
+                                                sent += ret;
+                                        } while ( sent < len );
+                                }
+                        }
+                }
+                break;
+#endif /* DISABLE_SCTP */
+        
+                default:
+                        TRACE_DEBUG(INFO, "Unknwon protocol: %d", conn->cc_proto);
+                        return ENOTSUP; /* or EINVAL... */
+        }
+        
+        return 0;
+}
+
+
+/**************************************/
+/*     Destruction of connection      */
+/**************************************/
+
+/* Destroy a conn structure, and shutdown the socket */
+void fd_cnx_destroy(struct cnxctx * conn)
+{
+        TRACE_ENTRY("%p", conn);
+        
+        CHECK_PARAMS_DO(conn, return);
+
+        /* In case of TLS, stop receiver thread, then close properly the gnutls session */
+        if ((conn->cc_tls) && (conn->cc_sctp_para.pairs > 1)) {
+#ifndef DISABLE_SCTP
+                /* Multi-stream TLS: Stop all decipher threads, but not the demux thread */
+                fd_sctps_stopthreads(conn);
+#endif /* DISABLE_SCTP */
+        } else {
+                /* Stop the decoding thread */
+                CHECK_FCT_DO( fd_thr_term(&conn->cc_rcvthr), /* continue */ );
+        }
+        
+        /* Terminate properly the TLS session(s) */
+        if (conn->cc_tls) {
+                /* Master session */
+                CHECK_GNUTLS_DO( gnutls_bye(conn->cc_tls_para.session, GNUTLS_SHUT_RDWR), /* Continue */ );
+                gnutls_deinit(conn->cc_tls_para.session);
+                
+#ifndef DISABLE_SCTP
+                if (conn->cc_sctp_para.pairs > 1) {
+                        /* Multi-stream TLS: destroy the wrapper and stop the demux thread */
+                        fd_sctps_destroy(conn);
+                }
+#endif /* DISABLE_SCTP */
+                
+        }
+        
+        /* Shut the connection down */
+        if (conn->cc_socket > 0) {
+                shutdown(conn->cc_socket, SHUT_RDWR);
+        }
+        
+        /* Empty and destroy FIFO list */
+        if (conn->cc_incoming) {
+                fd_event_destroy( &conn->cc_incoming, free );
+        }
+        
+        /* Free the object */
+        free(conn);
+        
+        /* Done! */
+        return;
+}

freeDiameter/config.c

@@ -100 +100 @@
                         struct fd_endpoint * ep = (struct fd_endpoint *)li;
                         if (li != fd_g_config->cnf_endpoints.next) fd_log_debug("                             ");
-                        sSA_DUMP_NODE( &ep->ss, NI_NUMERICHOST );
+                        sSA_DUMP_NODE( &ep->sa, NI_NUMERICHOST );
                         fd_log_debug("\n");
                         li = li->next;
@@ -229 +229 @@
         }
         
+        /* Validate local endpoints */
+        if ((!FD_IS_LIST_EMPTY(&fd_g_config->cnf_endpoints)) && (fd_g_config->cnf_flags.no_ip4 || fd_g_config->cnf_flags.no_ip6)) {
+                struct fd_list * li;
+                for ( li = fd_g_config->cnf_endpoints.next; li != &fd_g_config->cnf_endpoints; li = li->next) {
+                        struct fd_endpoint * ep = (struct fd_endpoint *)li;
+                        if ( (fd_g_config->cnf_flags.no_ip4 && (ep->sa.sa_family == AF_INET))
+                           ||(fd_g_config->cnf_flags.no_ip6 && (ep->sa.sa_family == AF_INET6)) ) {
+                                li = li->prev;
+                                fd_list_unlink(&ep->chain);
+                                if (TRACE_BOOL(INFO)) {
+                                        fd_log_debug("Info: Removing local address conflicting with the flags no_IP / no_IP6 : ");
+                                        sSA_DUMP_NODE( &ep->sa, AI_NUMERICHOST );
+                                        fd_log_debug("\n");
+                                }
+                                free(ep);
+                        }
+                }
+        }
+        
         /* Configure TLS default parameters */
         if (! fd_g_config->cnf_sec_data.prio_string) {
@@ -239 +258 @@
         }
         if (! fd_g_config->cnf_sec_data.dh_bits) {
-                TRACE_DEBUG(FULL, "Generating DH parameters...");
+                if (TRACE_BOOL(INFO)) {
+                        fd_log_debug("Generating Diffie-Hellman parameters of size %d (this takes a few seconds)... ", GNUTLS_DEFAULT_DHBITS);
+                }
                 CHECK_GNUTLS_DO( gnutls_dh_params_generate2( 
                                         fd_g_config->cnf_sec_data.dh_cache,
                                         GNUTLS_DEFAULT_DHBITS),
                                  { TRACE_DEBUG(INFO, "Error in DH bits value : %d", GNUTLS_DEFAULT_DHBITS); return EINVAL; } );
-                TRACE_DEBUG(FULL, "DH parameters generated.");
-        }
-        
+                if (TRACE_BOOL(INFO)) {
+                        fd_log_debug("Done!\n");
+                }
+        }
         
         return 0;

freeDiameter/fD.h

@@ -152 +152 @@
 enum {
         /* Dump all info about this peer in the debug log */
-         FDEVP_DUMP_ALL = 2000
+         FDEVP_DUMP_ALL = 1500
         
         /* request to terminate this peer : disconnect, requeue all messages */
         ,FDEVP_TERMINATE
         
-        /* A message was received in the peer */
-        ,FDEVP_MSG_INCOMING
+        /* A connection object has received a message. (data contains the buffer) */
+        ,FDEVP_CNX_MSG_RECV
+                         
+        /* A connection object has encountered an error (disconnected). */
+        ,FDEVP_CNX_ERROR
+        
+        /* Endpoints of a connection have been changed (multihomed SCTP). */
+        ,FDEVP_CNX_EP_CHANGE
+        
+        /* A new connection has been established (data contains the appropriate info) */
+        ,FDEVP_CNX_INCOMING
         
         /* The PSM state is expired */
         ,FDEVP_PSM_TIMEOUT
+        
 };
 const char * fd_pev_str(int event);
 #define CHECK_EVENT( _e ) \
         (((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 */
@@ -173 +190 @@
 };
 
-/* The connection context structure */
-struct cnxctx {
-        int             cc_socket;      /* The socket object of the connection -- <=0 if no socket is created */
-        
-        struct fifo   **cc_events;      /* Location of the events list to send connection events */
-        
-        int             cc_proto;       /* IPPROTO_TCP or IPPROTO_SCTP */
-        int             cc_tls;         /* Is TLS already started ? */
-        
-        uint16_t        cc_port;        /* Remote port of the connection, when we are client */
-        struct fd_list  cc_ep_remote;   /* The remote address(es) of the connection */
-        struct fd_list  cc_ep_local;    /* The local address(es) of the connection */
-        
-        /* If cc_proto == SCTP */
-        struct  {
-                int             str_out;/* Out streams */
-                int             str_in; /* In streams */
-                int             pairs;  /* max number of pairs ( = min(in, out)) */
-                int             next;   /* # of stream the next message will be sent to */
-        }               cc_sctp_para;
-        
-        /* If cc_tls == true */
-        struct {
-                int                              mode;          /* GNUTLS_CLIENT / GNUTLS_SERVER */
-                gnutls_session_t                 session;       /* Session object (stream #0 in case of SCTP) */
-        }               cc_tls_para;
-        
-        /* If both conditions */
-        struct {
-                gnutls_session_t                *res_sessions;  /* Sessions of other pairs of streams, resumed from the first */
-                /* Buffers, threads, ... */
-        }               cc_sctp_tls_para;
-};
 
 /* Functions */
-int fd_peer_fini();
+int  fd_peer_fini();
 void fd_peer_dump_list(int details);
 void fd_peer_dump(struct fd_peer * peer, int details);
-int fd_peer_alloc(struct fd_peer ** ptr);
-int fd_peer_free(struct fd_peer ** ptr);
+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 );
 /* fd_peer_add declared in freeDiameter.h */
+int fd_peer_validate( struct fd_peer * peer );
 
 /* Peer expiry */
@@ -221 +207 @@
 
 /* Peer state machine */
-int fd_psm_start();
-int fd_psm_begin(struct fd_peer * peer );
-int fd_psm_terminate(struct fd_peer * peer );
+int  fd_psm_start();
+int  fd_psm_begin(struct fd_peer * peer );
+int  fd_psm_terminate(struct fd_peer * peer );
 void fd_psm_abord(struct fd_peer * peer );
 
 /* Server sockets */
 void fd_servers_dump();
-int fd_servers_start();
-void fd_servers_stop();
-
-/* Connection contexts */
-struct cnxctx * fd_cnx_init(int sock, int proto);
-int fd_cnx_handshake(struct cnxctx * conn, int mode);
-
-/* SCTP */
-#ifndef DISABLE_SCTP
-int fd_sctp_create_bind_server( int * socket, uint16_t port );
-int fd_sctp_get_str_info( int socket, int *in, int *out );
-
-#endif /* DISABLE_SCTP */
-
+int  fd_servers_start();
+int  fd_servers_stop();
+
+/* Connection contexts -- there are also definitions in cnxctx.h for the relevant files */
+struct cnxctx * fd_cnx_serv_tcp(uint16_t port, int family, struct fd_endpoint * ep);
+struct cnxctx * fd_cnx_serv_sctp(uint16_t port, struct fd_list * ep_list);
+int             fd_cnx_serv_listen(struct cnxctx * conn);
+struct cnxctx * fd_cnx_serv_accept(struct cnxctx * serv);
+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_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);
+char *          fd_cnx_getremoteid(struct cnxctx * conn);
+int             fd_cnx_receive(struct cnxctx * conn, struct timespec * timeout, unsigned char **buf, size_t * len);
+int             fd_cnx_recv_setaltfifo(struct cnxctx * conn, struct fifo * alt_fifo); /* send FDEVP_CNX_MSG_RECV event to the fifo list */
+int             fd_cnx_send(struct cnxctx * conn, unsigned char * buf, size_t len);
+void            fd_cnx_destroy(struct cnxctx * conn);
 
 

freeDiameter/fdd.y

@@ -212 +212 @@
 listenon:               LISTENON '=' QSTRING ';'
                         {
-                                struct fd_endpoint * ep;
                                 struct addrinfo hints, *ai;
                                 int ret;
-                                
-                                CHECK_MALLOC_DO( ep = malloc(sizeof(struct fd_endpoint)),
-                                        { yyerror (&yylloc, conf, "Out of memory"); YYERROR; } );
-                                memset(ep, 0, sizeof(struct fd_endpoint));
-                                fd_list_init(&ep->chain, NULL);
-                                ep->meta.conf = 1;
                                 
                                 memset(&hints, 0, sizeof(hints));
                                 hints.ai_flags = AI_PASSIVE | AI_NUMERICHOST;
                                 ret = getaddrinfo($3, NULL, &hints, &ai);
-                                if (ret) { yyerror (&yylloc, conf, gai_strerror(ret)); free(ep); YYERROR; }
-                                ASSERT( ai->ai_addrlen <= sizeof(sSS) );
-                                memcpy(&ep->ss, ai->ai_addr, ai->ai_addrlen);
+                                if (ret) { yyerror (&yylloc, conf, gai_strerror(ret)); YYERROR; }
+                                CHECK_FCT_DO( fd_ep_add_merge( &conf->cnf_endpoints, ai->ai_addr, ai->ai_addrlen, EP_FL_CONF ), YYERROR );
+                                freeaddrinfo(ai);
                                 free($3);
-                                freeaddrinfo(ai);
-                                fd_list_insert_before(&conf->cnf_endpoints, &ep->chain);
                         }
                         ;
@@ -336 +327 @@
                                 /* Now destroy any content in the structure */
                                 free(fddpi.pi_diamid);
+                                free(fddpi.pi_sec_data.priority);
                                 while (!FD_IS_LIST_EMPTY(&fddpi.pi_endpoints)) {
                                         struct fd_list * li = fddpi.pi_endpoints.next;
@@ -415 +407 @@
                                 fddpi.pi_port = (uint16_t)$4;
                         }
-                        | peerparams SCTPSTREAMS '=' INTEGER ';'
-                        {
-                                CHECK_PARAMS_DO( ($4 > 0) && ($4 < 1<<16),
-                                        { yyerror (&yylloc, conf, "Invalid value"); YYERROR; } );
-                                fddpi.pi_streams = (uint16_t)$4;
-                        }
                         | peerparams TCTIMER '=' INTEGER ';'
                         {
                                 fddpi.pi_tctimer = $4;
                         }
+                        | peerparams TLS_PRIO '=' QSTRING ';'
+                        {
+                                fddpi.pi_sec_data.priority = $4;
+                        }
                         | peerparams TWTIMER '=' INTEGER ';'
                         {
@@ -431 +421 @@
                         | peerparams CONNTO '=' QSTRING ';'
                         {
-                                struct fd_endpoint * ep;
                                 struct addrinfo hints, *ai;
                                 int ret;
+                                int disc = 0;
                                 
-                                CHECK_MALLOC_DO( ep = malloc(sizeof(struct fd_endpoint)),
-                                        { yyerror (&yylloc, conf, "Out of memory"); YYERROR; } );
-                                memset(ep, 0, sizeof(struct fd_endpoint));
-                                fd_list_init(&ep->chain, NULL);
-                                ep->meta.conf = 1;
                                 memset(&hints, 0, sizeof(hints));
                                 hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICHOST;
@@ -445 +430 @@
                                 if (ret == EAI_NONAME) {
                                         /* The name was maybe not numeric, try again */
-                                        ep->meta.disc = 1;
+                                        disc = EP_FL_DISC;
                                         hints.ai_flags &= ~ AI_NUMERICHOST;
                                         ret = getaddrinfo($4, NULL, &hints, &ai);
                                 }
-                                if (ret) { yyerror (&yylloc, conf, gai_strerror(ret)); free(ep); YYERROR; }
+                                if (ret) { yyerror (&yylloc, conf, gai_strerror(ret)); YYERROR; }
                                 
-                                memcpy(&ep->ss, ai->ai_addr, ai->ai_addrlen);
+                                CHECK_FCT_DO( fd_ep_add_merge( &fddpi.pi_endpoints, ai->ai_addr, ai->ai_addrlen, EP_FL_CONF | disc ), YYERROR );
                                 free($4);
                                 freeaddrinfo(ai);
-                                fd_list_insert_before(&fddpi.pi_endpoints, &ep->chain);
                         }
                         ;

freeDiameter/main.c

@@ -51 +51 @@
 struct fd_config * fd_g_config = &conf;
 
+/* gcrypt functions to support posix threads */
 GCRY_THREAD_OPTION_PTHREAD_IMPL;
 
@@ -105 +106 @@
         CHECK_FCT(  fd_ext_load()  );
         
+        fd_conf_dump();
+        
+        /* Start the servers */
+        CHECK_FCT( fd_servers_start() );
+        
         /* Start the peer state machines */
         CHECK_FCT( fd_psm_start() );
@@ -110 +116 @@
         /* Now, just wait for events */
         TRACE_DEBUG(INFO, FD_PROJECT_BINARY " daemon initialized.");
-        fd_conf_dump();
         while (1) {
-                int code;
-                CHECK_FCT_DO(  fd_event_get(fd_g_config->cnf_main_ev, &code, NULL),  break  );
+                int code; size_t sz; void * data;
+                CHECK_FCT_DO(  fd_event_get(fd_g_config->cnf_main_ev, &code, &sz, &data),  break  );
                 switch (code) {
                         case FDEV_DUMP_DICT:
@@ -154 +159 @@
         
         /* cleanups */
+        CHECK_FCT_DO( fd_servers_stop(), /* Stop accepting new connections */ );
         TODO("Stop dispatch thread(s) properly (no cancel yet)");
         CHECK_FCT_DO( fd_peer_fini(), /* Stop all connections */ );
@@ -333 +339 @@
         
         TRACE_DEBUG(INFO, "Received signal %s (%d), exiting", SIGNALSTR(sig), sig);
-        CHECK_FCT_DO( fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, NULL), exit(2) );
+        CHECK_FCT_DO( fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, 0, NULL), exit(2) );
         return NULL;
 }

freeDiameter/p_expiry.c

@@ -47 +47 @@
 static void * gc_th_fct(void * arg)
 {
-        fd_log_threadname ( "Peers/garbage" );
-        TRACE_ENTRY( "" );
+        fd_log_threadname ( "Peers/garb. col." );
+        TRACE_ENTRY( "%p", arg );
         
         do {
                 struct fd_list * li, purge = FD_LIST_INITIALIZER(purge);
                 
-                pthread_testcancel();
-                sleep(GC_TIME);
+                sleep(GC_TIME); /* sleep is a cancellation point */
                 
                 /* Now check in the peers list if any peer can be deleted */
@@ -88 +87 @@
         TRACE_DEBUG(INFO, "An error occurred in peers module! GC thread is terminating...");
         ASSERT(0);
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, NULL), );
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, 0, NULL), );
         return NULL;
 }
@@ -96 +95 @@
 {
         fd_log_threadname ( "Peers/expire" );
-        TRACE_ENTRY( "" );
+        TRACE_ENTRY( "%p", arg );
         
         CHECK_POSIX_DO( pthread_mutex_lock(&exp_mtx),  goto error );
@@ -124 +123 @@
                         
                         CHECK_POSIX_DO2(  pthread_cond_timedwait( &exp_cnd, &exp_mtx, &first->p_exp_timer ),  
-                                        ETIMEDOUT, /* ETIMEDOUT is a normal error, continue */,
+                                        ETIMEDOUT, /* ETIMEDOUT is a normal return value, continue */,
                                         /* on other error, */ goto error );
         
@@ -133 +132 @@
                 /* Now, the first peer in the list is expired; signal it */
                 fd_list_unlink( &first->p_expiry );
-                CHECK_FCT_DO( fd_event_send(first->p_events, FDEVP_TERMINATE, NULL), goto error );
+                CHECK_FCT_DO( fd_event_send(first->p_events, FDEVP_TERMINATE, 0, NULL), goto error );
                 
         } while (1);
@@ -141 +140 @@
         TRACE_DEBUG(INFO, "An error occurred in peers module! Expiry thread is terminating...");
         ASSERT(0);
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, NULL), );
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, 0, NULL), );
         return NULL;
 }

freeDiameter/p_psm.c

@@ -55 +55 @@
         #define case_str( _val )\
                 case _val : return #_val
+                case_str(FDEVP_DUMP_ALL);
                 case_str(FDEVP_TERMINATE);
-                case_str(FDEVP_DUMP_ALL);
-                case_str(FDEVP_MSG_INCOMING);
+                case_str(FDEVP_CNX_MSG_RECV);
+                case_str(FDEVP_CNX_ERROR);
+                case_str(FDEVP_CNX_EP_CHANGE);
+                case_str(FDEVP_CNX_INCOMING);
                 case_str(FDEVP_PSM_TIMEOUT);
                 
@@ -125 +128 @@
 }
 
-/* Wait for the next event in the PSM, or timeout */
-static int psm_ev_timedget(struct fd_peer * peer, int *code, void ** data)
-{
-        struct fd_event * ev;
-        int ret = 0;
-        
-        TRACE_ENTRY("%p %p %p", peer, code, data);
-        
-        ret = fd_fifo_timedget(peer->p_events, &ev, &peer->p_psm_timer);
-        if (ret == ETIMEDOUT) {
-                *code = FDEVP_PSM_TIMEOUT;
-                *data = NULL;
-        } else {
-                CHECK_FCT( ret );
-                *code = ev->code;
-                *data = ev->data;
-                free(ev);
-        }
-        
-        return 0;
-}
-
 /* The state machine thread (controler) */
 static void * p_psm_th( void * arg )
@@ -153 +134 @@
         int created_started = started;
         int event;
+        size_t ev_sz;
         void * ev_data;
         
@@ -181 +163 @@
 psm_loop:
         /* Get next event */
-        CHECK_FCT_DO( psm_ev_timedget(peer, &event, &ev_data), goto psm_end );
-        TRACE_DEBUG(FULL, "'%s'\t<-- '%s'\t(%p)\t'%s'",
+        CHECK_FCT_DO( fd_event_timedget(peer->p_events, &peer->p_psm_timer, FDEVP_PSM_TIMEOUT, &event, &ev_sz, &ev_data), goto psm_end );
+        TRACE_DEBUG(FULL, "'%s'\t<-- '%s'\t(%p,%zd)\t'%s'",
                         STATE_STR(peer->p_hdr.info.pi_state),
-                        fd_pev_str(event), ev_data,
+                        fd_pev_str(event), ev_data, ev_sz,
                         peer->p_hdr.info.pi_diamid);
 
@@ -227 +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 */
@@ -241 +249 @@
 psm_end:
         pthread_cleanup_pop(1); /* set STATE_ZOMBIE */
+        peer->p_psm = (pthread_t)NULL;
+        pthread_detach(pthread_self());
         return NULL;
 }       
-        
-        
-
 
 /* Create the PSM thread of one peer structure */
@@ -267 +274 @@
         TRACE_ENTRY("%p", peer);
         CHECK_PARAMS( CHECK_PEER(peer) );
+        
         if (peer->p_hdr.info.pi_state != STATE_ZOMBIE) {
-                CHECK_FCT( fd_event_send(peer->p_events, FDEVP_TERMINATE, NULL) );
+                CHECK_FCT( fd_event_send(peer->p_events, FDEVP_TERMINATE, 0, NULL) );
         } else {
                 TRACE_DEBUG(FULL, "Peer '%s' was already terminated", peer->p_hdr.info.pi_diamid);

freeDiameter/peers.c

@@ -101 +101 @@
         
         p->p_hdr.info.pi_lft     = info->pi_lft;
-        p->p_hdr.info.pi_streams = info->pi_streams;
         p->p_hdr.info.pi_port    = info->pi_port;
         p->p_hdr.info.pi_tctimer = info->pi_tctimer;
         p->p_hdr.info.pi_twtimer = info->pi_twtimer;
+        
+        if (info->pi_sec_data.priority) {
+                CHECK_MALLOC( p->p_hdr.info.pi_sec_data.priority = strdup(info->pi_sec_data.priority) );
+        }
         
         /* Move the items from one list to the other */
@@ -114 +117 @@
                 }
         
+        
         /* The internal data */
         if (orig_dbg) {
@@ -127 +131 @@
         
         for (li = fd_g_peers.next; li != &fd_g_peers; li = li->next) {
-                struct fd_peer * prev = (struct fd_peer *)li;
-                int cmp = strcasecmp( p->p_hdr.info.pi_diamid, prev->p_hdr.info.pi_diamid );
-                if (cmp < 0)
+                struct fd_peer * next = (struct fd_peer *)li;
+                int cmp = strcasecmp( p->p_hdr.info.pi_diamid, next->p_hdr.info.pi_diamid );
+                if (cmp > 0)
                         continue;
                 if (cmp == 0)
@@ -229 +233 @@
         
         if (p->p_cnxctx) {
-                TODO("destroy p->p_cnxctx");
+                fd_cnx_destroy(p->p_cnxctx);
         }
         
@@ -293 +297 @@
                 list_empty = FD_IS_LIST_EMPTY(&fd_g_peers);
                 CHECK_FCT_DO( pthread_rwlock_unlock(&fd_g_peers_rw), /* continue */ );
+                CHECK_SYS(  clock_gettime(CLOCK_REALTIME, &now)  );
         }
         
@@ -370 +375 @@
 }
 
+/* Handle an incoming CER request on a new connection */
+int fd_peer_handle_newCER( struct msg ** cer, struct cnxctx ** cnx )
+{
+        struct msg * msg;
+        struct dict_object *avp_oh_model;
+        avp_code_t code = AC_ORIGIN_HOST;
+        struct avp *avp_oh;
+        struct avp_hdr * avp_hdr;
+        struct fd_list * li;
+        int found = 0;
+        int ret = 0;
+        struct fd_peer * peer;
+        struct cnx_incoming * ev_data;
+        
+        TRACE_ENTRY("%p %p", cer, cnx);
+        CHECK_PARAMS(cer && *cer && cnx && *cnx);
+        
+        msg = *cer; 
+        
+        /* Find the Diameter Identity of the remote peer in the message */
+        CHECK_FCT( fd_dict_search ( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_CODE, &code, &avp_oh_model, ENOENT) );
+        CHECK_FCT( fd_msg_search_avp ( msg, avp_oh_model, &avp_oh ) );
+        CHECK_FCT( fd_msg_avp_hdr ( avp_oh, &avp_hdr ) );
+        
+        /* Search if we already have this peer id in our list */
+        CHECK_POSIX( pthread_rwlock_rdlock(&fd_g_peers_rw) );
+        
+        for (li = fd_g_peers.next; li != &fd_g_peers; li = li->next) {
+                peer = (struct fd_peer *)li;
+                int cmp = strncasecmp( avp_hdr->avp_value->os.data, peer->p_hdr.info.pi_diamid, avp_hdr->avp_value->os.len );
+                if (cmp > 0)
+                        continue;
+                if (cmp == 0)
+                        found = 1;
+                break;
+        }
+        
+        if (!found) {
+                /* 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) );
+
+        if (ret == 0) {
+                /* Reset the "out" parameters, so that they are not cleanup on function return. */
+                *cer = NULL;
+                *cnx = NULL;
+        }
+        
+        return ret;
+}
+
+/* Save a callback to accept / reject incoming unknown peers */
+int fd_peer_validate_register ( int (*peer_validate)(struct peer_info * /* info */, int * /* auth */, int (**cb2)(struct peer_info *)) )
+{
+        
+        TODO("...");
+        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

@@ -35 +35 @@
 
 #include "fD.h"
-
-int fd_sctp_create_bind_server( int * socket, uint16_t port )
+#include "cnxctx.h"
+
+#include <netinet/sctp.h>
+#include <sys/uio.h>
+
+/* Size of buffer to receive ancilliary data. May need to be enlarged if more sockopt are set... */
+#ifndef CMSG_BUF_LEN
+#define CMSG_BUF_LEN    1024
+#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)
 {
-        TODO("Create sctp server, using fd_g_config: cnf_endpoints, no_ip4, no_ip6, cnf_sctp_str");
-        
-        return ENOTSUP;
+        socklen_t sz;
+        
+        TRACE_ENTRY( "%d", sk);
+        
+        CHECK_PARAMS( sk > 0 );
+        
+        /* Subscribe to some notifications */
+        {
+                struct sctp_event_subscribe event;
+
+                memset(&event, 0, sizeof(event));
+                event.sctp_data_io_event        = 1;    /* to receive the stream ID in SCTP_SNDRCV ancilliary data on message reception */
+                event.sctp_association_event    = 0;    /* new or closed associations (mostly for one-to-many style sockets) */
+                event.sctp_address_event        = 1;    /* address changes */
+                event.sctp_send_failure_event   = 1;    /* delivery failures */
+                event.sctp_peer_error_event     = 1;    /* remote peer sends an error */
+                event.sctp_shutdown_event       = 1;    /* peer has sent a SHUTDOWN */
+                event.sctp_partial_delivery_event = 1;  /* a partial delivery is aborted, probably indicating the connection is being shutdown */
+                // event.sctp_adaptation_layer_event = 0;       /* adaptation layer notifications */
+                // event.sctp_authentication_event = 0; /* when new key is made active */
+
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_EVENTS, &event, sizeof(event)) );
+                
+                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);
+                }
+                
+        }
+        
+        /* Set the INIT parameters, such as number of streams */
+        {
+                struct sctp_initmsg init;
+                memset(&init, 0, sizeof(init));
+                
+                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 */
+                init.sinit_num_ostreams   = fd_g_config->cnf_sctp_str;  /* desired number of outgoing streams */
+                init.sinit_max_init_timeo = CNX_TIMEOUT * 1000;
+
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_INITMSG, &init, sizeof(init))  );
+                
+                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);
+                }
+        }
+        
+        /* Set the SCTP_DISABLE_FRAGMENTS option, required for TLS */
+        #ifdef SCTP_DISABLE_FRAGMENTS
+        {
+                int nofrag;
+                
+                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 */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_DISABLE_FRAGMENTS, &nofrag, sizeof(nofrag))  );
+                
+                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 */
+        # error "TLS requires support of SCTP_DISABLE_FRAGMENTS"
+        #endif /* SCTP_DISABLE_FRAGMENTS */
+        
+        
+        /* Set the RETRANSMIT parameters */
+        #ifdef SCTP_RTOINFO
+        {
+                struct sctp_rtoinfo rtoinfo;
+                memset(&rtoinfo, 0, sizeof(rtoinfo));
+
+                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) */
+
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_RTOINFO, &rtoinfo, sizeof(rtoinfo))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_RTOINFO");
+        #endif /* SCTP_RTOINFO */
+        
+        /* Set the ASSOCIATION parameters */
+        #ifdef SCTP_ASSOCINFO
+        {
+                struct sctp_assocparams assoc;
+                memset(&assoc, 0, sizeof(assoc));
+
+                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 */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_ASSOCINFO, &assoc, sizeof(assoc))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_ASSOCINFO");
+        #endif /* SCTP_ASSOCINFO */
+        
+        
+        /* The SO_LINGER option will be re-set if we want to perform SCTP ABORT */
+        #ifdef SO_LINGER
+        {
+                struct linger linger;
+                memset(&linger, 0, sizeof(linger));
+                
+                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 */
+                linger.l_linger = 0;    /* Return immediately when closing (=> abort) */
+                
+                /* Set the option */
+                CHECK_SYS(  setsockopt(sk, SOL_SOCKET, SO_LINGER, &linger, sizeof(linger))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SO_LINGER");
+        #endif /* SO_LINGER */
+        
+        /* Set the NODELAY option (Nagle-like algorithm) */
+        #ifdef SCTP_NODELAY
+        {
+                int nodelay;
+                
+                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) */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_NODELAY, &nodelay, sizeof(nodelay))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_NODELAY");
+        #endif /* SCTP_NODELAY */
+        
+        /* Set the interleaving option */
+        #ifdef SCTP_FRAGMENT_INTERLEAVE
+        {
+                int interleave;
+                
+                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
+                interleave = 2; /* Allow partial delivery on several streams at the same time, since we are stream-aware in our security modules */
+                #else /* 0 */
+                interleave = 1; /* hmmm actually, we are not yet capable of handling this, and we don t need it. */
+                #endif /* 0 */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_FRAGMENT_INTERLEAVE, &interleave, sizeof(interleave))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_FRAGMENT_INTERLEAVE");
+        #endif /* SCTP_FRAGMENT_INTERLEAVE */
+        
+        /* Set the v4 mapped addresses option */
+        #ifdef SCTP_I_WANT_MAPPED_V4_ADDR
+        {
+                int v4mapped;
+                
+                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
+                v4mapped = 0;   /* We don't want v4 mapped addresses */
+#else /* SCTP_USE_MAPPED_ADDRESSES */
+                v4mapped = 1;   /* but we may have to, otherwise the bind fails in some environments */
+#endif /* SCTP_USE_MAPPED_ADDRESSES */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_I_WANT_MAPPED_V4_ADDR, &v4mapped, sizeof(v4mapped))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_I_WANT_MAPPED_V4_ADDR");
+        #endif /* SCTP_I_WANT_MAPPED_V4_ADDR */
+                           
+                           
+        /* Other settable options (draft-ietf-tsvwg-sctpsocket-17):
+           SO_RCVBUF                    size of receiver window
+           SO_SNDBUF                    size of pending data to send
+           SCTP_AUTOCLOSE               for one-to-many only
+           SCTP_SET_PEER_PRIMARY_ADDR   ask remote peer to use this local address as primary
+           SCTP_PRIMARY_ADDR            use this address as primary locally
+           SCTP_ADAPTATION_LAYER        set adaptation layer indication 
+           SCTP_PEER_ADDR_PARAMS        control heartbeat per peer address
+           SCTP_DEFAULT_SEND_PARAM      parameters for the sendto() call
+           SCTP_MAXSEG                  max size of fragmented segments -- bound to PMTU
+           SCTP_AUTH_CHUNK              request authentication of some type of chunk
+            SCTP_HMAC_IDENT             authentication algorithms
+            SCTP_AUTH_KEY               set a shared key
+            SCTP_AUTH_ACTIVE_KEY        set the active key
+            SCTP_AUTH_DELETE_KEY        remove a key
+            SCTP_AUTH_DEACTIVATE_KEY    will not use that key anymore
+           SCTP_DELAYED_SACK            control delayed acks
+           SCTP_PARTIAL_DELIVERY_POINT  control partial delivery size
+           SCTP_USE_EXT_RCVINFO         use extended receive info structure (information about the next message if available)
+           SCTP_MAX_BURST               number of packets that can be burst emitted
+           SCTP_CONTEXT                 save a context information along with the association.
+           SCTP_EXPLICIT_EOR            enable sending one message across several send calls
+           SCTP_REUSE_PORT              share one listening port with several sockets
+           
+           read-only options:
+           SCTP_STATUS                  retrieve info such as number of streams, pending packets, state, ...
+           SCTP_GET_PEER_ADDR_INFO      get information about a specific peer address of the association.
+           SCTP_PEER_AUTH_CHUNKS        list of chunks the remote peer wants authenticated
+           SCTP_LOCAL_AUTH_CHUNKS       list of chunks the local peer wants authenticated
+           SCTP_GET_ASSOC_NUMBER        number of associations in a one-to-many socket
+           SCTP_GET_ASSOC_ID_LIST       list of these associations
+        */
+        
+        /* In case of no_ip4, force the v6only option -- is it a valid option for SCTP ? */
+        #ifdef IPV6_V6ONLY
+        if (fd_g_config->cnf_flags.no_ip4) {
+                int opt = 1;
+                CHECK_SYS(setsockopt(sk, IPPROTO_IPV6, IPV6_V6ONLY, &opt, sizeof(opt)));
+        }
+        #endif /* IPV6_V6ONLY */
+        
+        return 0;
 }
 
-int fd_sctp_get_str_info( int socket, int *in, int *out )
+
+/* Post-binding socket options */
+static int fd_setsockopt_postbind(int sk, int bound_to_default)
 {
-        TODO("Retrieve streams info from the socket");
-        
-        return ENOTSUP;
+        TRACE_ENTRY( "%d %d", sk, bound_to_default);
+        
+        CHECK_PARAMS( (sk > 0) );
+        
+        /* Set the ASCONF option */
+        #ifdef SCTP_AUTO_ASCONF
+        {
+                int asconf;
+                
+                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) */
+                
+                /* Set the option to the socket */
+                CHECK_SYS(  setsockopt(sk, IPPROTO_SCTP, SCTP_AUTO_ASCONF, &asconf, sizeof(asconf))  );
+                
+                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 */
+        TRACE_DEBUG(SCTP_LEVEL, "Skipping SCTP_AUTO_ASCONF");
+        #endif /* SCTP_AUTO_ASCONF */
+        
+        return 0;
 }
+
+/* Create a socket server and bind it according to daemon s configuration */
+int fd_sctp_create_bind_server( int * sock, struct fd_list * list, uint16_t port )
+{
+        int family;
+        int bind_default;
+        
+        TRACE_ENTRY("%p %p %hu", sock, list, port);
+        CHECK_PARAMS(sock);
+        
+        if (fd_g_config->cnf_flags.no_ip6) {
+                family = AF_INET;
+        } else {
+                family = AF_INET6; /* can create socket for both IP and IPv6 */
+        }
+        
+        /* Create the socket */
+        CHECK_SYS( *sock = socket(family, SOCK_STREAM, IPPROTO_SCTP) );
+        
+        /* Set pre-binding socket options, including number of streams etc... */
+        CHECK_FCT( fd_setsockopt_prebind(*sock) );
+        
+        bind_default = (! list) || (FD_IS_LIST_EMPTY(list)) ;
+redo:
+        if ( bind_default ) {
+                /* Implicit endpoints : bind to default addresses */
+                union {
+                        sSS  ss;
+                        sSA  sa;
+                        sSA4 sin;
+                        sSA6 sin6;
+                } s;
+                
+                /* 0.0.0.0 and [::] are all zeros */
+                memset(&s, 0, sizeof(s));
+                
+                s.sa.sa_family = family;
+                
+                if (family == AF_INET)
+                        s.sin.sin_port = htons(port);
+                else
+                        s.sin6.sin6_port = htons(port);
+                
+                CHECK_SYS( bind(*sock, &s.sa, sizeof(s)) );
+                
+        } else {
+                /* Explicit endpoints to bind to from config */
+                
+                union {
+                        sSA     * sa;
+                        sSA4    *sin;
+                        sSA6    *sin6;
+                        uint8_t *buf;
+                } ptr;
+                union {
+                        sSA     * sa;
+                        uint8_t * buf;
+                } sar;
+                int count = 0; /* number of sock addr in sar array */
+                size_t offset = 0;
+                struct fd_list * li;
+                
+                sar.buf = NULL;
+                
+                /* Create a flat array from the list of configured addresses */
+                for (li = list->next; li != list; li = li->next) {
+                        struct fd_endpoint * ep = (struct fd_endpoint *)li;
+                        size_t sz = 0;
+                        
+                        if (! (ep->flags & EP_FL_CONF))
+                                continue;
+                        
+                        count++;
+                        
+                        /* Size of the new SA we are adding (sar may contain a mix of sockaddr_in and sockaddr_in6) */
+#ifndef SCTP_USE_MAPPED_ADDRESSES
+                        if (ep->sa.sa_family == AF_INET6)
+#else /* SCTP_USE_MAPPED_ADDRESSES */
+                        if (family == AF_INET6)
+#endif /* SCTP_USE_MAPPED_ADDRESSES */
+                                sz = sizeof(sSA6);
+                        else
+                                sz = sizeof(sSA4);
+                        
+                        /* augment sar to contain the additional info */
+                        CHECK_MALLOC( sar.buf = realloc(sar.buf, offset + sz)  );
+                        
+                        ptr.buf = sar.buf + offset; /* place of the new SA */
+                        offset += sz; /* update to end of sar */
+                        
+                        if (sz == sizeof(sSA4)) {
+                                memcpy(ptr.buf, &ep->sin, sz);
+                                ptr.sin->sin_port = htons(port);
+                        } else {
+                                if (ep->sa.sa_family == AF_INET) { /* We must map the address */ 
+                                        memset(ptr.buf, 0, sz);
+                                        ptr.sin6->sin6_family = AF_INET6;
+                                        IN6_ADDR_V4MAP( &ptr.sin6->sin6_addr.s6_addr, ep->sin.sin_addr.s_addr );
+                                } else {
+                                        memcpy(ptr.sin6, &ep->sin6, sz);
+                                }
+                                ptr.sin6->sin6_port = htons(port);
+                        }
+                }
+                
+                if (!count) {
+                        /* None of the addresses in the list came from configuration, we bind to default */
+                        bind_default = 1;
+                        goto redo;
+                }
+                
+                if (TRACE_BOOL(SCTP_LEVEL)) {
+                        int i;
+                        ptr.buf = sar.buf;
+                        fd_log_debug("Calling sctp_bindx with the following address array:\n");
+                        for (i = 0; i < count; i++) {
+                                TRACE_DEBUG_sSA(FULL, "    - ", ptr.sa, NI_NUMERICHOST | NI_NUMERICSERV, "" );
+                                ptr.buf += (ptr.sa->sa_family == AF_INET) ? sizeof(sSA4) : sizeof(sSA6) ;
+                        }
+                }
+                
+                /* Bind to this array */
+                CHECK_SYS(  sctp_bindx(*sock, sar.sa, count, SCTP_BINDX_ADD_ADDR)  );
+                
+                /* We don't need sar anymore */
+                free(sar.buf);
+        }
+        
+        /* Now, the server is bound, set remaining sockopt */
+        CHECK_FCT( fd_setsockopt_postbind(*sock, bind_default) );
+        
+        /* Debug: show all local listening addresses */
+        if (TRACE_BOOL(SCTP_LEVEL)) {
+                sSA *sar;
+                union {
+                        sSA     *sa;
+                        uint8_t *buf;
+                } ptr;
+                int sz;
+                
+                CHECK_SYS(  sz = sctp_getladdrs(*sock, 0, &sar)  );
+                
+                fd_log_debug("SCTP server bound on :\n");
+                for (ptr.sa = sar; sz-- > 0; ptr.buf += (ptr.sa->sa_family == AF_INET) ? sizeof(sSA4) : sizeof(sSA6)) {
+                        TRACE_DEBUG_sSA(FULL, "    - ", ptr.sa, NI_NUMERICHOST | NI_NUMERICSERV, "" );
+                }
+                sctp_freeladdrs(sar);
+        }
+
+        return 0;
+}
+
+/* Allow clients connections on server sockets */
+int fd_sctp_listen( int sock )
+{
+        TRACE_ENTRY("%d", sock);
+        CHECK_SYS( listen(sock, 5) );
+        return 0;
+}
+
+/* Create a client socket and connect to remote server */
+int fd_sctp_client( int *sock, int no_ip6, uint16_t port, struct fd_list * list )
+{
+        int family;
+        int count = 0;
+        size_t offset = 0, sz;
+        union {
+                uint8_t *buf;
+                sSA     *sa;
+        } sar;
+        union {
+                uint8_t *buf;
+                sSA     *sa;
+                sSA4    *sin;
+                sSA6    *sin6;
+        } ptr;
+        struct fd_list * li;
+        int ret;
+        
+        sar.buf = NULL;
+        
+        TRACE_ENTRY("%p %i %hu %p", sock, no_ip6, port, list);
+        CHECK_PARAMS( sock && list && (!FD_IS_LIST_EMPTY(list)) );
+        
+        if (no_ip6) {
+                family = AF_INET;
+        } else {
+                family = AF_INET6;
+        }
+        
+        /* Create the socket */
+        CHECK_SYS( *sock = socket(family, SOCK_STREAM, IPPROTO_SCTP) );
+        
+        /* Cleanup if we are cancelled */
+        pthread_cleanup_push(fd_cleanup_socket, sock);
+        
+        /* Set the socket options */
+        CHECK_FCT_DO( ret = fd_setsockopt_prebind(*sock), goto fail );
+        
+        /* Create the array of addresses for sctp_connectx */
+        for (li = list->next; li != list; li = li->next) {
+                struct fd_endpoint * ep = (struct fd_endpoint *) li;
+                
+                count++;
+                
+                /* Size of the new SA we are adding (sar may contain a mix of sockaddr_in and sockaddr_in6) */
+#ifndef SCTP_USE_MAPPED_ADDRESSES
+                if (ep->sa.sa_family == AF_INET6)
+#else /* SCTP_USE_MAPPED_ADDRESSES */
+                if (family == AF_INET6)
+#endif /* SCTP_USE_MAPPED_ADDRESSES */
+                        sz = sizeof(sSA6);
+                else
+                        sz = sizeof(sSA4);
+                
+                /* augment sar to contain the additional info */
+                CHECK_MALLOC_DO( sar.buf = realloc(sar.buf, offset + sz), { ret = ENOMEM; goto fail; }  );
+
+                ptr.buf = sar.buf + offset; /* place of the new SA */
+                offset += sz; /* update to end of sar */
+                        
+                if (sz == sizeof(sSA4)) {
+                        memcpy(ptr.buf, &ep->sin, sz);
+                        ptr.sin->sin_port = htons(port);
+                } else {
+                        if (ep->sa.sa_family == AF_INET) { /* We must map the address */ 
+                                memset(ptr.buf, 0, sz);
+                                ptr.sin6->sin6_family = AF_INET6;
+                                IN6_ADDR_V4MAP( &ptr.sin6->sin6_addr.s6_addr, ep->sin.sin_addr.s_addr );
+                        } else {
+                                memcpy(ptr.sin6, &ep->sin6, sz);
+                        }
+                        ptr.sin6->sin6_port = htons(port);
+                }
+        }
+        
+        /* Try connecting */
+        TRACE_DEBUG(FULL, "Attempting SCTP connection (%d addresses attempted)...", count);
+        CHECK_SYS_DO( sctp_connectx(*sock, sar.sa, count), { ret = errno; goto fail; } );
+        free(sar.buf); sar.buf = NULL;
+        
+        /* Set the remaining sockopts */
+        CHECK_FCT_DO( ret = fd_setsockopt_postbind(*sock, 1), goto fail );
+        
+        /* Done! */
+        pthread_cleanup_pop(0);
+        return 0;
+        
+fail:
+        if (*sock > 0) {
+                shutdown(*sock, SHUT_RDWR);
+                *sock = -1;
+        }
+        free(sar.buf);
+        return ret;
+}
+
+/* Retrieve streams information from a connected association -- optionaly provide the primary address */
+int fd_sctp_get_str_info( int sock, uint16_t *in, uint16_t *out, sSS *primary )
+{
+        struct sctp_status status;
+        socklen_t sz = sizeof(status);
+        
+        TRACE_ENTRY("%d %p %p %p", sock, in, out, primary);
+        CHECK_PARAMS( (sock > 0) && in && out );
+        
+        /* Read the association parameters */
+        memset(&status, 0, sizeof(status));
+        CHECK_SYS(  getsockopt(sock, IPPROTO_SCTP, SCTP_STATUS, &status, &sz) );
+        if (sz != sizeof(status))
+        {
+                TRACE_DEBUG(INFO, "Invalid size of socket option: %d / %zd", sz, sizeof(status));
+                return ENOTSUP;
+        }
+        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;
+        *out = status.sstat_outstrms;
+        
+        if (primary)
+                memcpy(primary, &status.sstat_primary.spinfo_address, sizeof(sSS));
+        
+        return 0;
+}
+
+/* Get the list of local endpoints of the socket */
+int fd_sctp_get_local_ep(int sock, struct fd_list * list)
+{
+        union {
+                sSA     *sa;
+                uint8_t *buf;
+        } ptr;
+        
+        sSA * data;
+        int count;
+        
+        TRACE_ENTRY("%d %p", sock, list);
+        CHECK_PARAMS(list);
+        
+        /* Read the list on the socket */
+        CHECK_SYS( count = sctp_getladdrs(sock, 0, &data)  );
+        ptr.sa = data;
+        
+        while (count) {
+                socklen_t sl;
+                switch (ptr.sa->sa_family) {
+                        case AF_INET:   sl = sizeof(sSA4); break;
+                        case AF_INET6:  sl = sizeof(sSA6); break;
+                        default:
+                                TRACE_DEBUG(INFO, "Unkown address family returned in sctp_getladdrs: %d", ptr.sa->sa_family);
+                }
+                                
+                CHECK_FCT( fd_ep_add_merge( list, ptr.sa, sl, EP_FL_LL ) );
+                ptr.buf += sl;
+                count --;
+        }
+        
+        /* Free the list */
+        sctp_freeladdrs(data);
+        
+        /* Now get the primary address, the add function will take care of merging with existing entry */
+        {
+                 
+                struct sctp_status status;
+                socklen_t sz = sizeof(status);
+                int ret;
+                
+                memset(&status, 0, sizeof(status));
+                /* Attempt to use SCTP_STATUS message to retrieve the primary address */
+                ret = getsockopt(sock, IPPROTO_SCTP, SCTP_STATUS, &status, &sz);
+                if (sz != sizeof(status))
+                        ret = -1;
+                sz = sizeof(sSS);
+                if (ret < 0)
+                {
+                        /* Fallback to getsockname -- not recommended by draft-ietf-tsvwg-sctpsocket-19#section-7.4 */
+                        CHECK_SYS(getsockname(sock, (sSA *)&status.sstat_primary.spinfo_address, &sz));
+                }
+                        
+                CHECK_FCT( fd_ep_add_merge( list, (sSA *)&status.sstat_primary.spinfo_address, sz, EP_FL_PRIMARY ) );
+        }
+        
+        return 0;
+}
+
+/* Get the list of remote endpoints of the socket */
+int fd_sctp_get_remote_ep(int sock, struct fd_list * list)
+{
+        union {
+                sSA     *sa;
+                uint8_t *buf;
+        } ptr;
+        
+        sSA * data;
+        int count;
+        
+        TRACE_ENTRY("%d %p", sock, list);
+        CHECK_PARAMS(list);
+        
+        /* Read the list on the socket */
+        CHECK_SYS( count = sctp_getpaddrs(sock, 0, &data)  );
+        ptr.sa = data;
+        
+        while (count) {
+                socklen_t sl;
+                switch (ptr.sa->sa_family) {
+                        case AF_INET:   sl = sizeof(sSA4); break;
+                        case AF_INET6:  sl = sizeof(sSA6); break;
+                        default:
+                                TRACE_DEBUG(INFO, "Unkown address family returned in sctp_getpaddrs: %d", ptr.sa->sa_family);
+                }
+                                
+                CHECK_FCT( fd_ep_add_merge( list, ptr.sa, sl, EP_FL_LL ) );
+                ptr.buf += sl;
+                count --;
+        }
+        
+        /* Free the list */
+        sctp_freepaddrs(data);
+        
+        /* Now get the primary address, the add function will take care of merging with existing entry */
+        {
+                sSS ss;
+                socklen_t sl = sizeof(sSS);
+        
+                CHECK_SYS(getpeername(sock, (sSA *)&ss, &sl));
+                CHECK_FCT( fd_ep_add_merge( list, (sSA *)&ss, sl, EP_FL_PRIMARY ) );
+        }
+        
+        /* Done! */
+        return 0;
+}
+
+/* Send a buffer over a specified stream */
+int fd_sctp_sendstr(int sock, uint16_t strid, uint8_t * buf, size_t len)
+{
+        struct msghdr mhdr;
+        struct iovec  iov;
+        struct {
+                struct cmsghdr          hdr;
+                struct sctp_sndrcvinfo  sndrcv;
+        } anci;
+        ssize_t ret;
+        
+        TRACE_ENTRY("%d %hu %p %zd", sock, strid, buf, len);
+        
+        memset(&mhdr, 0, sizeof(mhdr));
+        memset(&iov,  0, sizeof(iov));
+        memset(&anci, 0, sizeof(anci));
+        
+        /* IO Vector: message data */
+        iov.iov_base = buf;
+        iov.iov_len  = len;
+        
+        /* Anciliary data: specify SCTP stream */
+        anci.hdr.cmsg_len   = sizeof(anci);
+        anci.hdr.cmsg_level = IPPROTO_SCTP;
+        anci.hdr.cmsg_type  = SCTP_SNDRCV;
+        anci.sndrcv.sinfo_stream = strid;
+        /* note : we could store other data also, for example in .sinfo_ppid for remote peer or in .sinfo_context for errors. */
+        
+        /* We don't use mhdr.msg_name here; it could be used to specify an address different from the primary */
+        
+        mhdr.msg_iov    = &iov;
+        mhdr.msg_iovlen = 1;
+        
+        mhdr.msg_control    = &anci;
+        mhdr.msg_controllen = sizeof(anci);
+        
+        TRACE_DEBUG(FULL, "Sending %db data on stream %hu of socket %d", len, strid, sock);
+        
+        CHECK_SYS( ret = sendmsg(sock, &mhdr, 0) );
+        ASSERT( ret == len ); /* There should not be partial delivery with sendmsg... */
+        
+        return 0;
+}
+
+/* Receive the next data from the socket, or next notification */
+int fd_sctp_recvmeta(int sock, uint16_t * strid, uint8_t ** buf, size_t * len, int *event)
+{
+        ssize_t                  ret = 0;
+        struct msghdr            mhdr;
+        char                     ancidata[ CMSG_BUF_LEN ];
+        struct iovec             iov;
+        uint8_t                 *data = NULL;
+        size_t                   bufsz = 0, datasize = 0;
+        size_t                   mempagesz = sysconf(_SC_PAGESIZE); /* We alloc buffer by memory pages for efficiency */
+        
+        TRACE_ENTRY("%d %p %p %p %p", sock, strid, buf, len, event);
+        CHECK_PARAMS( (sock > 0) && buf && len && event );
+        
+        /* Cleanup out parameters */
+        *buf = NULL;
+        *len = 0;
+        *event = 0;
+        
+        /* Prepare header for receiving message */
+        memset(&mhdr, 0, sizeof(mhdr));
+        mhdr.msg_iov    = &iov;
+        mhdr.msg_iovlen = 1;
+        mhdr.msg_control    = &ancidata;
+        mhdr.msg_controllen = sizeof(ancidata);
+        
+        /* We will loop while all data is not received. */
+incomplete:
+        if (datasize == bufsz) {
+                /* The buffer is full, enlarge it */
+                bufsz += mempagesz;
+                CHECK_MALLOC( data = realloc(data, bufsz) );
+        }
+        /* the new data will be received following the preceding */
+        memset(&iov,  0, sizeof(iov));
+        iov.iov_base = data + datasize ;
+        iov.iov_len  = bufsz - datasize;
+
+        /* Receive data from the socket */
+        pthread_cleanup_push(free, data);
+        ret = recvmsg(sock, &mhdr, 0);
+        pthread_cleanup_pop(0);
+        
+        /* Handle errors */
+        if (ret <= 0) { /* Socket is closed, or an error occurred */
+                CHECK_SYS_DO(ret, /* to log in case of error */);
+                free(data);
+                *event = FDEVP_CNX_ERROR;
+                return 0;
+        }
+        
+        /* Update the size of data we received */
+        datasize += ret;
+
+        /* SCTP provides an indication when we received a full record; loop if it is not the case */
+        if ( ! (mhdr.msg_flags & MSG_EOR) ) {
+                goto incomplete;
+        }
+        
+        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) {
+                union sctp_notification * notif = (union sctp_notification *) data;
+                
+                switch (notif->sn_header.sn_type) {
+                        
+                        case SCTP_ASSOC_CHANGE:
+                                TRACE_DEBUG(FULL, "Received SCTP_ASSOC_CHANGE notification");
+                                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;
+                                break;
+        
+                        case SCTP_PEER_ADDR_CHANGE:
+                                TRACE_DEBUG(FULL, "Received SCTP_PEER_ADDR_CHANGE notification");
+                                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;
+                                break;
+        
+                        case SCTP_SEND_FAILED:
+                                TRACE_DEBUG(FULL, "Received SCTP_SEND_FAILED notification");
+                                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;
+                                break;
+                        
+                        case SCTP_REMOTE_ERROR:
+                                TRACE_DEBUG(FULL, "Received SCTP_REMOTE_ERROR notification");
+                                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;
+                                break;
+        
+                        case SCTP_SHUTDOWN_EVENT:
+                                TRACE_DEBUG(FULL, "Received SCTP_SHUTDOWN_EVENT notification");
+                                
+                                *event = FDEVP_CNX_ERROR;
+                                break;
+                        
+                        default:        
+                                TRACE_DEBUG(FULL, "Received unknown notification %d, assume error", notif->sn_header.sn_type);
+                                *event = FDEVP_CNX_ERROR;
+                }
+                
+                free(data);
+                return 0;
+        }
+        
+        /* From this point, we have received a message */
+        *event = FDEVP_CNX_MSG_RECV;
+        *buf = data;
+        *len = datasize;
+        
+        if (strid) {
+                struct cmsghdr          *hdr;
+                struct sctp_sndrcvinfo  *sndrcv;
+                
+                /* Handle the anciliary data */
+                for (hdr = CMSG_FIRSTHDR(&mhdr); hdr; hdr = CMSG_NXTHDR(&mhdr, hdr)) {
+
+                        /* We deal only with anciliary data at SCTP level */
+                        if (hdr->cmsg_level != IPPROTO_SCTP) {
+                                TRACE_DEBUG(FULL, "Received some anciliary data at level %d, skipped", hdr->cmsg_level);
+                                continue;
+                        }
+                        
+                        /* Also only interested in SCTP_SNDRCV message for the moment */
+                        if (hdr->cmsg_type != SCTP_SNDRCV) {
+                                TRACE_DEBUG(FULL, "Anciliary block IPPROTO_SCTP / %d, skipped", hdr->cmsg_type);
+                                continue;
+                        }
+                        
+                        sndrcv = (struct sctp_sndrcvinfo *) CMSG_DATA(hdr);
+                        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;
+                }
+        }
+        
+        return 0;
+}

freeDiameter/server.c

@@ -36 +36 @@
 #include "fD.h"
 
-/* This file contains the server (listening) part of the daemon */
-
-struct fd_list          FD_SERVERS = FD_LIST_INITIALIZER(FD_SERVERS);   /* The list of all server sockets */
-/* We don't need to protect this list, it is only accessed from the main thread. */
-
-/* Server (listening socket) information */
+/* Server (listening) part of the daemon */
+
+struct fd_list          FD_SERVERS = FD_LIST_INITIALIZER(FD_SERVERS);   /* The list of all server objects */
+/* We don't need to protect this list, it is only accessed from the main daemon thread. */
+
+/* Servers information */
 struct server {
         struct fd_list  chain;          /* link in the FD_SERVERS list */
 
-        int             socket;         /* server socket, or <= 0 */
-        
+        struct cnxctx * conn;           /* server connection context (listening socket) */
         int             proto;          /* IPPROTO_TCP or IPPROTO_SCTP */
         int             secur;          /* TLS is started immediatly after connection ? */
         
-        pthread_t       serv_thr;       /* The thread listening for new connections */
-        int             serv_status;    /* 0 : not created; 1 : running; 2 : terminated */
-        
-        pthread_mutex_t clients_mtx;    /* Mutex to protect the list of clients connected to the thread */
-        struct fd_list  clients;        /* The list of clients connecting to this server, which information is not yet known */
-        
-        char *          serv_name;      /* A string to identify this server */
+        pthread_t       thr;            /* The thread listening for new connections */
+        int             status;         /* 0 : not created; 1 : running; 2 : terminated */
+        
+        struct fd_list  clients;        /* List of clients connected to this server, not yet identified */
+        pthread_mutex_t clients_mtx;    /* Mutex to protect the list of clients */
 };
 
-/* Client (connected remote endpoint, not received CER yet) information */
+/* Client information (connecting peer for which we don't have the CER yet) */
 struct client {
         struct fd_list   chain; /* link in the server's list of clients */
-        
-        struct cnxctx   *conn;  /* Parameters of the connection; sends its events to the ev fifo bellow */
-        
-        struct timespec  ts;    /* Delay for receiving CER: INCNX_TIMEOUT */
-        struct fifo     *ev;    /* Events of the connection -- allowed: TIMEOUT, ERROR (cnx, tls), MSG_RCV (CER, other=>error) */
-        
-        pthread_t        cli_thr; /* connection state machine (simplified PSM) */
+        struct cnxctx   *conn;  /* Parameters of the connection */
+        struct timespec  ts;    /* Deadline for receiving CER (after INCNX_TIMEOUT) */
+        pthread_t        thr;   /* connection state machine */
 };
 
-/* Parameter for the thread handling the new connected client, to avoid bloking the server thread */
-struct cli_fast {
-        struct server * serv;
-        int             sock;
-        sSS             ss;
-        socklen_t       sslen;
-};
-
-
-/* This thread is called when a new client had just connected */
-static void * handle_client_fast(void * arg)
-{
-        struct cli_fast * cf = arg;
-        struct client * c = NULL;
+
+/* Dump all servers information */
+void fd_servers_dump()
+{
+        struct fd_list * li, *cli;
+        
+        fd_log_debug("Dumping servers list :\n");
+        for (li = FD_SERVERS.next; li != &FD_SERVERS; li = li->next) {
+                struct server * s = (struct server *)li;
+                fd_log_debug("  Serv %p '%s': %s, %s, %s\n", 
+                                s, fd_cnx_getid(s->conn), 
+                                IPPROTO_NAME( s->proto ),
+                                s->secur ? "Secur" : "NotSecur",
+                                (s->status == 0) ? "Thread not created" :
+                                ((s->status == 1) ? "Thread running" :
+                                ((s->status == 2) ? "Thread terminated" :
+                                                          "Thread status unknown")));
+                /* Dump the client list of this server */
+                (void) pthread_mutex_lock(&s->clients_mtx);
+                for (cli = s->clients.next; cli != &s->clients; cli = cli->next) {
+                        struct client * c = (struct client *)cli;
+                        char bufts[128];
+                        fd_log_debug("     Connected: '%s' (timeout: %s)\n",
+                                        fd_cnx_getid(c->conn),
+                                        fd_log_time(&c->ts, bufts, sizeof(bufts)));
+                }
+                (void) pthread_mutex_unlock(&s->clients_mtx);
+        }
+}
+
+
+/* The state machine to handle incoming connection before the remote peer is identified */
+static void * client_sm(void * arg)
+{
+        struct client * c = arg;
+        struct server * s = NULL;
+        uint8_t       * buf = NULL;
+        size_t          bufsz;
+        struct msg    * msg = NULL;
+        struct msg_hdr *hdr = NULL;
+        
+        TRACE_ENTRY("%p", c);
+        
+        CHECK_PARAMS_DO(c && c->conn && c->chain.head, goto fatal_error );
+        
+        s = c->chain.head->o;
         
         /* Name the current thread */
-        ASSERT(arg);
-        {
-                char addr[128];
-                int offset = snprintf(addr, sizeof(addr), "Srv %d/Cli %d : ", cf->serv->socket, cf->sock);
-                int rc = getnameinfo((sSA *)&cf->ss, sizeof(sSS), addr + offset, sizeof(addr) - offset, NULL, 0, 0);
-                if (rc)
-                        memcpy(addr + offset, gai_strerror(rc), sizeof(addr) - offset);
-                
-                if (TRACE_BOOL(INFO)) {
-                        fd_log_debug( "New connection %s, sock %d, from '%s'\n", cf->serv->serv_name, cf->sock, addr + offset);
+        fd_log_threadname ( fd_cnx_getid(c->conn) );
+        
+        /* 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, NULL);
+                if (ret != 0) {
+                        if (TRACE_BOOL(INFO)) {
+                                fd_log_debug("TLS handshake failed for client '%s', connection aborted.\n", fd_cnx_getid(c->conn));
+                        }
+                        goto cleanup;
                 }
-        
-                fd_log_threadname ( addr );
-        }
-        
-        /* Create a client structure */
-        CHECK_MALLOC_DO( c = malloc(sizeof(struct client)), goto early_error );
-        memset(c, 0, sizeof(struct client));
-        fd_list_init(&c->chain, c);
-        c->cli_thr = pthread_self();
-        
-        /* Create the connection context */
-        CHECK_MALLOC_DO( c->conn = fd_cnx_init(cf->sock, cf->serv->proto), goto early_error );
-        
-        /* In case we are a secure server, handshake now */
-        if (cf->serv->secur) {
-                
-                TODO("Continue");
-        }
-        
-        /* Save the client in the list */
-        CHECK_POSIX_DO( pthread_mutex_lock( &cf->serv->clients_mtx ), goto early_error );
-        fd_list_insert_before(&cf->serv->clients, &c->chain);
-        CHECK_POSIX_DO( pthread_mutex_unlock( &cf->serv->clients_mtx ), goto error );
-        
-        
-        
-        
-early_error:
-        TRACE_DEBUG(INFO, "Thread is detaching to die");
+        } else {
+                CHECK_FCT_DO( fd_cnx_start_clear(c->conn, 0), goto cleanup );
+        }
+        
+        /* Set the timeout to receive the first message */
+        CHECK_SYS_DO( clock_gettime(CLOCK_REALTIME, &c->ts), goto fatal_error );
+        c->ts.tv_sec += INCNX_TIMEOUT;
+        
+        /* Receive the first Diameter message on the connection -- cleanup in case of timeout */
+        CHECK_FCT_DO( fd_cnx_receive(c->conn, &c->ts, &buf, &bufsz), goto cleanup );
+        
+        TRACE_DEBUG(FULL, "Received %zdb from new client '%s'", bufsz, fd_cnx_getid(c->conn));
+        
+        /* Try parsing this message */
+        CHECK_FCT_DO( fd_msg_parse_buffer( &buf, bufsz, &msg ), /* Parsing failed */ goto cleanup );
+        
+        /* We expect a CER, it must parse with our dictionary and rules */
+        CHECK_FCT_DO( fd_msg_parse_rules( msg, fd_g_config->cnf_dict, NULL ), /* Parsing failed -- trace details ? */ goto cleanup );
+        
+        if (TRACE_BOOL(FULL)) {
+                fd_log_debug("Received Diameter message from new client '%s':\n", fd_cnx_getid(c->conn));
+                fd_msg_dump_walk(FULL, msg);
+        }
+        
+        /* Now check we received a CER */
+        CHECK_FCT_DO( fd_msg_hdr ( msg, &hdr ), goto fatal_error );
+        CHECK_PARAMS_DO( (hdr->msg_appl == 0) && (hdr->msg_flags & CMD_FLAG_REQUEST) && (hdr->msg_code == CC_CAPABILITIES_EXCHANGE),
+                { fd_log_debug("Connection '%s', expecting CER, received something else, closing...\n", fd_cnx_getid(c->conn)); goto cleanup; } );
+        
+        /* Finally, pass the information to the peers module which will handle it next */
+        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 */
+cleanup:
+        /* Unlink the client structure */
+        CHECK_POSIX_DO( pthread_mutex_lock(&s->clients_mtx), goto fatal_error );
+        fd_list_unlink( &c->chain );
+        CHECK_POSIX_DO( pthread_mutex_unlock(&s->clients_mtx), goto fatal_error );
+        
+        /* Destroy the connection object if present */
+        if (c->conn)
+                fd_cnx_destroy(c->conn);
+        
+        /* Cleanup the received buffer if any */
+        free(buf);
+        
+        /* Cleanup the parsed message if any */
+        if (msg) {
+                CHECK_FCT_DO( fd_msg_free(msg), /* continue */);
+        }
+        
+        /* Detach the thread, cleanup the client structure */
         pthread_detach(pthread_self());
-        shutdown(cf->sock, SHUT_RDWR);
-        free(cf);
         free(c);
+        return NULL;
+        
+fatal_error:    /* This has effect to terminate the daemon */
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, 0, NULL), );
+        return NULL;
+}
+
+/* The thread managing a server */
+static void * serv_th(void * arg)
+{
+        struct server *s = (struct server *)arg;
+        
+        CHECK_PARAMS_DO(s, goto error);
+        fd_log_threadname ( fd_cnx_getid(s->conn) );
+        s->status = 1;
+        
+        /* Accept incoming connections */
+        CHECK_FCT_DO( fd_cnx_serv_listen(s->conn), goto error );
+        
+        do {
+                struct client * c = NULL;
+                struct cnxctx * conn = NULL;
+                
+                /* Wait for a new client */
+                CHECK_MALLOC_DO( conn = fd_cnx_serv_accept(s->conn), goto error );
+                
+                TRACE_DEBUG(FULL, "New connection accepted");
+                
+                /* Create a client structure */
+                CHECK_MALLOC_DO( c = malloc(sizeof(struct client)), goto error );
+                memset(c, 0, sizeof(struct client));
+                fd_list_init(&c->chain, c);
+                c->conn = conn;
+                
+                /* Save the client in the list */
+                CHECK_POSIX_DO( pthread_mutex_lock( &s->clients_mtx ), goto error );
+                fd_list_insert_before(&s->clients, &c->chain);
+                CHECK_POSIX_DO( pthread_mutex_unlock( &s->clients_mtx ), goto error );
+
+                /* Start the client thread */
+                CHECK_POSIX_DO( pthread_create( &c->thr, NULL, client_sm, c ), goto error );
+                
+        } while (1);
+        
 error:  
-        TRACE_DEBUG(INFO, "Thread is terminating");
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, NULL), );
-        return NULL;
-}
-
-/* The thread for the server */
-static void * serv_th(void * arg)
-{
-        struct server *sv = (struct server *)arg;
-        struct cli_fast cf;
-        
-        CHECK_PARAMS_DO(sv, goto error);
-        fd_log_threadname ( sv->serv_name );
-        sv->serv_status = 1;
-        
-        memset(&cf, 0, sizeof(struct cli_fast));
-        cf.serv = sv;
-        
-        
-        /* Accept incoming connections */
-        CHECK_SYS_DO(  listen(sv->socket, 5), goto error );
-        
-        do {
-                struct cli_fast * ncf;
-                pthread_t         thr;
-                
-                /* Re-init socket size */
-                cf.sslen = sizeof(sSS);
-                
-                /* Wait for a new client */
-                CHECK_SYS_DO( cf.sock = accept(sv->socket, (sSA *)&cf.ss, &cf.sslen), goto error );
-                
-                TRACE_DEBUG(FULL, "New connection accepted");
-                
-                /* Create the copy for the client thread */
-                CHECK_MALLOC_DO( ncf = malloc(sizeof(struct cli_fast)), goto error );
-                memcpy(ncf, &cf, sizeof(struct cli_fast));
-                
-                /* Create the thread to handle the new incoming connection */
-                CHECK_POSIX_DO( pthread_create( &thr /* we don't use it, but NULL is not standard */, NULL, handle_client_fast, ncf), goto error );
-                
-        } while (1);
-        
-error:  
-        if (sv)
-                sv->serv_status = 2;
+        if (s)
+                s->status = 2;
         /* Send error signal to the daemon */
         TRACE_DEBUG(INFO, "An error occurred in server module! Thread is terminating...");
-        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, NULL), );
+        CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_TERMINATE, 0, NULL), );
 
         return NULL;
@@ -187 +237 @@
 
 /* Create a new server structure */
-static struct server * new_serv( int proto, int secur, int socket )
-{
-        char buf[32];
-        char * sn = NULL;
+static struct server * new_serv( int proto, int secur )
+{
         struct server * new;
-        
-        /* Create the server debug name */
-        buf[sizeof(buf) - 1] = '\0';
-        snprintf(buf, sizeof(buf) - 1, "Serv %d (%s%s)", socket, IPPROTO_NAME( proto ), secur ? "s" : "");
-        CHECK_MALLOC_DO( sn = strdup(buf), return NULL );
         
         /* New server structure */
@@ -203 +246 @@
         memset(new, 0, sizeof(struct server));
         fd_list_init(&new->chain, new);
-        new->socket = socket;
         new->proto = proto;
         new->secur = secur;
@@ -209 +251 @@
         fd_list_init(&new->clients, new);
         
-        new->serv_name = sn;
-        
         return new;
-}
-
-/* Dump all servers information */
-void fd_servers_dump()
-{
-        struct fd_list * li;
-        
-        fd_log_debug("Dumping servers list :\n");
-        for (li = FD_SERVERS.next; li != &FD_SERVERS; li = li->next) {
-                struct server * sv = (struct server *)li;
-                fd_log_debug("  Serv '%s': %s(%d), %s, %s, %s\n", 
-                                sv->serv_name, 
-                                (sv->socket > 0) ? "Open" : "Closed", sv->socket,
-                                IPPROTO_NAME( sv->proto ),
-                                sv->secur ? "Secur" : "NotSecur",
-                                (sv->serv_status == 0) ? "Thread not created" :
-                                ((sv->serv_status == 1) ? "Thread running" :
-                                ((sv->serv_status == 2) ? "Thread terminated" :
-                                                          "Thread status unknown")));
-                /* Dump the endpoints ? */
-                /* Dump the client list ? */
-        }
 }
 
@@ -239 +257 @@
 int fd_servers_start()
 {
-        int  socket;
-        struct server * sv;
+        struct server * s;
+        
+        int empty_conf_ep = FD_IS_LIST_EMPTY(&fd_g_config->cnf_endpoints);
         
         /* SCTP */
@@ -249 +268 @@
                 
                 /* Create the server on default port */
-                CHECK_FCT( fd_sctp_create_bind_server( &socket, fd_g_config->cnf_port ) );
-                CHECK_MALLOC( sv = new_serv(IPPROTO_SCTP, 0, socket) );
-                
-                
-                
+                CHECK_MALLOC( s = new_serv(IPPROTO_SCTP, 0) );
+                CHECK_MALLOC( s->conn = fd_cnx_serv_sctp(fd_g_config->cnf_port, FD_IS_LIST_EMPTY(&fd_g_config->cnf_endpoints) ? NULL : &fd_g_config->cnf_endpoints) );
+                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+                
+                /* Retrieve the list of endpoints if it was empty */
+                if (empty_conf_ep) {
+                        (void) fd_cnx_getendpoints(s->conn, &fd_g_config->cnf_endpoints, NULL);
+                }
+                
+                /* Create the server on secure port */
+                CHECK_MALLOC( s = new_serv(IPPROTO_SCTP, 1) );
+                CHECK_MALLOC( s->conn = fd_cnx_serv_sctp(fd_g_config->cnf_port_tls, FD_IS_LIST_EMPTY(&fd_g_config->cnf_endpoints) ? NULL : &fd_g_config->cnf_endpoints) );
+                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
                 
 #endif /* DISABLE_SCTP */
@@ -261 +290 @@
         if (!fd_g_config->cnf_flags.no_tcp) {
                 
-                
+                if (empty_conf_ep) {
+                        /* Bind TCP servers on [0.0.0.0] */
+                        if (!fd_g_config->cnf_flags.no_ip4) {
+                                
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 0) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port, AF_INET, NULL) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 1) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port_tls, AF_INET, NULL) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+                        }
+                        /* Bind TCP servers on [::] */
+                        if (!fd_g_config->cnf_flags.no_ip6) {
+                                
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 0) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port, AF_INET6, NULL) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 1) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port_tls, AF_INET6, NULL) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+                        }
+                } else {
+                        /* Create all endpoints -- check flags */
+                        struct fd_list * li;
+                        for (li = fd_g_config->cnf_endpoints.next; li != &fd_g_config->cnf_endpoints; li = li->next) {
+                                struct fd_endpoint * ep = (struct fd_endpoint *)li;
+                                sSA * sa = (sSA *) &ep->ss;
+                                if (! (ep->flags & EP_FL_CONF))
+                                        continue;
+                                if (fd_g_config->cnf_flags.no_ip4 && (sa->sa_family == AF_INET))
+                                        continue;
+                                if (fd_g_config->cnf_flags.no_ip6 && (sa->sa_family == AF_INET6))
+                                        continue;
+                                
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 0) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port, sa->sa_family, ep) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+
+                                CHECK_MALLOC( s = new_serv(IPPROTO_TCP, 1) );
+                                CHECK_MALLOC( s->conn = fd_cnx_serv_tcp(fd_g_config->cnf_port_tls, sa->sa_family, ep) );
+                                fd_list_insert_before( &FD_SERVERS, &s->chain );
+                                CHECK_POSIX( pthread_create( &s->thr, NULL, serv_th, s ) );
+                        }
+                }
         }
         
@@ -268 +347 @@
 
 /* Terminate all the servers */
-void fd_servers_stop()
-{
-        
-}
+int fd_servers_stop()
+{
+        TODO("Not implemented");
+        
+        /* Loop on all servers */
+                /* cancel thread */
+                /* destroy server connection context */
+                /* cancel and destroy all clients */
+}

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/CMakeLists.txt

@@ -10 +10 @@
 
 # Disable SCTP support completly ?
-OPTION(DISABLE_SCTP "Disable SCTP support?")
+OPTION(DISABLE_SCTP "Disable SCTP support?" OFF)
+IF (NOT DISABLE_SCTP)
+        OPTION(DEBUG_SCTP "Verbose SCTP (for debug)?" OFF)
+        OPTION(SCTP_USE_MAPPED_ADDRESSES "Use v6-mapped v4 addresses in SCTP (workaround some SCTP limitations)?" OFF)
+ENDIF (NOT DISABLE_SCTP)
 
 # Find TODO items in the code easily ?

include/freeDiameter/freeDiameter-host.h.in

@@ -45 +45 @@
 
 #cmakedefine DISABLE_SCTP
+#cmakedefine DEBUG_SCTP
+#cmakedefine SCTP_USE_MAPPED_ADDRESSES
 #cmakedefine ERRORS_ON_TODO
 #cmakedefine DEBUG

include/freeDiameter/freeDiameter.h

@@ -118 +118 @@
 struct fd_endpoint {
         struct fd_list  chain;  /* link in cnf_endpoints list */
-        sSS             ss;     /* the socket information. List is always ordered by ss value (memcmp) */
-        struct {
-                unsigned conf : 1; /* This endpoint is statically configured in a configuration file */
-                unsigned disc : 1; /* This endpoint was resolved from the Diameter Identity or other DNS query */
-                unsigned adv  : 1; /* This endpoint was advertized in Diameter CER/CEA exchange */
-                unsigned ll   : 1; /* Lower layer mechanism provided this endpoint */
-                
-                /* To add: a validity timestamp for DNS records ? How do we retrieve this lifetime from DNS ? */
-
-        }               meta;   /* Additional information about the endpoint */
+        
+        union {
+                sSS             ss;     /* the socket information. List is always ordered by ss value (memcmp) -- see fd_ep_add_merge */
+                sSA4            sin;
+                sSA6            sin6;
+                sSA             sa;
+        };
+        
+#define EP_FL_CONF      (1 << 0)        /* This endpoint is statically configured in a configuration file */
+#define EP_FL_DISC      (1 << 1)        /* This endpoint was resolved from the Diameter Identity or other DNS query */
+#define EP_FL_ADV       (1 << 2)        /* This endpoint was advertized in Diameter CER/CEA exchange */
+#define EP_FL_LL        (1 << 3)        /* Lower layer mechanism provided this endpoint */
+#define EP_FL_PRIMARY   (1 << 4)        /* This endpoint is primary in a multihomed SCTP association */
+        uint32_t        flags;          /* Additional information about the endpoint */
+                
+        /* To add: a validity timestamp for DNS records ? How do we retrieve this lifetime from DNS ? */
 };
 
@@ -146 +152 @@
 struct fd_event {
         int      code; /* codespace depends on the queue */
+        size_t   size;
         void    *data;
 };
 
-static __inline__ int fd_event_send(struct fifo *queue, int code, void * data)
-{
-        struct fd_event * ev;
-        CHECK_MALLOC( ev = malloc(sizeof(struct fd_event)) );
-        ev->code = code;
-        ev->data = data;
-        CHECK_FCT( fd_fifo_post(queue, &ev) );
-        return 0;
-}
-static __inline__ int fd_event_get(struct fifo *queue, int *code, void ** data)
-{
-        struct fd_event * ev;
-        CHECK_FCT( fd_fifo_get(queue, &ev) );
-        if (code)
-                *code = ev->code;
-        if (data)
-                *data = ev->data;
-        free(ev);
-        return 0;
-}
-
-/* Events codespace for fd_g_config->cnf_main_ev */
+/* Daemon's codespace: 1000->1999 */
 enum {
-         FDEV_TERMINATE = 1000  /* request to terminate */
+         FDEV_TERMINATE = 1000  /* request to terminate */
         ,FDEV_DUMP_DICT         /* Dump the content of the dictionary */
         ,FDEV_DUMP_EXT          /* Dump state of extensions */
@@ -180 +166 @@
         ,FDEV_DUMP_PEERS        /* Dump the list of peers */
 };
+
+static __inline__ int fd_event_send(struct fifo *queue, int code, size_t datasz, void * data)
+{
+        struct fd_event * ev;
+        CHECK_MALLOC( ev = malloc(sizeof(struct fd_event)) );
+        ev->code = code;
+        ev->size = datasz;
+        ev->data = data;
+        CHECK_FCT( fd_fifo_post(queue, &ev) );
+        return 0;
+}
+static __inline__ int fd_event_get(struct fifo *queue, int *code, size_t *datasz, void ** data)
+{
+        struct fd_event * ev;
+        CHECK_FCT( fd_fifo_get(queue, &ev) );
+        if (code)
+                *code = ev->code;
+        if (datasz)
+                *datasz = ev->size;
+        if (data)
+                *data = ev->data;
+        free(ev);
+        return 0;
+}
+static __inline__ int fd_event_timedget(struct fifo *queue, struct timespec * timeout, int timeoutcode, int *code, size_t *datasz, void ** data)
+{
+        struct fd_event * ev;
+        int ret = 0;
+        ret = fd_fifo_timedget(queue, &ev, timeout);
+        if (ret == ETIMEDOUT) {
+                if (code)
+                        *code = timeoutcode;
+                if (datasz)
+                        *datasz = 0;
+                if (data)
+                        *data = NULL;
+        } else {
+                CHECK_FCT( ret );
+                if (code)
+                        *code = ev->code;
+                if (datasz)
+                        *datasz = ev->size;
+                if (data)
+                        *data = ev->data;
+                free(ev);
+        }
+        return 0;
+}
+static __inline__ void fd_event_destroy(struct fifo **queue, void (*free_cb)(void * data))
+{
+        struct fd_event * ev;
+        /* Purge all events, and free the associated data if any */
+        while (fd_fifo_tryget( *queue, &ev ) == 0) {
+                (*free_cb)(ev->data);
+                free(ev);
+        }
+        CHECK_FCT_DO( fd_fifo_del(queue), /* continue */ );
+        return ;
+}  
 const char * fd_ev_str(int event); /* defined in freeDiameter/main.c */
 
@@ -256 +301 @@
         /* Additional parameters */
         uint32_t        pi_lft;         /* lifetime of this peer when inactive (see pi_flags.exp definition) */
-        uint16_t        pi_streams;     /* number of streams for SCTP. 0 = default */
         uint16_t        pi_port;        /* port to connect to. 0: default. */
         int             pi_tctimer;     /* use this value for TcTimer instead of global, if != 0 */
@@ -271 +315 @@
         struct fd_list  pi_apps;        /* applications advertised by the remote peer, except relay (pi_flags.relay) */
         struct {
+                char                    *priority;      /* In case the default priority is not appropriate */
                 /* This is inspired from http://www.gnu.org/software/gnutls/manual/gnutls.html#ex_003ax509_002dinfo */
                 const gnutls_datum_t    *cert_list;     /* The (valid) credentials that the peer has presented */
@@ -460 +505 @@
 
 
+/***************************************/
+/*   Endpoints lists helpers           */
+/***************************************/
+
+int fd_ep_add_merge( struct fd_list * list, sSA * sa, socklen_t sl, uint32_t flags );
+int fd_ep_filter( struct fd_list * list, uint32_t flags );
+int fd_ep_clearflags( struct fd_list * list, uint32_t flags );
+
+
+
 #endif /* _FREEDIAMETER_H */

include/freeDiameter/libfreeDiameter.h

@@ -120 +120 @@
  *
  * PARAMETERS:
+ *  ts          : The timestamp to log, or NULL for "now"
  *  buf         : An array where the time must be stored
  *  len         : size of the buffer
  *
  * DESCRIPTION: 
- *  Writes the current timestamp (in human readable format) in a buffer. 
+ *  Writes the timestamp (in human readable format) in a buffer. 
  *
  * RETURN VALUE:
  *  pointer to buf.
  */
-char * fd_log_time ( char * buf, size_t len );
+char * fd_log_time ( struct timespec * ts, char * buf, size_t len );
 
 
@@ -173 +174 @@
                 fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
                           "\t%s|%*s" format "\n",                                                                               \
-                                        __thn, fd_log_time(__buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,      \
+                                        __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,        \
                                         (level < FULL)?"@":" ",level, "", ## args);                                             \
         }                                                                                                                       \
@@ -180 +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 */
@@ -328 +329 @@
                         flag);                                  \
           if (__rc)                                             \
-                fd_log_debug((char *)gai_strerror(__rc));       \
+                fd_log_debug("%s", (char *)gai_strerror(__rc)); \
           else                                                  \
-                fd_log_debug(&__addrbuf[0]);                    \
+                fd_log_debug("%s", &__addrbuf[0]);              \
         } else {                                                \
                 fd_log_debug("(NULL / ANY)");                   \
         }                                                       \
 }
-/* if needed, add sSA_DUMP_SERVICE */
+/* Same but with the port (service) also */
+#define sSA_DUMP_NODE_SERV( sa, flag ) {                                \
+        sSA * __sa = (sSA *)(sa);                                       \
+        char __addrbuf[INET6_ADDRSTRLEN];                               \
+        char __servbuf[32];                                             \
+        if (__sa) {                                                     \
+          int __rc = getnameinfo(__sa,                                  \
+                        sizeof(sSS),                                    \
+                        __addrbuf,                                      \
+                        sizeof(__addrbuf),                              \
+                        __servbuf,                                      \
+                        sizeof(__servbuf),                              \
+                        flag);                                          \
+          if (__rc)                                                     \
+                fd_log_debug("%s", (char *)gai_strerror(__rc));         \
+          else                                                          \
+                fd_log_debug("[%s]:%s", &__addrbuf[0],&__servbuf[0]);   \
+        } else {                                                        \
+                fd_log_debug("(NULL / ANY)");                           \
+        }                                                               \
+}
+/* Inside a debug trace */
+#define TRACE_DEBUG_sSA(level, prefix, sa, flags, suffix ) {                                                                            \
+        if ( TRACE_BOOL(level) ) {                                                                                              \
+                char __buf[25];                                                                                                 \
+                char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                       \
+                fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
+                          "\t%s|%*s" prefix ,                                                                                   \
+                                        __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,\
+                                        (level < FULL)?"@":" ",level, "");                                                      \
+                sSA_DUMP_NODE_SERV( sa, flags );                                                                                \
+                fd_log_debug(suffix "\n");                                                                                      \
+        }                                                                                                                       \
+}
+
 
 /* A l4 protocol name (TCP / SCTP) */
@@ -390 +425 @@
         (    ((ts1)->tv_sec  < (ts2)->tv_sec )  \
           || (((ts1)->tv_sec  == (ts2)->tv_sec ) && ((ts1)->tv_nsec < (ts2)->tv_nsec) ))
+
+
+/* Trace a binary buffer content */
+#define TRACE_DEBUG_BUFFER(level, prefix, buf, bufsz, suffix ) {                                                                \
+        if ( TRACE_BOOL(level) ) {                                                                                              \
+                int __i;                                                                                                        \
+                size_t __sz = (size_t)(bufsz);                                                                                  \
+                uint8_t * __buf = (uint8_t *)(buf);                                                                             \
+                char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                       \
+                fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
+                          "\t%s|%*s" prefix ,                                                                                   \
+                                        __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,\
+                                        (level < FULL)?"@":" ",level, "");                                                      \
+                for (__i = 0; __i < __sz; __i++) {                                                                              \
+                        fd_log_debug("%02.2hhx", __buf[__i]);                                                                   \
+                }                                                                                                               \
+                fd_log_debug(suffix "\n");                                                                                      \
+        }                                                                                                                       \
+}
+
 
 
@@ -415 +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);
         }
         
@@ -439 +494 @@
         free(buffer);
 }
+static __inline__ void fd_cleanup_socket(void * sockptr)
+{
+        if (sockptr) {
+                shutdown(*(int *)sockptr, SHUT_RDWR);
+                *(int *)sockptr = 0;
+        }
+}
+
 
 /*============================================================*/
@@ -465 +528 @@
 void fd_list_insert_after  ( struct fd_list * ref, struct fd_list * item );
 void fd_list_insert_before ( struct fd_list * ref, struct fd_list * item );
+
+/* Move a list at the end of another */
+void fd_list_move_end(struct fd_list * ref, struct fd_list * senti);
 
 /* Insert an item in an ordered list -- ordering function provided. If duplicate object found, EEXIST and it is returned in ref_duplicate */
@@ -2342 +2408 @@
 
 /*
+ * FUNCTION:    fd_fifo_move
+ *
+ * PARAMETERS:
+ *  old         : Location of a FIFO that is to be emptied and deleted.
+ *  new         : A FIFO that will receive the old data.
+ *  loc_update  : if non NULL, a place to store the pointer to new FIFO atomically with the move.
+ *
+ * DESCRIPTION: 
+ *  Delete a queue and move its content to another one atomically.
+ *
+ * RETURN VALUE:
+ *  0           : The queue has been destroyed successfully.
+ *  EINVAL      : A parameter is invalid.
+ */
+int fd_fifo_move ( struct fifo ** old, struct fifo * new, struct fifo ** loc_update );
+
+/*
  * FUNCTION:    fd_fifo_length
  *

libfreeDiameter/fifo.c

@@ -136 +136 @@
 }
 
-/* Delete a queue. It must be unused. */ 
+/* Delete a queue. It must be empty. */ 
 int fd_fifo_del ( struct fifo  ** queue )
 {
         struct fifo * q;
+        int loops = 0;
         
         TRACE_ENTRY( "%p", queue );
@@ -149 +150 @@
         CHECK_POSIX(  pthread_mutex_lock( &q->mtx )  );
         
-        if ((q->count != 0) || (q->thrs != 0) || (q->data != NULL)) {
-                TRACE_DEBUG(INFO, "The queue cannot be destroyed (%d, %d, %p)", q->count, q->thrs, q->data);
+        if ((q->count != 0) || (q->data != NULL)) {
+                TRACE_DEBUG(INFO, "The queue cannot be destroyed (%d, %p)", q->count, q->data);
                 CHECK_POSIX_DO(  pthread_mutex_unlock( &q->mtx ), /* no fallback */  );
                 return EINVAL;
         }
         
+        /* Ok, now invalidate the queue */
+        q->eyec = 0xdead;
+        
+        while (q->thrs) {
+                CHECK_POSIX(  pthread_cond_signal(&q->cond)  );
+                CHECK_POSIX(  pthread_mutex_unlock( &q->mtx ));
+                pthread_yield();
+                CHECK_POSIX(  pthread_mutex_lock( &q->mtx )  );
+                ASSERT( ++loops < 10 ); /* detect infinite loops */
+        }
+        
         /* sanity check */
         ASSERT(FD_IS_LIST_EMPTY(&q->list));
         
-        /* Ok, now invalidate the queue */
-        q->eyec = 0xdead;
-        
         /* And destroy it */
         CHECK_POSIX(  pthread_mutex_unlock( &q->mtx )  );
@@ -170 +179 @@
         free(q);
         *queue = NULL;
+        
+        return 0;
+}
+
+/* Move the content of old into new, and update loc_update atomically */
+int fd_fifo_move ( struct fifo ** old, struct fifo * new, struct fifo ** loc_update )
+{
+        struct fifo * q;
+        int loops = 0;
+        
+        TRACE_ENTRY("%p %p %p", old, new, loc_update);
+        CHECK_PARAMS( old && CHECK_FIFO( *old ) && CHECK_FIFO( new ));
+        
+        q = *old;
+        CHECK_PARAMS( ! q->data );
+        if (new->high) {
+                TODO("Implement support for thresholds in fd_fifo_move...");
+        }
+        
+        /* Update loc_update */
+        *old = NULL;
+        if (loc_update)
+                *loc_update = new;
+        
+        /* Lock the queues */
+        CHECK_POSIX(  pthread_mutex_lock( &q->mtx )  );
+        CHECK_POSIX(  pthread_mutex_lock( &new->mtx )  );
+        
+        /* Any waiting thread on the old queue returns an error */
+        q->eyec = 0xdead;
+        while (q->thrs) {
+                CHECK_POSIX(  pthread_cond_signal(&q->cond)  );
+                CHECK_POSIX(  pthread_mutex_unlock( &q->mtx ));
+                pthread_yield();
+                CHECK_POSIX(  pthread_mutex_lock( &q->mtx )  );
+                ASSERT( ++loops < 10 ); /* detect infinite loops */
+        }
+        
+        /* Move all data from old to new */
+        fd_list_move_end( &new->list, &q->list );
+        if (q->count && (!new->count)) {
+                CHECK_POSIX(  pthread_cond_signal(&new->cond)  );
+        }
+        new->count += q->count;
+        
+        /* Destroy old */
+        CHECK_POSIX(  pthread_mutex_unlock( &q->mtx )  );
+        CHECK_POSIX(  pthread_cond_destroy( &q->cond )  );
+        CHECK_POSIX(  pthread_mutex_destroy( &q->mtx )  );
+        free(q);
+        
+        /* Unlock new, we're done */
+        CHECK_POSIX(  pthread_mutex_unlock( &new->mtx )  );
         
         return 0;
@@ -379 +441 @@
 awaken:
         /* Check queue status */
+        if (!CHECK_FIFO( queue )) {
+                /* The queue is being destroyed */
+                CHECK_POSIX(  pthread_mutex_unlock( &queue->mtx )  );
+                TRACE_DEBUG(FULL, "The queue is being destroyed -> EPIPE");
+                return EPIPE;
+        }
+                
         if (queue->count > 0) {
                 /* There are items in the queue, so pick the first one */

libfreeDiameter/lists.c

@@ -70 +70 @@
         ASSERT(ref->head != item);
         list_insert_after(ref, item);
+}
+
+/* Move all elements of list senti at the end of list ref */
+void fd_list_move_end(struct fd_list * ref, struct fd_list * senti)
+{
+        ASSERT(ref->head == ref);
+        ASSERT(senti->head == senti);
+        
+        if (senti->next == senti)
+                return;
+        
+        senti->next->prev = ref->prev;
+        ref->prev->next   = senti->next;
+        senti->prev->next = ref;
+        ref->prev         = senti->prev;
+        senti->prev = senti;
+        senti->next = senti;
+        
 }
 

libfreeDiameter/log.c

@@ -87 +87 @@
 }
 
-/* Write current time into a buffer */
-char * fd_log_time ( char * buf, size_t len )
+/* Write time into a buffer */
+char * fd_log_time ( struct timespec * ts, char * buf, size_t len )
 {
         int ret;
@@ -96 +96 @@
         
         /* Get current time */
-        ret = clock_gettime(CLOCK_REALTIME, &tp);
-        if (ret != 0) {
-                snprintf(buf, len, "%s", strerror(ret));
-                return buf;
+        if (!ts) {
+                ret = clock_gettime(CLOCK_REALTIME, &tp);
+                if (ret != 0) {
+                        snprintf(buf, len, "%s", strerror(ret));
+                        return buf;
+                }
+                ts = &tp;
         }
         
-        offset += strftime(buf + offset, len - offset, "%D,%T", localtime_r( &tp.tv_sec , &tm ));
-        offset += snprintf(buf + offset, len - offset, ".%6.6ld", tp.tv_nsec / 1000);
+        offset += strftime(buf + offset, len - offset, "%D,%T", localtime_r( &ts->tv_sec , &tm ));
+        offset += snprintf(buf + offset, len - offset, ".%6.6ld", ts->tv_nsec / 1000);
 
         return buf;