Navigation

Changes in / [1081:758b21ae6c3e:1082:b380c9f3be1e] in freeDiameter


Ignore:
Files:
3 added
12 edited

Legend:

Unmodified
Added
Removed

  • extensions/app_diameap/diameap_eap.c

    r1052 r1075  
    373373                case EAP_INTEGRITY_CHECK:
    374374                        if ((*eap_sm->selectedMethod->eap_method_check)(eap_sm,
    375                                         eap_i->aaaEapRespData) == FALSE)
     375                                        &eap_i->aaaEapRespData) == FALSE)
    376376                        {
    377377                                TRACE_DEBUG(INFO,"%s[EAP Protocol] Invalid EAP packet received {Type=%d, Vendor=%d}. Integrity check failed (non fatal error).",DIAMEAP_EXTENSION,eap_sm->currentMethod,eap_sm->currentVendor);
    … …  
    434434                        }
    435435                        if ((*eap_sm->selectedMethod->eap_method_process)(eap_sm,
    436                                         eap_i->aaaEapRespData))
     436                                        &eap_i->aaaEapRespData))
    437437                        {
    438438                                TRACE_DEBUG(INFO,"%s[EAP Protocol] [%s plugin] Authentication process failed.",DIAMEAP_EXTENSION,eap_sm->selectedMethod->methodname);

  • extensions/app_diameap/diameap_plugins.c

    r1052 r1075  
    263263                {
    264264                        plugin->eap_method_check = (boolean(*)(struct eap_state_machine *,
    265                                         struct eap_packet)) dlsym(plugin->handler,
     265                                        struct eap_packet*)) dlsym(plugin->handler,
    266266                                        registerplugin->check);
    267267                        if (plugin->eap_method_check == NULL)
    … …  
    285285                {
    286286                        plugin->eap_method_process = (int(*)(struct eap_state_machine *,
    287                                         struct eap_packet)) dlsym(plugin->handler,
     287                                        struct eap_packet*)) dlsym(plugin->handler,
    288288                                        registerplugin->process);
    289289                        if (plugin->eap_method_process == NULL)

  • extensions/app_diameap/libdiameap.h

    r610 r1075  
    110110        int (*eap_method_getTimeout)(struct eap_state_machine *smd, int * timeout); /* address of the eap_method_getTimeout method */
    111111        boolean (*eap_method_check)(struct eap_state_machine *smd,
    112                         struct eap_packet eapRespData); /* address of the eap_method_check method */
     112                        struct eap_packet * eapRespData); /* address of the eap_method_check method */
    113113        int (*eap_method_process)(struct eap_state_machine *smd,
    114                         struct eap_packet eapRespData); /* address of the eap_method_process method */
     114                        struct eap_packet * eapRespData); /* address of the eap_method_process method */
    115115        boolean (*eap_method_isDone)(struct eap_state_machine *smd); /* address of the eap_method_isDone method */
    116116        int (*eap_method_getKey)(struct eap_state_machine *smd, u8 ** msk,int *msklength,

  • extensions/dbg_interactive/queues.i

    r1060 r1071  
    6666        /* Get the length of the queue (nb elements) */
    6767        int length() {
    68                 int l;
    69                 int ret = fd_fifo_length ( $self, &l, NULL );
    70                 if (ret != 0) {
    71                         DI_ERROR(ret, NULL, NULL);
    72                 }
    73                 return l;
     68                return fd_fifo_length ( $self ) ;
    7469        }
    7570

  • extensions/dbg_monitor/dbg_monitor.c

    r974 r1075  
    5050EXTENSION_ENTRY("dbg_monitor", monitor_main);
    5151
     52
     53
     54/* Display information about a queue */
     55static void display_info(char * queue_desc, char * peer, int current_count, int limit_count, int highest_count, long long total_count,
     56                        struct timespec * total, struct timespec * blocking, struct timespec * last)
     57{
     58        long long ms = (total->tv_sec * 1000000) + (total->tv_nsec / 1000);
     59        long double throughput = (long double)total_count * 1000000;
     60        throughput /= ms;
     61        if (peer) {
     62                TRACE_DEBUG(INFO, "'%s'@'%s': cur:%d/%d, h:%d, T:%lld in %ld.%06lds (%.2LFitems/s), blocked:%ld.%06lds, last processing:%ld.%06lds",
     63                        queue_desc, peer, current_count, limit_count, highest_count,
     64                        total_count, total->tv_sec, total->tv_nsec, throughput,
     65                        blocking->tv_sec, blocking->tv_nsec, last->tv_sec, last->tv_nsec);
     66        } else {
     67                TRACE_DEBUG(INFO, "Global '%s': cur:%d/%d, h:%d, T:%lld in %ld.%06lds (%.2LFitems/s), blocked:%ld.%06lds, last processing:%ld.%06lds",
     68                        queue_desc, current_count, limit_count, highest_count,
     69                        total_count, total->tv_sec, total->tv_nsec, throughput,
     70                        blocking->tv_sec, blocking->tv_nsec, last->tv_sec, last->tv_nsec);
     71        }
     72}
     73
    5274/* Thread to display periodical debug information */
    5375static pthread_t thr;
    … …  
    5981        /* Loop */
    6082        while (1) {
     83                int current_count, limit_count, highest_count;
     84                long long total_count;
     85                struct timespec total, blocking, last;
     86                struct fd_list * li;
     87       
    6188                #ifdef DEBUG
    6289                for (i++; i % 30; i++) {
    … …  
    6592                }
    6693                #else /* DEBUG */
    67                 sleep(3600); /* 1 hour */
     94                sleep(3599); /* 1 hour */
    6895                #endif /* DEBUG */
    69                 fd_log_debug("[dbg_monitor] Dumping current information");
    70                 CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_QUEUES, 0, NULL), /* continue */);
     96                TRACE_DEBUG(INFO, "[dbg_monitor] Dumping queues statistics");
     97               
     98                CHECK_FCT_DO( fd_stat_getstats(STAT_G_LOCAL, NULL, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
     99                display_info("Local delivery", NULL, current_count, limit_count, highest_count, total_count, &total, &blocking, &last);
     100               
     101                CHECK_FCT_DO( fd_stat_getstats(STAT_G_INCOMING, NULL, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
     102                display_info("Total received", NULL, current_count, limit_count, highest_count, total_count, &total, &blocking, &last);
     103               
     104                CHECK_FCT_DO( fd_stat_getstats(STAT_G_OUTGOING, NULL, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
     105                display_info("Total sending", NULL, current_count, limit_count, highest_count, total_count, &total, &blocking, &last);
     106               
     107               
     108                CHECK_FCT_DO( pthread_rwlock_rdlock(&fd_g_peers_rw), /* continue */ );
     109
     110                for (li = fd_g_peers.next; li != &fd_g_peers; li = li->next) {
     111                        struct peer_hdr * p = (struct peer_hdr *)li->o;
     112                       
     113                        fd_peer_dump(p, NONE);
     114                       
     115                        CHECK_FCT_DO( fd_stat_getstats(STAT_P_PSM, p, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
     116                        display_info("Events, incl. recept", p->info.pi_diamid, current_count, limit_count, highest_count, total_count, &total, &blocking, &last);
     117                       
     118                        CHECK_FCT_DO( fd_stat_getstats(STAT_P_TOSEND, p, &current_count, &limit_count, &highest_count, &total_count, &total, &blocking, &last), );
     119                        display_info("Outgoing", p->info.pi_diamid, current_count, limit_count, highest_count, total_count, &total, &blocking, &last);
     120                       
     121                }
     122
     123                CHECK_FCT_DO( pthread_rwlock_unlock(&fd_g_peers_rw), /* continue */ );
     124
     125               
     126               
    71127                CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_SERV, 0, NULL), /* continue */);
    72                 CHECK_FCT_DO(fd_event_send(fd_g_config->cnf_main_ev, FDEV_DUMP_PEERS, 0, NULL), /* continue */);
    73128                sleep(1);
    74129        }

  • include/freeDiameter/libfdcore.h

    r1069 r1077  
    861861/*============================================================*/
    862862
    863 /* These functions allows an extension to collect state information about the
    864  * framework state, as well as hooks at some key checkpoints in the processing
     863/* These functions allow an extension to collect state information about the
     864 * framework, as well as being hooked at some key checkpoints in the processing
    865865 * for logging / statistics purpose.
    866866 */
    … …  
    10971097 *  stat          : Which queue is being queried
    10981098 *  peer          : (depending on the stat parameter) which peer is being queried
    1099  *  len          : (out) The number of items in the queue currently
    1100  *  max           : (out) The max number of items the queue accepts before becoming blocking -- 0 means no max.
     1099 *  current_count : (out) The number of items in the queue currently
     1100 *  limit_count   : (out) The max number of items the queue accepts before becoming blocking -- 0 means no max.
    11011101 *  highest_count : (out) The highest count the queue has reached since startup
    11021102 *  total_count   : (out) Total number of items that this queue has processed (always growing, use deltas for monitoring)
    … …  
    11141114 */
    11151115int fd_stat_getstats(enum fd_stat_type stat, struct peer_hdr * peer,
    1116                         int * len, int * max, int * highest_count, long long * total_count,
     1116                        int * current_count, int * limit_count, int * highest_count, long long * total_count,
    11171117                        struct timespec * total, struct timespec * blocking, struct timespec * last);
    11181118

  • include/freeDiameter/libfdproto.h

    r1078 r1082  
    29892989
    29902990/*
     2991 * FUNCTION:    fd_fifo_getstats
     2992 *
     2993 * PARAMETERS:
     2994 *  queue         : The queue from which to retrieve the information.
     2995 *  current_count : How many items in the queue at the time of execution. This changes each time an item is pushed or poped.
     2996 *  limit_count   : The maximum number of items allowed in this queue. This is specified during queue creation.
     2997 *  highest_count : The maximum number of items this queue has contained. This enables to see if limit_count count was reached.
     2998 *  total_count   : the total number of items that went through the queue (already pop'd). Always increasing.
     2999 *  total         : Cumulated time all items spent in this queue, including blocking time (always growing, use deltas for monitoring)
     3000 *  blocking      : Cumulated time threads trying to post new items were blocked (queue full).
     3001 *  last          : For the last element retrieved from the queue, how long it take between posting (including blocking) and poping
     3002 * 
     3003 * DESCRIPTION:
     3004 *  Retrieve the timing information associated with a queue, for monitoring purpose.
     3005 *
     3006 * RETURN VALUE:
     3007 *  0           : The statistics have been updated.
     3008 *  EINVAL      : A parameter is invalid.
     3009 */
     3010int fd_fifo_getstats( struct fifo * queue, int * current_count, int * limit_count, int * highest_count, long long * total_count,
     3011                                           struct timespec * total, struct timespec * blocking, struct timespec * last);
     3012
     3013/*
    29913014 * FUNCTION:    fd_fifo_length
    29923015 *
    29933016 * PARAMETERS:
    29943017 *  queue       : The queue from which to retrieve the number of elements.
    2995  *  length      : Upon success, the current number of elements in the queue is stored here.
    2996  *  max         : the maximum number of elements as specified during creation. Can be NULL.
    2997  *
    2998  * DESCRIPTION:
    2999  *  Retrieve the number of elements in a queue.
    3000  *
    3001  * RETURN VALUE:
    3002  *  0           : The length of the queue has been written.
    3003  *  EINVAL      : A parameter is invalid.
    3004  */
    3005 int fd_fifo_length ( struct fifo * queue, int * length, int * max);
    3006 int fd_fifo_length_noerr ( struct fifo * queue ); /* no error checking version */
    3007 
    3008 /*
    3009  * FUNCTION:    fd_fifo_getstats
    3010  *
    3011  * PARAMETERS:
    3012  *  queue       : The queue from which to retrieve the timings information.
    3013  *  items       : the total number of items that went through the queue (already pop'd). Always increasing.
    3014  *  total       : Cumulated time all items spent in this queue, including blocking time (always growing, use deltas for monitoring)
    3015  *  blocking    : Cumulated time threads trying to post new items were blocked (queue full).
    3016  *  last        : For the last element retrieved from the queue, how long it take between posting (including blocking) and poping
    3017  * 
    3018  * DESCRIPTION:
    3019  *  Retrieve the timing information associated with a queue, for monitoring purpose.
    3020  *
    3021  * RETURN VALUE:
    3022  *  0           : The statistics have been updated.
    3023  *  EINVAL      : A parameter is invalid.
    3024  */
    3025 int fd_fifo_getstats( struct fifo * queue, long long *items, struct timespec * total, struct timespec * blocking, struct timespec * last);
    3026 
     3018 *
     3019 * DESCRIPTION:
     3020 *  Retrieve the number of elements in a queue, without error checking.
     3021 *
     3022 * RETURN VALUE:
     3023 *  The number of items currently queued.
     3024 */
     3025int fd_fifo_length ( struct fifo * queue );
    30273026
    30283027/*

  • libfdcore/CMakeLists.txt

    r668 r1077  
    1818        events.c
    1919        extensions.c
     20        fifo_stats.c
     21        hooks.c
    2022        dict_base_proto.c
    2123        messages.c

  • libfdproto/fifo.c

    r1067 r1073  
    152152                for (li = queue->list.next; li != &queue->list; li = li->next) {
    153153                        struct fifo_item * fi = (struct fifo_item *)li;
    154                         fd_log_debug("  [%i] item %p in fifo %p, posted:ld.%06ld",
     154                        fd_log_debug("  [%i] item %p in fifo %p, posted:%ld.%06ld",
    155155                                i++, fi->item.o, queue, (long)fi->posted_on.tv_sec,(long)(fi->posted_on.tv_nsec/1000));
    156156                        (*dump_item)(level, fi->item.o);
    … …  
    284284}
    285285
    286 /* Get the length of the queue */
    287 int fd_fifo_length ( struct fifo * queue, int * length, int * max )
    288 {
    289         TRACE_ENTRY( "%p %p %p", queue, length, max );
     286/* Get the information on the queue */
     287int fd_fifo_getstats( struct fifo * queue, int * current_count, int * limit_count, int * highest_count, long long * total_count,
     288                                           struct timespec * total, struct timespec * blocking, struct timespec * last)
     289{
     290        TRACE_ENTRY( "%p %p %p %p %p %p %p %p", queue, current_count, limit_count, highest_count, total_count, total, blocking, last);
    290291       
    291292        /* Check the parameters */
    292         CHECK_PARAMS( CHECK_FIFO( queue ) && length );
     293        CHECK_PARAMS( CHECK_FIFO( queue ) );
    293294       
    294295        /* lock the queue */
    295296        CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
    296297       
    297         /* Retrieve the count */
    298         *length = queue->count;
    299        
    300         if (max)
    301                 *max = queue->max;
     298        if (current_count)
     299                *current_count = queue->count;
     300       
     301        if (limit_count)
     302                *limit_count = queue->max;
     303       
     304        if (highest_count)
     305                *highest_count = queue->highest_ever;
     306       
     307        if (total_count)
     308                *total_count = queue->total_items;
     309       
     310        if (total)
     311                memcpy(total, &queue->total_time, sizeof(struct timespec));
     312       
     313        if (blocking)
     314                memcpy(blocking, &queue->blocking_time, sizeof(struct timespec));
     315       
     316        if (last)
     317                memcpy(last, &queue->last_time, sizeof(struct timespec));
    302318       
    303319        /* Unlock */
    … …  
    308324}
    309325
    310 /* Get the timings */
    311 int fd_fifo_getstats( struct fifo * queue, long long *items, struct timespec * total, struct timespec * blocking, struct timespec * last)
    312 {
    313         TRACE_ENTRY( "%p %p %p %p %p", queue, items, total, blocking, last);
    314        
    315         /* Check the parameters */
    316         CHECK_PARAMS( CHECK_FIFO( queue ) );
    317        
    318         /* lock the queue */
    319         CHECK_POSIX(  pthread_mutex_lock( &queue->mtx )  );
    320        
    321         if (items)
    322                 *items = queue->total_items;
    323        
    324         if (total)
    325                 memcpy(total, &queue->total_time, sizeof(struct timespec));
    326        
    327         if (blocking)
    328                 memcpy(blocking, &queue->blocking_time, sizeof(struct timespec));
    329        
    330         if (last)
    331                 memcpy(last, &queue->last_time, sizeof(struct timespec));
    332        
    333         /* Unlock */
    334         CHECK_POSIX(  pthread_mutex_unlock( &queue->mtx )  );
    335        
    336         /* Done */
    337         return 0;
    338 }
    339 
    340326
    341327/* alternate version with no error checking */
    342 int fd_fifo_length_noerr ( struct fifo * queue )
     328int fd_fifo_length ( struct fifo * queue )
    343329{
    344330        if ( !CHECK_FIFO( queue ) )

  • libfdproto/ostr.c

    r1068 r1070  
    188188int fd_os_validate_DiameterIdentity(char ** id, size_t * inoutsz, int memory)
    189189{
    190 #if defined(DIAMID_IDNA_IGNORE) || defined(DIAMID_IDNA_REJECT)
     190#if !defined(DIAMID_IDNA_IGNORE) && !defined(DIAMID_IDNA_REJECT)
    191191        int gotsize = 0;
    192192#endif /* defined(DIAMID_IDNA_IGNORE) || defined(DIAMID_IDNA_REJECT) */
    … …  
    197197        if (!*inoutsz)
    198198                *inoutsz = strlen(*id);
    199 #if defined(DIAMID_IDNA_IGNORE) || defined(DIAMID_IDNA_REJECT)
     199#if !defined(DIAMID_IDNA_IGNORE) && !defined(DIAMID_IDNA_REJECT)
    200200        else
    201201                gotsize = 1;

  • tests/CMakeLists.txt

    r1031 r1076  
    2626        testdict
    2727        testmesg
     28        testmesg_stress
    2829        testsess
    2930        testdisp

  • tests/testfifo.c

    r1060 r1071  
    217217        {
    218218                struct fifo * queue = NULL;
    219                 int count, max;
    220219                struct msg * msg  = NULL;
     220                int max;
     221                long long count;
    221222               
    222223                /* Create the queue */
    … …  
    224225               
    225226                /* Check the count is 0 */
    226                 CHECK( 0, fd_fifo_length(queue, &count, &max) );
    227                 CHECK( 0, count);
    228                 CHECK( 0, max);
     227                CHECK( 0, fd_fifo_length(queue) );
    229228               
    230229                /* Now enqueue */
    … …  
    237236               
    238237                /* Check the count is 3 */
    239                 CHECK( 0, fd_fifo_length(queue, &count, &max) );
    240                 CHECK( 3, count);
    241                 CHECK( 0, max);
     238                CHECK( 3, fd_fifo_length(queue) );
    242239               
    243240                /* Retrieve the first message using fd_fifo_get */
    244241                CHECK( 0, fd_fifo_get(queue, &msg) );
    245242                CHECK( msg1, msg);
    246                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    247                 CHECK( 2, count);
     243                CHECK( 2, fd_fifo_length(queue) );
    248244               
    249245                /* Retrieve the second message using fd_fifo_timedget */
    … …  
    252248                CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) );
    253249                CHECK( msg2, msg);
    254                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    255                 CHECK( 1, count);
     250                CHECK( 1, fd_fifo_length(queue) );
    256251               
    257252                /* Retrieve the third message using meq_tryget */
    258253                CHECK( 0, fd_fifo_tryget(queue, &msg) );
    259254                CHECK( msg3, msg);
    260                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    261                 CHECK( 0, count);
     255                CHECK( 0, fd_fifo_length(queue) );
    262256               
    263257                /* Check that another meq_tryget does not block */
    264258                CHECK( EWOULDBLOCK, fd_fifo_tryget(queue, &msg) );
    265                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    266                 CHECK( 0, count);
     259                CHECK( 0, fd_fifo_length(queue) );
    267260               
    268261                /* Check the timedget actually timesout */
    … …  
    274267                }
    275268                CHECK( ETIMEDOUT, fd_fifo_timedget(queue, &msg, &ts) );
    276                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    277                 CHECK( 0, count);
     269                CHECK( 0, fd_fifo_length(queue) );
     270               
     271                /* Post & get another message */
     272                msg = msg1;
     273                CHECK( 0, fd_fifo_post(queue, &msg) );
     274                CHECK( 0, fd_fifo_timedget(queue, &msg, &ts) );
     275                CHECK( msg1, msg);             
     276               
     277                /* Check some statistics */
     278                CHECK( 0, fd_fifo_getstats(queue, NULL, NULL, &max, &count, NULL, NULL, NULL) );
     279                CHECK( 3, max );
     280                CHECK( 4, count );     
    278281               
    279282                /* We're done for basic tests */
    … …  
    292295                pthread_t                thr [NBR_THREADS * 2];
    293296                struct dict_object      *dwr_model = NULL;
    294                 int                      count;
    295297                int                      i;
    296298                int                      nbr_threads;
    … …  
    363365               
    364366                /* Check the count of the queue is back to 0 */
    365                 CHECK( 0, fd_fifo_length(queue, &count, NULL) );
    366                 CHECK( 0, count);
     367                CHECK( 0, fd_fifo_length(queue) );
    367368               
    368369                /* Destroy this queue and the messages */
Note: See TracChangeset for help on using the changeset viewer.