Navigation


Changeset 1344:a5c072798f1a in freeDiameter for libfdcore


Ignore:
Timestamp:
Apr 12, 2019, 8:15:04 PM (5 years ago)
Author:
Thomas Klausner <tk@giga.or.at>
Branch:
default
Phase:
public
Message:

Increase two buffer sizes to avoid truncation.

Remove trailing whitespace while here.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • libfdcore/sctp3436.c

    r1190 r1344  
    5151 - the push function sends the data on a certain stream.
    5252 We also have a demux thread that reads the socket and store received data in the appropriate fifo
    53  
     53
    5454 We have one gnutls_session per stream pair, and as many threads that read the gnutls records and save incoming data to the target queue.
    55  
     55
    5656This complexity is required because we cannot read a socket for a given stream only; we can only get the next message and find its stream.
    5757*/
     
    7171        int       event;
    7272        uint16_t  strid;
    73        
     73
    7474        TRACE_ENTRY("%p", arg);
    7575        CHECK_PARAMS_DO(conn && (conn->cc_socket > 0), goto out);
    76        
     76
    7777        /* Set the thread name */
    7878        {
    79                 char buf[48];
     79                char buf[100];
    8080                snprintf(buf, sizeof(buf), "Demuxer (%d:%s)", conn->cc_socket, conn->cc_remid);
    8181                fd_log_threadname ( buf );
    8282        }
    83        
     83
    8484        ASSERT( conn->cc_proto == IPPROTO_SCTP );
    8585        ASSERT( fd_cnx_target_queue(conn) );
    8686        ASSERT( conn->cc_sctp3436_data.array );
    87        
     87
    8888        do {
    8989                CHECK_FCT_DO( fd_sctp_recvmeta(conn, &strid, &buf, &bufsz, &event), goto fatal );
     
    9898                                }
    9999                                break;
    100                                
     100
    101101                        case FDEVP_CNX_EP_CHANGE:
    102102                                /* Send this event to the target queue */
    103103                                CHECK_FCT_DO( fd_event_send( fd_cnx_target_queue(conn), event, bufsz, buf), goto fatal );
    104104                                break;
    105                        
     105
    106106                        case FDEVP_CNX_ERROR:
    107107                                goto out;
    108                                
     108
    109109                        case FDEVP_CNX_SHUTDOWN:
    110110                                /* Just ignore the notification for now, we will get another error later anyway */
    111111                                continue;
    112                                
     112
    113113                        default:
    114114                                goto fatal;
    115115                }
    116                
     116
    117117        } while (conn->cc_loop);
    118        
     118
    119119out:
    120120        /* Signal termination of the connection to all decipher threads */
     
    125125        }
    126126        fd_cnx_markerror(conn);
    127         TRACE_DEBUG(FULL, "Thread terminated"); 
     127        TRACE_DEBUG(FULL, "Thread terminated");
    128128        return NULL;
    129        
     129
    130130fatal:
    131131        /* An unrecoverable error occurred, stop the daemon */
     
    139139        struct sctp3436_ctx * ctx = arg;
    140140        struct cnxctx    *cnx;
    141        
     141
    142142        TRACE_ENTRY("%p", arg);
    143143        CHECK_PARAMS_DO(ctx && ctx->raw_recv && ctx->parent, goto error);
    144144        cnx = ctx->parent;
    145145        ASSERT( fd_cnx_target_queue(cnx) );
    146        
     146
    147147        /* Set the thread name */
    148148        {
    149                 char buf[48];
     149                char buf[100];
    150150                snprintf(buf, sizeof(buf), "Decipher (%hu@%d:%s)", ctx->strid, cnx->cc_socket, cnx->cc_remid);
    151151                fd_log_threadname ( buf );
    152152        }
    153        
     153
    154154        /* The next function loops while there is no error */
    155155        CHECK_FCT_DO(fd_tls_rcvthr_core(cnx, ctx->strid ? ctx->session : cnx->cc_tls_para.session), /* continue */);
    156156error:
    157157        fd_cnx_markerror(cnx);
    158         TRACE_DEBUG(FULL, "Thread terminated"); 
     158        TRACE_DEBUG(FULL, "Thread terminated");
    159159        return NULL;
    160160}
     
    171171        struct timespec tsstore, *ts = NULL;
    172172        int ret;
    173        
     173
    174174        TRACE_ENTRY("%p %d", tr, ms);
    175        
     175
    176176        if (ctx->partial.buf)
    177177                return 1; /* data is already available for pull */
    178        
     178
    179179        if (ms) {
    180180                CHECK_SYS_DO(  clock_gettime(CLOCK_REALTIME, &tsstore),  return -1  );
     
    184184                ts = &tsstore;
    185185        }
    186        
     186
    187187        ret = fd_fifo_select ( ctx->raw_recv, ts );
    188188        if (ret < 0) {
     
    190190                ret = -1;
    191191        }
    192                
     192
    193193        return ret;
    194194}
     
    201201        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) tr;
    202202        struct iovec iov;
    203        
     203
    204204        TRACE_ENTRY("%p %p %zd", tr, data, len);
    205205        CHECK_PARAMS_DO( tr && data, { errno = EINVAL; return -1; } );
    206        
     206
    207207        iov.iov_base = (void *)data;
    208208        iov.iov_len  = len;
    209        
     209
    210210        return fd_sctp_sendstrv(ctx->parent, ctx->strid, &iov, 1);
    211211}
     
    214214{
    215215        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) tr;
    216        
     216
    217217        TRACE_ENTRY("%p %p %d", tr, iov, iovcnt);
    218218        CHECK_PARAMS_DO( tr && iov, { errno = EINVAL; return -1; } );
    219        
     219
    220220        return fd_sctp_sendstrv(ctx->parent, ctx->strid, (const struct iovec *)iov, iovcnt);
    221221}
     
    228228        size_t pulled = 0;
    229229        int emptied;
    230        
     230
    231231        TRACE_ENTRY("%p %p %zd", tr, buf, len);
    232232        CHECK_PARAMS_DO( tr && buf, { errno = EINVAL; goto error; } );
    233        
     233
    234234        /* If we don't have data available now, pull new message from the fifo -- this is blocking (until the queue is destroyed) */
    235235        if (!ctx->partial.buf) {
     
    241241                }
    242242        }
    243                
     243
    244244        pulled = ctx->partial.bufsz - ctx->partial.offset;
    245245        if (pulled <= len) {
     
    264264        /* We are done */
    265265        return pulled;
    266        
     266
    267267error:
    268268        gnutls_transport_set_errno (ctx->session, errno);
     
    278278        /* Set the transport pointer passed to push & pull callbacks */
    279279        GNUTLS_TRACE( gnutls_transport_set_ptr( session, (gnutls_transport_ptr_t) ctx ) );
    280        
     280
    281281        /* Reset the low water value, since we don't use sockets */
    282282#ifndef GNUTLS_VERSION_300
     
    287287        GNUTLS_TRACE( gnutls_transport_set_pull_timeout_function( session, sctp3436_pull_timeout ) );
    288288#endif /* GNUTLS_VERSION_300 */
    289        
     289
    290290        /* Set the push and pull callbacks */
    291291        GNUTLS_TRACE( gnutls_transport_set_pull_function(session, sctp3436_pull) );
     
    325325        TRACE_ENTRY("%p", conn);
    326326        CHECK_PARAMS( conn && !conn->cc_sctp3436_data.sess_store );
    327        
     327
    328328        CHECK_MALLOC( conn->cc_sctp3436_data.sess_store = malloc(sizeof(struct sr_store)) );
    329329        memset(conn->cc_sctp3436_data.sess_store, 0, sizeof(struct sr_store));
    330        
     330
    331331        fd_list_init(&conn->cc_sctp3436_data.sess_store->list, NULL);
    332332        CHECK_POSIX( pthread_rwlock_init(&conn->cc_sctp3436_data.sess_store->lock, NULL) );
    333333        conn->cc_sctp3436_data.sess_store->parent = conn;
    334        
     334
    335335        return 0;
    336336}
     
    342342        TRACE_ENTRY("%p", conn);
    343343        CHECK_PARAMS_DO( conn, return );
    344        
     344
    345345        if (!conn->cc_sctp3436_data.sess_store)
    346346                return;
    347        
     347
    348348        CHECK_POSIX_DO( pthread_rwlock_destroy(&conn->cc_sctp3436_data.sess_store->lock), /* continue */ );
    349        
     349
    350350        while (!FD_IS_LIST_EMPTY(&conn->cc_sctp3436_data.sess_store->list)) {
    351351                struct sr_data * sr = (struct sr_data *) conn->cc_sctp3436_data.sess_store->list.next;
     
    355355                free(sr);
    356356        }
    357        
     357
    358358        free(conn->cc_sctp3436_data.sess_store);
    359359        conn->cc_sctp3436_data.sess_store = NULL;
     
    366366        struct fd_list * ret;
    367367        *match = 0;
    368        
     368
    369369        for (ret = sto->list.next; ret != &sto->list; ret = ret->next) {
    370370                int cmp = 0;
    371371                struct sr_data * sr = (struct sr_data *)ret;
    372                
     372
    373373                cmp = fd_os_cmp(key.data, key.size, sr->key.data, sr->key.size);
    374374                if (cmp > 0)
    375375                        continue;
    376                
     376
    377377                if (cmp == 0)
    378378                        *match = 1;
    379                
     379
    380380                break;
    381381        }
    382        
     382
    383383        return ret;
    384384}
     
    392392        int match = 0;
    393393        int ret = 0;
    394        
     394
    395395        TRACE_DEBUG( GNUTLS_DBG_LEVEL, "GNUTLS Callback: %s", __PRETTY_FUNCTION__ );
    396396        CHECK_PARAMS_DO( sto && key.data && data.data, return -1 );
    397        
     397
    398398        CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
    399399        TRACE_BUFFER(FD_LOG_DEBUG, GNUTLS_DBG_LEVEL, "Session store [key ", key.data, key.size, "]");
    400        
     400
    401401        li = find_or_next(sto, key, &match);
    402402        if (match) {
    403403                sr = (struct sr_data *)li;
    404                
     404
    405405                /* Check the data is the same */
    406406                if ((data.size != sr->data.size) || memcmp(data.data, sr->data.data, data.size)) {
     
    409409                        TRACE_BUFFER(FD_LOG_DEBUG, INFO, "  -- old data [", sr->data.data, sr->data.size, "]");
    410410                        TRACE_BUFFER(FD_LOG_DEBUG, INFO, "  -- new data [", data.data, data.size, "]");
    411                        
     411
    412412                        ret = -1;
    413413                } else {
     
    416416                goto out;
    417417        }
    418        
     418
    419419        /* Create a new entry */
    420420        CHECK_MALLOC_DO( sr = malloc(sizeof(struct sr_data)), { ret = -1; goto out; } );
     
    430430        sr->data.size = data.size;
    431431        memcpy(sr->data.data, data.data, data.size);
    432        
     432
    433433        /* Save this new entry in the list, we are done */
    434434        fd_list_insert_before(li, &sr->chain);
    435435
    436 out:   
     436out:
    437437        CHECK_POSIX_DO( pthread_rwlock_unlock(&sto->lock), return -1 );
    438438        return ret;
     
    446446        int match = 0;
    447447        int ret = 0;
    448        
     448
    449449        TRACE_DEBUG( GNUTLS_DBG_LEVEL, "GNUTLS Callback: %s", __PRETTY_FUNCTION__ );
    450450        CHECK_PARAMS_DO( sto && key.data, return -1 );
    451        
     451
    452452        CHECK_POSIX_DO( pthread_rwlock_wrlock(&sto->lock), return -1 );
    453453        TRACE_BUFFER(FD_LOG_DEBUG, GNUTLS_DBG_LEVEL, "Session delete [key ", key.data, key.size, "]");
    454        
     454
    455455        li = find_or_next(sto, key, &match);
    456456        if (match) {
    457457                sr = (struct sr_data *)li;
    458                
     458
    459459                /* Destroy this data */
    460460                fd_list_unlink(li);
     
    466466                ret = -1;
    467467        }
    468        
     468
    469469        CHECK_POSIX_DO( pthread_rwlock_unlock(&sto->lock), return -1 );
    470470        return ret;
     
    485485        CHECK_POSIX_DO( pthread_rwlock_rdlock(&sto->lock), return error );
    486486        TRACE_BUFFER(FD_LOG_DEBUG, GNUTLS_DBG_LEVEL, "Session fetch [key ", key.data, key.size, "]");
    487        
     487
    488488        li = find_or_next(sto, key, &match);
    489489        if (match) {
     
    493493                memcpy(res.data, sr->data.data, res.size);
    494494        }
    495 out:   
     495out:
    496496        TRACE_DEBUG(GNUTLS_DBG_LEVEL, "Fetched (%p, %d) from store %p", res.data, res.size, sto);
    497497        CHECK_POSIX_DO( pthread_rwlock_unlock(&sto->lock), return error);
     
    503503{
    504504        TRACE_ENTRY("%p", conn);
    505        
     505
    506506        GNUTLS_TRACE( gnutls_db_set_retrieve_function(session, sr_fetch));
    507507        GNUTLS_TRACE( gnutls_db_set_remove_function  (session, sr_remove));
    508508        GNUTLS_TRACE( gnutls_db_set_store_function   (session, sr_store));
    509509        GNUTLS_TRACE( gnutls_db_set_ptr              (session, conn->cc_sctp3436_data.sess_store));
    510        
     510
    511511        return;
    512512}
     
    517517        struct sctp3436_ctx * ctx = (struct sctp3436_ctx *) arg;
    518518        int resumed;
    519        
     519
    520520        TRACE_ENTRY("%p", arg);
    521        
     521
    522522        /* Set the thread name */
    523523        {
     
    526526                fd_log_threadname ( buf );
    527527        }
    528        
     528
    529529        TRACE_DEBUG(FULL, "Starting TLS resumed handshake on stream %hu", ctx->strid);
    530530
    531531        CHECK_GNUTLS_DO( gnutls_handshake( ctx->session ), return NULL);
    532                        
     532
    533533        GNUTLS_TRACE( resumed = gnutls_session_is_resumed(ctx->session) );
    534534        #ifndef GNUTLS_VERSION_300
     
    545545                }
    546546        }
    547                        
     547
    548548        /* Finished, OK */
    549549        return arg;
     
    559559{
    560560        uint16_t i;
    561        
     561
    562562        TRACE_ENTRY("%p", conn);
    563563        CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && (!conn->cc_sctp3436_data.array) );
    564        
     564
    565565        /* First, alloc the array and initialize the non-TLS data */
    566566        CHECK_MALLOC( conn->cc_sctp3436_data.array = calloc(conn->cc_sctp_para.pairs, sizeof(struct sctp3436_ctx))  );
     
    570570                CHECK_FCT( fd_fifo_new(&conn->cc_sctp3436_data.array[i].raw_recv, 10) );
    571571        }
    572        
     572
    573573        /* Set push/pull functions in the master session, using fifo in array[0] */
    574574        set_sess_transport(conn->cc_tls_para.session, &conn->cc_sctp3436_data.array[0]);
    575        
     575
    576576        /* For server side, we also initialize the resuming capabilities */
    577577        if (conn->cc_tls_para.mode == GNUTLS_SERVER) {
    578                
     578
    579579                /* Prepare the store for sessions data */
    580580                CHECK_FCT( store_init(conn) );
    581                
     581
    582582                /* Set the callbacks for resuming in the master session */
    583583                set_resume_callbacks(conn->cc_tls_para.session, conn);
     
    586586        /* Start the demux thread */
    587587        CHECK_POSIX( pthread_create( &conn->cc_rcvthr, NULL, demuxer, conn ) );
    588        
     588
    589589        return 0;
    590590}
     
    596596        int errors = 0;
    597597        gnutls_datum_t  master_data;
    598        
     598
    599599        TRACE_ENTRY("%p %p", conn, priority);
    600600        CHECK_PARAMS( conn && (conn->cc_sctp_para.pairs > 1) && conn->cc_sctp3436_data.array );
     
    602602        /* Server side: we set all the parameters, the resume callback will take care of resuming the session */
    603603        /* Client side: we duplicate the parameters of the master session, then set the transport pointer */
    604        
     604
    605605        /* For client side, retrieve the master session parameters */
    606606        if (conn->cc_tls_para.mode == GNUTLS_CLIENT) {
     
    614614                }
    615615        }
    616        
     616
    617617        /* Initialize the session objects and start the handshake in a separate thread */
    618618        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    619619                /* Set credentials and priority */
    620620                CHECK_FCT( fd_tls_prepare(&conn->cc_sctp3436_data.array[i].session, conn->cc_tls_para.mode, 0, priority, alt_creds) );
    621                
     621
    622622                /* additional initialization for gnutls 3.x */
    623623                #ifdef GNUTLS_VERSION_300
     
    644644                        set_resume_callbacks(conn->cc_sctp3436_data.array[i].session, conn);
    645645                }
    646                
     646
    647647                /* Set transport parameters */
    648648                set_sess_transport(conn->cc_sctp3436_data.array[i].session, &conn->cc_sctp3436_data.array[i]);
    649                
     649
    650650                /* Start the handshake thread */
    651651                CHECK_POSIX( pthread_create( &conn->cc_sctp3436_data.array[i].thr, NULL, handshake_resume_th, &conn->cc_sctp3436_data.array[i] ) );
    652652        }
    653        
     653
    654654        /* We can now release the memory of master session data if any */
    655655        if (conn->cc_tls_para.mode == GNUTLS_CLIENT) {
    656656                GNUTLS_TRACE( gnutls_free(master_data.data) );
    657657        }
    658        
     658
    659659        /* Now wait for all handshakes to finish */
    660660        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
     
    666666                }
    667667        }
    668        
     668
    669669        if (errors) {
    670670                TRACE_DEBUG(INFO, "Handshake failed on %d/%hd stream pairs", errors, conn->cc_sctp_para.pairs);
     
    672672                return ENOTCONN;
    673673        }
    674        
     674
    675675        return 0;
    676676}
     
    680680{
    681681        uint16_t i;
    682        
     682
    683683        TRACE_ENTRY("%p", conn);
    684684        CHECK_PARAMS( conn && conn->cc_sctp3436_data.array );
    685        
     685
    686686        if (others) {
    687687                for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
     
    700700{
    701701        uint16_t i;
    702        
     702
    703703        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    704        
     704
    705705        /* End all TLS sessions, in series (not as efficient as paralel, but simpler) */
    706706        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
     
    715715{
    716716        uint16_t i;
    717        
     717
    718718        TRACE_ENTRY("%p", conn);
    719719        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    720        
     720
    721721        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    722722                if (conn->cc_sctp3436_data.array[i].thr != (pthread_t)NULL) {
     
    732732{
    733733        uint16_t i;
    734        
     734
    735735        TRACE_ENTRY("%p", conn);
    736736        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    737        
     737
    738738        for (i = 1; i < conn->cc_sctp_para.pairs; i++) {
    739739                if (conn->cc_sctp3436_data.array[i].session) {
     
    749749{
    750750        uint16_t i;
    751        
     751
    752752        TRACE_ENTRY("%p", conn);
    753753        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    754        
     754
    755755        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
    756756                CHECK_FCT_DO( fd_thr_term(&conn->cc_sctp3436_data.array[i].thr), /* continue */ );
     
    763763{
    764764        uint16_t i;
    765        
     765
    766766        CHECK_PARAMS_DO( conn && conn->cc_sctp3436_data.array, return );
    767        
     767
    768768        /* Terminate all receiving threads in case we did not do it yet */
    769769        fd_sctp3436_stopthreads(conn);
    770        
     770
    771771        /* Now, stop the demux thread */
    772772        CHECK_FCT_DO( fd_thr_term(&conn->cc_rcvthr), /* continue */ );
    773        
     773
    774774        /* Free remaining data in the array */
    775775        for (i = 0; i < conn->cc_sctp_para.pairs; i++) {
     
    782782                }
    783783        }
    784        
     784
    785785        /* Free the array itself now */
    786786        free(conn->cc_sctp3436_data.array);
    787787        conn->cc_sctp3436_data.array = NULL;
    788        
     788
    789789        /* Delete the store of sessions */
    790790        store_destroy(conn);
    791        
     791
    792792        return ;
    793793}
Note: See TracChangeset for help on using the changeset viewer.