Navigation

Changeset 1180:773498f59520 in freeDiameter


Ignore:
Timestamp:
Jun 5, 2013, 4:02:29 PM (11 years ago)
Author:
Sebastien Decugis <sdecugis@freediameter.net>
Branch:
default
Phase:
public
Message:

Preparing for future DTLS/SCTP support

Files:
7 edited
1 moved

Legend:

Unmodified
Added
Removed

  • doc/freediameter.conf.sample

    r1165 r1180  
    3333# Default: 5658. Use 0 to disable.
    3434#SecPort = 5658;
     35
     36# freeDiameter 1.2.0 introduces the support of DTLS over SCTP (RFC6083) instead of TLS over SCTP (RFC3436),
     37# as specified in RFC6733. If you need compatibility with older implementation that use TLS over SCTP, you
     38# can open an additional SCTP server port using this method:
     39# Default: 0 (disabled). Use 3869 for compatibility with freeDiameter < 1.2.0.
     40#SctpSec3436 = 0;
    3541
    3642# Use RFC3588 method for TLS protection, where TLS is negociated after CER/CEA exchange is completed
    … …  
    212218#  No_TCP; No_SCTP; No_IP; No_IPv6; Prefer_TCP; TLS_old_method;
    213219#  No_TLS;       # assume transparent security instead of TLS
     220#  SctpSec3436;  # Use TLS/SCTP instead of DTLS/SCTP to protect SCTP associations with this peer.
    214221#  Port = 5658;  # The port to connect to
    215222#  TcTimer = 30;

  • include/freeDiameter/libfdcore.h

    r1169 r1180  
    129129        uint16_t         cnf_port;      /* the local port for legacy Diameter (default: 3868) in host byte order */
    130130        uint16_t         cnf_port_tls;  /* the local port for Diameter/TLS (default: 5658) in host byte order */
     131        uint16_t         cnf_port_3436; /* Open an additional server port to listen to old TLS/SCTP clients (RFC3436, freeDiameter versions < 1.2.0) */
    131132        uint16_t         cnf_sctp_str;  /* default max number of streams for SCTP associations (def: 30) */
    132133        struct fd_list   cnf_endpoints; /* the local endpoints to bind the server to. list of struct fd_endpoint. default is empty (bind all). After servers are started, this is the actual list of endpoints including port information. */
    … …  
    249250#define PI_SEC_TLS_OLD  2       /* Old TLS security (use Inband-Security-Id AVP during CER/CEA) */
    250251                                /* Set sec = 3 to authorize use of (Inband-Security-Id == NONE) with this peer, sec = 2 only authorizing TLS */
     252                               
     253#define PI_SCTPSEC_DEF  0       /* Use DTLS over SCTP to connect to this peer (default) */
     254#define PI_SCTPSEC_3436 1       /* Use TLS over SCTP to connect to this peer (RFC3436) */
    251255
    252256#define PI_EXP_NONE     0       /* the peer entry does not expire */
    … …  
    268272                        unsigned        alg :1;         /* PI_ALGPREF_* */
    269273                        unsigned        sec :2;         /* PI_SEC_* */
     274                        unsigned        sctpsec :1;     /* PI_SCTPSEC_* */
    270275                        unsigned        exp :1;         /* PI_EXP_* */
    271276                        unsigned        persist :1;     /* PI_PRST_* */

  • libfdcore/CMakeLists.txt

    r1159 r1180  
    3939
    4040IF(NOT DISABLE_SCTP)
    41         SET(FDCORE_SRC ${FDCORE_SRC} sctp.c sctps.c)
     41        SET(FDCORE_SRC ${FDCORE_SRC} sctp.c sctp3436.c)
    4242ENDIF(NOT DISABLE_SCTP)
    4343

  • libfdcore/cnxctx.c

    r1145 r1180  
    15341534#else /* DISABLE_SCTP */
    15351535                /* Initialize the wrapper, start the demux thread */
    1536                 CHECK_FCT( fd_sctps_init(conn) );
     1536                CHECK_FCT( fd_sctp3436_init(conn) );
    15371537#endif /* DISABLE_SCTP */
    15381538        } else {
    … …  
    15941594#ifndef DISABLE_SCTP
    15951595                /* Start reading the messages from the master session. That way, if the remote peer closed, we are not stuck inside handshake */
    1596                 CHECK_FCT(fd_sctps_startthreads(conn, 0));
     1596                CHECK_FCT(fd_sctp3436_startthreads(conn, 0));
    15971597
    15981598                /* Resume all additional sessions from the master one. */
    1599                 CHECK_FCT(fd_sctps_handshake_others(conn, priority, alt_creds));
     1599                CHECK_FCT(fd_sctp3436_handshake_others(conn, priority, alt_creds));
    16001600
    16011601                /* Start decrypting the messages from all threads and queuing them in target queue */
    1602                 CHECK_FCT(fd_sctps_startthreads(conn, 1));
     1602                CHECK_FCT(fd_sctp3436_startthreads(conn, 1));
    16031603#endif /* DISABLE_SCTP */
    16041604        } else {
    … …  
    17611761                                                ssize_t ret;
    17621762                                                size_t sent = 0;
    1763                                                 ASSERT(conn->cc_sctps_data.array != NULL);
     1763                                                ASSERT(conn->cc_sctp3436_data.array != NULL);
    17641764                                                do {
    1765                                                         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), );
     1765                                                        CHECK_GNUTLS_DO( ret = fd_tls_send_handle_error(conn, conn->cc_sctp3436_data.array[conn->cc_sctp_para.next].session, buf + sent, len - sent), );
    17661766                                                        if (ret <= 0)
    17671767                                                                return ENOTCONN;
    … …  
    18101810                        if (! fd_cnx_teststate(conn, CC_STATUS_ERROR ) ) {
    18111811                                /* and other stream pairs */
    1812                                 fd_sctps_bye(conn);
     1812                                fd_sctp3436_bye(conn);
    18131813                        }
    18141814
    18151815                        if (! fd_cnx_teststate(conn, CC_STATUS_ERROR ) ) {
    18161816                                /* Now wait for all decipher threads to terminate */
    1817                                 fd_sctps_waitthreadsterm(conn);
     1817                                fd_sctp3436_waitthreadsterm(conn);
    18181818                        } else {
    18191819                                /* Abord the threads, the connection is dead already */
    1820                                 fd_sctps_stopthreads(conn);
     1820                                fd_sctp3436_stopthreads(conn);
    18211821                        }
    18221822
    18231823                        /* Deinit gnutls resources */
    1824                         fd_sctps_gnutls_deinit_others(conn);
     1824                        fd_sctp3436_gnutls_deinit_others(conn);
    18251825                        if (conn->cc_tls_para.session) {
    18261826                                GNUTLS_TRACE( gnutls_deinit(conn->cc_tls_para.session) );
    … …  
    18291829                       
    18301830                        /* Destroy the wrapper (also stops the demux thread) */
    1831                         fd_sctps_destroy(conn);
     1831                        fd_sctp3436_destroy(conn);
    18321832
    18331833                } else {
    18341834#endif /* DISABLE_SCTP */
    1835                 /* We are TLS, but not using the sctps wrapper layer */
     1835                /* We are TLS, but not using the sctp3436 wrapper layer */
    18361836                        if (! fd_cnx_teststate(conn, CC_STATUS_ERROR ) ) {
    18371837                                /* Master session */

  • libfdcore/cnxctx.h

    r1127 r1180  
    7878        /* If both conditions */
    7979        struct {
    80                 struct sctps_ctx *array; /* an array of cc_sctp_para.pairs elements -- the #0 is special (session is outside)*/
     80                struct sctp3436_ctx *array; /* an array of cc_sctp_para.pairs elements -- the #0 is special (session is outside)*/
    8181                struct sr_store  *sess_store; /* Session data of the master session, to resume the children sessions */
    82         }               cc_sctps_data;
     82        }               cc_sctp3436_data;
    8383};
    8484
    … …  
    121121
    122122/* TLS over SCTP (multi-stream) */
    123 struct sctps_ctx {
     123struct sctp3436_ctx {
    124124        struct cnxctx   *parent;        /* for info such as socket, conn name, event list */
    125125        uint16_t         strid;         /* Stream # of this session */
    … …  
    134134};
    135135
    136 int fd_sctps_init(struct cnxctx * conn);
    137 int fd_sctps_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds);
    138 int fd_sctps_startthreads(struct cnxctx * conn, int others);
    139 void fd_sctps_bye(struct cnxctx * conn);
    140 void fd_sctps_waitthreadsterm(struct cnxctx * conn);
    141 void fd_sctps_gnutls_deinit_others(struct cnxctx * conn);
    142 void fd_sctps_stopthreads(struct cnxctx * conn);
    143 void fd_sctps_destroy(struct cnxctx * conn);
     136int fd_sctp3436_init(struct cnxctx * conn);
     137int fd_sctp3436_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds);
     138int fd_sctp3436_startthreads(struct cnxctx * conn, int others);
     139void fd_sctp3436_bye(struct cnxctx * conn);
     140void fd_sctp3436_waitthreadsterm(struct cnxctx * conn);
     141void fd_sctp3436_gnutls_deinit_others(struct cnxctx * conn);
     142void fd_sctp3436_stopthreads(struct cnxctx * conn);
     143void fd_sctp3436_destroy(struct cnxctx * conn);
    144144
    145145#endif /* DISABLE_SCTP */

  • libfdcore/fdd.l

    r979 r1180  
    246246(?i:"Port")             { return PORT;          }
    247247(?i:"SecPort")          { return SECPORT;       }
     248(?i:"SctpSec3436")      { return SEC3436;       }
    248249(?i:"No_IPv6")          { return NOIP6;         }
    249250(?i:"No_IP")            { return NOIP;          }

  • libfdcore/fdd.y

    r1012 r1180  
    9898%token          PORT
    9999%token          SECPORT
     100%token          SEC3436
    100101%token          NOIP
    101102%token          NOIP6
    … …  
    133134                        | conffile port
    134135                        | conffile secport
     136                        | conffile sec3436
    135137                        | conffile sctpstreams
    136138                        | conffile listenon
    … …  
    203205                                        { yyerror (&yylloc, conf, "Invalid value"); YYERROR; } );
    204206                                conf->cnf_port_tls = (uint16_t)$3;
     207                        }
     208                        ;
     209
     210sec3436:                SEC3436 '=' INTEGER ';'
     211                        {
     212                                CHECK_PARAMS_DO( ($3 >= 0) && ($3 < 1<<16),
     213                                        { yyerror (&yylloc, conf, "Invalid value"); YYERROR; } );
     214                                conf->cnf_port_3436 = (uint16_t)$3;
    205215                        }
    206216                        ;
    … …  
    453463                                fddpi.config.pic_flags.sec |= PI_SEC_NONE;
    454464                        }
     465                        | peerparams SEC3436 ';'
     466                        {
     467                                fddpi.config.pic_flags.sctpsec |= PI_SCTPSEC_3436;
     468                        }
    455469                        | peerparams REALM '=' QSTRING ';'
    456470                        {

  • libfdcore/sctp3436.c

    r1127 r1180  
    8484        ASSERT( conn->cc_proto == IPPROTO_SCTP );
    8585        ASSERT( fd_cnx_target_queue(conn) );
    86         ASSERT( conn->cc_sctps_data.array );
     86        ASSERT( conn->cc_sctp3436_data.array );
    8787       
    8888        do {
    … …  
    9292                                /* Demux this message to the appropriate fifo, another thread will pull, gnutls process, and send to target queue */
    9393                                if (strid < conn->cc_sctp_para.pairs) {
    94                                         CHECK_FCT_DO(fd_event_send(conn->cc_sctps_data.array[strid].raw_recv, event, bufsz, buf), goto fatal );
     94                                        CHECK_FCT_DO(fd_event_send(conn->cc_sctp3436_data.array[strid].raw_recv, event, bufsz, buf), goto fatal );
    9595                                } else {
    9696                                        TRACE_DEBUG(INFO, "Received packet (%zd bytes) on out-of-range stream #%d from %s, discarded.", bufsz, strid, conn->cc_remid);
    … …  
    120120        /* Signal termination of the connection to all decipher threads */
    121121        for (strid = 0; strid < conn->cc_sctp_para.pairs; strid++) {
    122                 if (conn->cc_sctps_data.array[strid].raw_recv) {
    123                         CHECK_FCT_DO(fd_event_send(conn->cc_sctps_data.array[strid].raw_recv, FDEVP_CNX_ERROR, 0, NULL), goto fatal );
     122                if (conn->cc_sctp3436_data.array[strid].raw_recv) {
     123                        CHECK_FCT_DO(fd_event_send(conn->cc_sctp3436_data.array[strid].raw_recv, FDEVP_CNX_ERROR, 0, NULL), goto fatal );
    124124                }
    125125        }
    … …  
    137137static void * decipher(void * arg)
    138138{
    139         struct sctps_ctx * ctx = arg;
     139        struct sctp3436_ctx * ctx = arg;
    140140        struct cnxctx    *cnx;
    141141       
    … …  
    165165
    166166/* Send data over the connection, called by gnutls */
    167 static ssize_t sctps_push(gnutls_transport_ptr_t tr, const void * data, size_t len)
    168 {
    169         struct sctps_ctx * ctx = (struct sctps_ctx *) tr;
     167static ssize_t sctp3436_push(gnutls_transport_ptr_t tr, const void * data, size_t len)
     168{
     169        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) tr;
    170170       
    171171        TRACE_ENTRY("%p %p %zd", tr, data, len);
    … …  
    178178
    179179/* Retrieve data received on a stream and already demultiplexed */
    180 static ssize_t sctps_pull(gnutls_transport_ptr_t tr, void * buf, size_t len)
    181 {
    182         struct sctps_ctx * ctx = (struct sctps_ctx *) tr;
     180static ssize_t sctp3436_pull(gnutls_transport_ptr_t tr, void * buf, size_t len)
     181{
     182        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) tr;
    183183        size_t pulled = 0;
    184184        int emptied;
    … …  
    229229GCC_DIAG_OFF("-Wdeprecated-declarations")
    230230#endif /* !GNUTLS_VERSION_300 */
    231 static void set_sess_transport(gnutls_session_t session, struct sctps_ctx *ctx)
     231static void set_sess_transport(gnutls_session_t session, struct sctp3436_ctx *ctx)
    232232{
    233233        /* Set the transport pointer passed to push & pull callbacks */
    … …  
    241241       
    242242        /* Set the push and pull callbacks */
    243         GNUTLS_TRACE( gnutls_transport_set_pull_function(session, sctps_pull) );
    244         GNUTLS_TRACE( gnutls_transport_set_push_function(session, sctps_push) );
     243        GNUTLS_TRACE( gnutls_transport_set_pull_function(session, sctp3436_pull) );
     244        GNUTLS_TRACE( gnutls_transport_set_push_function(session, sctp3436_push) );
    245245
    246246        return;
    … …  
    272272{
    273273        TRACE_ENTRY("%p", conn);
    274         CHECK_PARAMS( conn && !conn->cc_sctps_data.sess_store );
    275        
    276         CHECK_MALLOC( conn->cc_sctps_data.sess_store = malloc(sizeof(struct sr_store)) );
    277         memset(conn->cc_sctps_data.sess_store, 0, sizeof(struct sr_store));
    278        
    279         fd_list_init(&conn->cc_sctps_data.sess_store->list, NULL);
    280         CHECK_POSIX( pthread_rwlock_init(&conn->cc_sctps_data.sess_store->lock, NULL) );
    281         conn->cc_sctps_data.sess_store->parent = conn;
     274        CHECK_PARAMS( conn && !conn->cc_sctp3436_data.sess_store );
     275       
     276        CHECK_MALLOC( conn->cc_sctp3436_data.sess_store = malloc(sizeof(struct sr_store)) );
     277        memset(conn->cc_sctp3436_data.sess_store, 0, sizeof(struct sr_store));
     278       
     279        fd_list_init(&conn->cc_sctp3436_data.sess_store->list, NULL);
     280        CHECK_POSIX( pthread_rwlock_init(&conn->cc_sctp3436_data.sess_store->lock, NULL) );
     281        conn->cc_sctp3436_data.sess_store->parent = conn;
    282282       
    283283        return 0;
    … …  
    291291        CHECK_PARAMS_DO( conn, return );
    292292       
    293         if (!conn->cc_sctps_data.sess_store)
     293        if (!conn->cc_sctp3436_data.sess_store)
    294294                return;
    295295       
    296         CHECK_POSIX_DO( pthread_rwlock_destroy(&conn->cc_sctps_data.sess_store->lock), /* continue */ );
    297        
    298         while (!FD_IS_LIST_EMPTY(&conn->cc_sctps_data.sess_store->list)) {
    299                 struct sr_data * sr = (struct sr_data *) conn->cc_sctps_data.sess_store->list.next;
     296        CHECK_POSIX_DO( pthread_rwlock_destroy(&conn->cc_sctp3436_data.sess_store->lock), /* continue */ );
     297       
     298        while (!FD_IS_LIST_EMPTY(&conn->cc_sctp3436_data.sess_store->list)) {
     299                struct sr_data * sr = (struct sr_data *) conn->cc_sctp3436_data.sess_store->list.next;
    300300                fd_list_unlink( &sr->chain );
    301301                free(sr->key.data);
    … …  
    304304        }
    305305       
    306         free(conn->cc_sctps_data.sess_store);
    307         conn->cc_sctps_data.sess_store = NULL;
     306        free(conn->cc_sctp3436_data.sess_store);
     307        conn->cc_sctp3436_data.sess_store = NULL;
    308308        return;
    309309}
    … …  
    455455        GNUTLS_TRACE( gnutls_db_set_remove_function  (session, sr_remove));
    456456        GNUTLS_TRACE( gnutls_db_set_store_function   (session, sr_store));
    457         GNUTLS_TRACE( gnutls_db_set_ptr              (session, conn->cc_sctps_data.sess_store));
     457        GNUTLS_TRACE( gnutls_db_set_ptr              (session, conn->cc_sctp3436_data.sess_store));
    458458       
    459459        return;
    … …  
    463463static void * handshake_resume_th(void * arg)
    464464{
    465         struct sctps_ctx * ctx = (struct sctps_ctx *) arg;
     465        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) arg;
    466466        int resumed;
    467467       
    … …  
    504504
    505505/* Initialize the wrapper for the connection */
    506 int fd_sctps_init(struct cnxctx * conn)
     506int fd_sctp3436_init(struct cnxctx * conn)
    507507{
    508508        uint16_t i;
    509509       
    510510        TRACE_ENTRY("%p", conn);
    511         CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && (!conn->cc_sctps_data.array) );
     511        CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && (!conn->cc_sctp3436_data.array) );
    512512       
    513513        /* First, alloc the array and initialize the non-TLS data */
    514         CHECK_MALLOC( conn->cc_sctps_data.array = calloc(conn->cc_sctp_para.pairs, sizeof(struct sctps_ctx))  );
     514        CHECK_MALLOC( conn->cc_sctp3436_data.array = calloc(conn->cc_sctp_para.pairs, sizeof(struct sctp3436_ctx))  );
    515515        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    516                 conn->cc_sctps_data.array[i].parent = conn;
    517                 conn->cc_sctps_data.array[i].strid  = i;
    518                 CHECK_FCT( fd_fifo_new(&conn->cc_sctps_data.array[i].raw_recv, 10) );
     516                conn->cc_sctp3436_data.array[i].parent = conn;
     517                conn->cc_sctp3436_data.array[i].strid  = i;
     518                CHECK_FCT( fd_fifo_new(&conn->cc_sctp3436_data.array[i].raw_recv, 10) );
    519519        }
    520520       
    521521        /* Set push/pull functions in the master session, using fifo in array[0] */
    522         set_sess_transport(conn->cc_tls_para.session, &conn->cc_sctps_data.array[0]);
     522        set_sess_transport(conn->cc_tls_para.session, &conn->cc_sctp3436_data.array[0]);
    523523       
    524524        /* For server side, we also initialize the resuming capabilities */
    … …  
    539539
    540540/* Handshake other streams, after full handshake on the master session */
    541 int fd_sctps_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds)
     541int fd_sctp3436_handshake_others(struct cnxctx * conn, char * priority, void * alt_creds)
    542542{
    543543        uint16_t i;
    … …  
    546546       
    547547        TRACE_ENTRY("%p %p", conn, priority);
    548         CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && conn->cc_sctps_data.array );
     548        CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && conn->cc_sctp3436_data.array );
    549549
    550550        /* Server side: we set all the parameters, the resume callback will take care of resuming the session */
    … …  
    566566        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    567567                /* Set credentials and priority */
    568                 CHECK_FCT( fd_tls_prepare(&conn->cc_sctps_data.array[i].session, conn->cc_tls_para.mode, priority, alt_creds) );
     568                CHECK_FCT( fd_tls_prepare(&conn->cc_sctp3436_data.array[i].session, conn->cc_tls_para.mode, priority, alt_creds) );
    569569               
    570570                /* additional initialization for gnutls 3.x */
    … …  
    573573
    574574                /* fd_tls_verify_credentials_2 uses the connection */
    575                 gnutls_session_set_ptr (conn->cc_sctps_data.array[i].session, (void *) conn);
     575                gnutls_session_set_ptr (conn->cc_sctp3436_data.array[i].session, (void *) conn);
    576576
    577577                if ((conn->cc_tls_para.cn != NULL) && (conn->cc_tls_para.mode == GNUTLS_CLIENT)) {
    578578                        /* this might allow virtual hosting on the remote peer */
    579                         CHECK_GNUTLS_DO( gnutls_server_name_set (conn->cc_sctps_data.array[i].session, GNUTLS_NAME_DNS, conn->cc_tls_para.cn, strlen(conn->cc_tls_para.cn)), /* ignore failure */);
     579                        CHECK_GNUTLS_DO( gnutls_server_name_set (conn->cc_sctp3436_data.array[i].session, GNUTLS_NAME_DNS, conn->cc_tls_para.cn, strlen(conn->cc_tls_para.cn)), /* ignore failure */);
    580580                }
    581581
    … …  
    583583
    584584                #ifdef GNUTLS_VERSION_310
    585                 GNUTLS_TRACE( gnutls_handshake_set_timeout( conn->cc_sctps_data.array[i].session, GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT));
     585                GNUTLS_TRACE( gnutls_handshake_set_timeout( conn->cc_sctp3436_data.array[i].session, GNUTLS_DEFAULT_HANDSHAKE_TIMEOUT));
    586586                #endif /* GNUTLS_VERSION_310 */
    587587
    588588                /* For the client, copy data from master session; for the server, set session resuming pointers */
    589589                if (conn->cc_tls_para.mode == GNUTLS_CLIENT) {
    590                         CHECK_GNUTLS_DO( gnutls_session_set_data(conn->cc_sctps_data.array[i].session, master_data.data, master_data.size), return ENOMEM );
     590                        CHECK_GNUTLS_DO( gnutls_session_set_data(conn->cc_sctp3436_data.array[i].session, master_data.data, master_data.size), return ENOMEM );
    591591                } else {
    592                         set_resume_callbacks(conn->cc_sctps_data.array[i].session, conn);
     592                        set_resume_callbacks(conn->cc_sctp3436_data.array[i].session, conn);
    593593                }
    594594               
    595595                /* Set transport parameters */
    596                 set_sess_transport(conn->cc_sctps_data.array[i].session, &conn->cc_sctps_data.array[i]);
     596                set_sess_transport(conn->cc_sctp3436_data.array[i].session, &conn->cc_sctp3436_data.array[i]);
    597597               
    598598                /* Start the handshake thread */
    599                 CHECK_POSIX( pthread_create( &conn->cc_sctps_data.array[i].thr, NULL, handshake_resume_th, &conn->cc_sctps_data.array[i] ) );
     599                CHECK_POSIX( pthread_create( &conn->cc_sctp3436_data.array[i].thr, NULL, handshake_resume_th, &conn->cc_sctp3436_data.array[i] ) );
    600600        }
    601601       
    … …  
    608608        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    609609                void * ret;
    610                 CHECK_POSIX( pthread_join(conn->cc_sctps_data.array[i].thr, &ret) );
    611                 conn->cc_sctps_data.array[i].thr = (pthread_t) NULL;
     610                CHECK_POSIX( pthread_join(conn->cc_sctp3436_data.array[i].thr, &ret) );
     611                conn->cc_sctp3436_data.array[i].thr = (pthread_t) NULL;
    612612                if (ret == NULL) {
    613613                        errors++; /* Handshake failed on this stream */
    … …  
    625625
    626626/* Receive messages from others ? all other stream pairs : the master pair */
    627 int fd_sctps_startthreads(struct cnxctx * conn, int others)
     627int fd_sctp3436_startthreads(struct cnxctx * conn, int others)
    628628{
    629629        uint16_t i;
    630630       
    631631        TRACE_ENTRY("%p", conn);
    632         CHECK_PARAMS( conn && conn->cc_sctps_data.array );
     632        CHECK_PARAMS( conn && conn->cc_sctp3436_data.array );
    633633       
    634634        if (others) {
    … …  
    636636
    637637                        /* Start the decipher thread */
    638                         CHECK_POSIX( pthread_create( &conn->cc_sctps_data.array[i].thr, NULL, decipher, &conn->cc_sctps_data.array[i] ) );
     638                        CHECK_POSIX( pthread_create( &conn->cc_sctp3436_data.array[i].thr, NULL, decipher, &conn->cc_sctp3436_data.array[i] ) );
    639639                }
    640640        } else {
    641                 CHECK_POSIX( pthread_create( &conn->cc_sctps_data.array[0].thr, NULL, decipher, &conn->cc_sctps_data.array[0] ) );
     641                CHECK_POSIX( pthread_create( &conn->cc_sctp3436_data.array[0].thr, NULL, decipher, &conn->cc_sctp3436_data.array[0] ) );
    642642        }
    643643        return 0;
    … …  
    645645
    646646/* Initiate a "bye" on all stream pairs */
    647 void fd_sctps_bye(struct cnxctx * conn)
     647void fd_sctp3436_bye(struct cnxctx * conn)
    648648{
    649649        uint16_t i;
    650650       
    651         CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
     651        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    652652       
    653653        /* End all TLS sessions, in series (not as efficient as paralel, but simpler) */
    654654        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    655655                if ( ! fd_cnx_teststate(conn, CC_STATUS_ERROR)) {
    656                         CHECK_GNUTLS_DO( gnutls_bye(conn->cc_sctps_data.array[i].session, GNUTLS_SHUT_WR), fd_cnx_markerror(conn) );
     656                        CHECK_GNUTLS_DO( gnutls_bye(conn->cc_sctp3436_data.array[i].session, GNUTLS_SHUT_WR), fd_cnx_markerror(conn) );
    657657                }
    658658        }
    … …  
    660660
    661661/* After "bye" was sent on all streams, read from sessions until an error is received */
    662 void fd_sctps_waitthreadsterm(struct cnxctx * conn)
     662void fd_sctp3436_waitthreadsterm(struct cnxctx * conn)
    663663{
    664664        uint16_t i;
    665665       
    666666        TRACE_ENTRY("%p", conn);
    667         CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
     667        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    668668       
    669669        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    670                 if (conn->cc_sctps_data.array[i].thr != (pthread_t)NULL) {
    671                         CHECK_POSIX_DO( pthread_join(conn->cc_sctps_data.array[i].thr, NULL), /* continue */ );
    672                         conn->cc_sctps_data.array[i].thr = (pthread_t)NULL;
     670                if (conn->cc_sctp3436_data.array[i].thr != (pthread_t)NULL) {
     671                        CHECK_POSIX_DO( pthread_join(conn->cc_sctp3436_data.array[i].thr, NULL), /* continue */ );
     672                        conn->cc_sctp3436_data.array[i].thr = (pthread_t)NULL;
    673673                }
    674674        }
    … …  
    677677
    678678/* Free gnutls resources of all sessions */
    679 void fd_sctps_gnutls_deinit_others(struct cnxctx * conn)
     679void fd_sctp3436_gnutls_deinit_others(struct cnxctx * conn)
    680680{
    681681        uint16_t i;
    682682       
    683683        TRACE_ENTRY("%p", conn);
    684         CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
     684        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    685685       
    686686        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    687                 if (conn->cc_sctps_data.array[i].session) {
    688                         GNUTLS_TRACE( gnutls_deinit(conn->cc_sctps_data.array[i].session) );
    689                         conn->cc_sctps_data.array[i].session = NULL;
     687                if (conn->cc_sctp3436_data.array[i].session) {
     688                        GNUTLS_TRACE( gnutls_deinit(conn->cc_sctp3436_data.array[i].session) );
     689                        conn->cc_sctp3436_data.array[i].session = NULL;
    690690                }
    691691        }
    … …  
    694694
    695695/* Stop all receiver threads */
    696 void fd_sctps_stopthreads(struct cnxctx * conn)
     696void fd_sctp3436_stopthreads(struct cnxctx * conn)
    697697{
    698698        uint16_t i;
    699699       
    700700        TRACE_ENTRY("%p", conn);
    701         CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
     701        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    702702       
    703703        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    704                 CHECK_FCT_DO( fd_thr_term(&conn->cc_sctps_data.array[i].thr), /* continue */ );
     704                CHECK_FCT_DO( fd_thr_term(&conn->cc_sctp3436_data.array[i].thr), /* continue */ );
    705705        }
    706706        return;
    … …  
    708708
    709709/* Destroy a wrapper context */
    710 void fd_sctps_destroy(struct cnxctx * conn)
     710void fd_sctp3436_destroy(struct cnxctx * conn)
    711711{
    712712        uint16_t i;
    713713       
    714         CHECK_PARAMS_DO( conn && conn->cc_sctps_data.array, return );
     714        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    715715       
    716716        /* Terminate all receiving threads in case we did not do it yet */
    717         fd_sctps_stopthreads(conn);
     717        fd_sctp3436_stopthreads(conn);
    718718       
    719719        /* Now, stop the demux thread */
    … …  
    722722        /* Free remaining data in the array */
    723723        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    724                 if (conn->cc_sctps_data.array[i].raw_recv)
    725                         fd_event_destroy( &conn->cc_sctps_data.array[i].raw_recv, free );
    726                 free(conn->cc_sctps_data.array[i].partial.buf);
    727                 if (conn->cc_sctps_data.array[i].session) {
    728                         GNUTLS_TRACE( gnutls_deinit(conn->cc_sctps_data.array[i].session) );
    729                         conn->cc_sctps_data.array[i].session = NULL;
     724                if (conn->cc_sctp3436_data.array[i].raw_recv)
     725                        fd_event_destroy( &conn->cc_sctp3436_data.array[i].raw_recv, free );
     726                free(conn->cc_sctp3436_data.array[i].partial.buf);
     727                if (conn->cc_sctp3436_data.array[i].session) {
     728                        GNUTLS_TRACE( gnutls_deinit(conn->cc_sctp3436_data.array[i].session) );
     729                        conn->cc_sctp3436_data.array[i].session = NULL;
    730730                }
    731731        }
    732732       
    733733        /* Free the array itself now */
    734         free(conn->cc_sctps_data.array);
    735         conn->cc_sctps_data.array = NULL;
     734        free(conn->cc_sctp3436_data.array);
     735        conn->cc_sctp3436_data.array = NULL;
    736736       
    737737        /* Delete the store of sessions */
Note: See TracChangeset for help on using the changeset viewer.