Navigation


Changeset 961:d95cd3ca9e8d in freeDiameter


Ignore:
Timestamp:
Mar 7, 2013, 4:09:54 AM (11 years ago)
Author:
Thomas Klausner <tk@giga.or.at>
Branch:
default
Parents:
960:f39fa6cd86e0 (diff), 933:04f590da5821 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Phase:
public
Message:

merge latest 1.1 branch (one commit post 1.1.6)

Files:
22 edited

Legend:

Unmodified
Added
Removed
  • .hgtags

    r932 r961  
    3030226f5957186ae4369467b070aeb61b1c631c9a5c 1.1.5-rc2
    3131ae96ae28f3ddc48b9e2676e9538008eab2b9d60a 1.1.5
     328500947421cb412b5f4f2dfffdf1a35b6fb369e0 FORK
    3233155d45d0653025f45b58ab96b6ba0d5e6fb7fcf8 1.1.6
  • .hgtags

    r942 r961  
    3131ae96ae28f3ddc48b9e2676e9538008eab2b9d60a 1.1.5
    32328500947421cb412b5f4f2dfffdf1a35b6fb369e0 FORK
     33155d45d0653025f45b58ab96b6ba0d5e6fb7fcf8 1.1.6
  • extensions/acl_wl/aw_conf.y

    r928 r961  
    3535
    3636/* Yacc extension's configuration parser.
    37  * See doc/app_test.conf.sample for configuration file format
     37 * See doc/acl_wl.conf.sample for configuration file format
    3838 */
    3939
  • extensions/acl_wl/aw_conf.y

    r957 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2011, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
     
    127127                                fqdn_added++;
    128128                        }
     129                        | conffile LEX_ERROR
     130                        {
     131                                yyerror(&yylloc, conffile, "An error occurred while parsing the configuration file");
     132                                return EINVAL;
     133                        }
    129134                        ;
    130135
  • include/freeDiameter/libfdproto.h

    r928 r961  
    110110
    111111/*
    112  * FUNCTION:    fd_log_debug_fstr
     112 * FUNCTION:    fd_log
    113113 * MACRO:       fd_log_debug
    114114 *
    115115 * PARAMETERS:
    116  *  fstr        : Stream where the text will be sent (default: stdout)
     116 *  loglevel    : Integer, how important the message is
    117117 *  format      : Same format string as in the printf function
    118118 *  ...         : Same list as printf
    119119 *
    120120 * DESCRIPTION:
    121  *  Log internal information for use of developpers only.
     121 * Write information to log.
    122122 * The format and arguments may contain UTF-8 encoded data. The
    123  * output medium (file or console) is expected to support this encoding.
     123 * output medium is expected to support this encoding.
    124124 *
    125125 * RETURN VALUE:
    126126 *  None.
    127127 */
    128 void fd_log_debug_fstr ( FILE * fstr, const char * format, ... );
    129 #define fd_log_debug(format,args...) fd_log_debug_fstr(NULL, format, ## args)
     128void fd_log ( int, const char *, ... );
     129#define fd_log_debug(format,args...) fd_log(FD_LOG_DEBUG, format, ## args)
     130void fd_log_debug_fstr( FILE *, const char *, ... );
    130131
    131132/* these are internal objects of the debug facility,
     
    174175 *
    175176 * PARAMETERS:
    176  *  fstr        : Stream where the text will be sent to (default: stdout)
     177 *  loglevel    : priority of the message
    177178 *  format      : Same format string as in the printf function
    178179 *  va_list     : Argument list
     
    184185 * int          : Success or failure
    185186 */
    186 int fd_log_handler_register ( void (*logger)(const char * format, va_list *args) );
     187int fd_log_handler_register ( void (*logger)(int loglevel, const char * format, va_list args) );
    187188
    188189/*
     
    209210#endif /* ASSERT */
    210211
    211 /* levels definitions */
     212/* log levels definitions */
     213#define FD_LOG_DEBUG 0
     214#define FD_LOG_ERROR 5
     215
     216/* print level definitions */
    212217#define NONE 0  /* Display no debug message */
    213218#define INFO 1  /* Display errors only */
     
    216221#define FCTS 6  /* Display entry parameters of most functions */
    217222#define CALL 9  /* Display calls to most functions (with CHECK macros) */
    218 
    219 /* Increment the debug level for a file at compilation time by defining -DTRACE_LEVEL=FULL for example. */
    220 #ifndef TRACE_LEVEL
    221 #define TRACE_LEVEL NONE
    222 #endif /* TRACE_LEVEL */
    223 
    224 /* The level of the file being compiled. */
    225 static int local_debug_level = TRACE_LEVEL;
    226223
    227224/* A global level, changed by configuration or cmd line for example. Default is INFO (in libfdproto/log.c). */
     
    247244/* Boolean for tracing at a certain level */
    248245#ifdef DEBUG
    249 #define TRACE_BOOL(_level_) ( ((_level_) <= local_debug_level + fd_g_debug_lvl)                                         \
     246#define TRACE_BOOL(_level_) ( ((_level_) <= fd_g_debug_lvl)                                     \
    250247                                || (fd_debug_one_function && !strcmp(fd_debug_one_function, __PRETTY_FUNCTION__))       \
    251248                                || (fd_debug_one_file && !strcmp(fd_debug_one_file, __STRIPPED_FILE__) ) )
    252249#else /* DEBUG */
    253 #define TRACE_BOOL(_level_) ((_level_) <= local_debug_level + fd_g_debug_lvl)
     250#define TRACE_BOOL(_level_) ((_level_) <= fd_g_debug_lvl)
    254251#endif /* DEBUG */
    255252
    256253
     254#define STD_TRACE_FMT_STRING "thread %s in %s@%s:%d: "
    257255/*************
    258256 The general debug macro, each call results in two lines of debug messages (change the macro for more compact output)
     
    262260#define TRACE_DEBUG(level,format,args... ) {                                                                                    \
    263261        if ( TRACE_BOOL(level) ) {                                                                                              \
    264                 char __buf[25];                                                                                                 \
    265262                const char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                 \
    266                 fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
    267                           "\t%s|%*s" format "\n",                                                                               \
    268                                         __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,\
    269                                         (level < FULL)?"@":" ",level, "", ## args);                                             \
     263                fd_log(level, STD_TRACE_FMT_STRING format, \
     264                                        __thn, __PRETTY_FUNCTION__, __FILE__, __LINE__, ## args);                                               \
    270265        }                                                                                                                       \
    271266}
     
    275270        if ( TRACE_BOOL(level) ) {                                                                                                      \
    276271                if (fd_g_debug_lvl > FULL) {                                                                                            \
    277                         char __buf[25];                                                                                                 \
    278272                        const char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                 \
    279                         fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
    280                                   "\t%s|%*s" format "\n",                                                                               \
    281                                                 __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,\
    282                                                 (level < FULL)?"@":" ",level, "", ## args);                                             \
     273                        fd_log(level, STD_TRACE_FMT_STRING format,      \
     274                               __thn, __PRETTY_FUNCTION__, __FILE__, __LINE__, ## args);  \
    283275                } else {                                                                                                                \
    284                         fd_log_debug(format "\n", ## args);                                                                             \
     276                        fd_log(level, format, ## args);           \
    285277                }                                                                                                                       \
    286278        }                                                                                                                               \
     
    316308#define TRACE_DEBUG_BUFFER(level, prefix, buf, bufsz, suffix ) {                                                                \
    317309        if ( TRACE_BOOL(level) ) {                                                                                              \
    318                 char __ts[25];                                                                                                  \
    319310                int __i;                                                                                                        \
    320311                size_t __sz = (size_t)(bufsz);                                                                                  \
    321312                uint8_t * __buf = (uint8_t *)(buf);                                                                             \
    322313                char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                       \
    323                 fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
    324                           "\t%s|%*s" prefix ,                                                                                   \
    325                                         __thn, fd_log_time(NULL, __ts, sizeof(__ts)), __PRETTY_FUNCTION__, __FILE__, __LINE__,  \
    326                                         (level < FULL)?"@":" ",level, "");                                                      \
     314                fd_log(level, STD_TRACE_FMT_STRING prefix,              \
     315                       __thn, __PRETTY_FUNCTION__, __FILE__, __LINE__); \
    327316                for (__i = 0; __i < __sz; __i++) {                                                                              \
    328                         fd_log_debug("%02.2hhx", __buf[__i]);                                                                   \
     317                        fd_log(level, "%02.2hhx", __buf[__i]);         \
    329318                }                                                                                                               \
    330                 fd_log_debug(suffix "\n");                                                                                      \
     319                fd_log(level, suffix);                        \
    331320        }                                                                                                                       \
    332321}
     
    345334
    346335/* Dump one sockaddr Node information */
    347 #define sSA_DUMP_NODE( sa, flag ) {                             \
     336#define sSA_DUMP_NODE( buf, bufsize, sa, flag ) {                \
    348337        sSA * __sa = (sSA *)(sa);                               \
    349338        char __addrbuf[INET6_ADDRSTRLEN];                       \
     
    357346                        flag);                                  \
    358347          if (__rc)                                             \
    359                 fd_log_debug("%s", (char *)gai_strerror(__rc)); \
     348                snprintf(buf, bufsize, "%s", gai_strerror(__rc));       \
    360349          else                                                  \
    361                 fd_log_debug("%s", &__addrbuf[0]);              \
     350                snprintf(buf, bufsize, "%s", &__addrbuf[0]);       \
    362351        } else {                                                \
    363                 fd_log_debug("(NULL / ANY)");                   \
     352                snprintf(buf, bufsize, "(NULL / ANY)");             \
    364353        }                                                       \
    365354}
    366355/* Same but with the port (service) also */
    367 #define sSA_DUMP_NODE_SERV( sa, flag ) {                                \
     356#define sSA_DUMP_NODE_SERV( buf, bufsize, sa, flag ) {                  \
    368357        sSA * __sa = (sSA *)(sa);                                       \
    369358        char __addrbuf[INET6_ADDRSTRLEN];                               \
     
    378367                        flag);                                          \
    379368          if (__rc)                                                     \
    380                 fd_log_debug("%s", (char *)gai_strerror(__rc));         \
     369                snprintf(buf, bufsize, "%s", gai_strerror(__rc));  \
    381370          else                                                          \
    382                 fd_log_debug("[%s]:%s", &__addrbuf[0],&__servbuf[0]);   \
     371                snprintf(buf, bufsize, "[%s]:%s", &__addrbuf[0],&__servbuf[0]); \
    383372        } else {                                                        \
    384                 fd_log_debug("(NULL / ANY)");                           \
     373                snprintf(buf, bufsize,"(NULL / ANY)");         \
    385374        }                                                               \
    386375}
     
    389378#define TRACE_DEBUG_sSA(level, prefix, sa, flags, suffix ) {                                                                            \
    390379        if ( TRACE_BOOL(level) ) {                                                                                              \
    391                 char __buf[25];                                                                                                 \
     380                char buf[1024]; \
    392381                char * __thn = ((char *)pthread_getspecific(fd_log_thname) ?: "unnamed");                                       \
    393                 fd_log_debug("\t | tid:%-20s\t%s\tin %s@%s:%d\n"                                                                \
    394                           "\t%s|%*s" prefix ,                                                                                   \
    395                                         __thn, fd_log_time(NULL, __buf, sizeof(__buf)), __PRETTY_FUNCTION__, __FILE__, __LINE__,\
    396                                         (level < FULL)?"@":" ",level, "");                                                      \
    397                 sSA_DUMP_NODE_SERV( sa, flags );                                                                                \
    398                 fd_log_debug(suffix "\n");                                                                                      \
     382                sSA_DUMP_NODE_SERV(buf, sizeof(buf), sa, flags );       \
     383                fd_log(level, STD_TRACE_FMT_STRING "%s%s%s",              \
     384                       __thn, __PRETTY_FUNCTION__, __FILE__, __LINE__, prefix, buf, suffix); \
    399385        }                                                                                                                       \
    400386}
     
    418404#define TRACE_DEBUG_sSA(level, prefix, sa, flags, suffix )
    419405#define TRACE_DEBUG_ERROR(format,args... ) {    \
    420         fd_log_debug(format "\n", ## args);     \
     406        fd_log(FD_LOG_ERROR, format, ## args);  \
    421407}
    422408#endif /* STRIP_DEBUG_CODE */
     
    14451431         
    14461432         ret = fd_dict_search ( dict, DICT_AVP, AVP_BY_NAME_AND_VENDOR, &avpvendorboolean, &avp_sampleboolean, ENOENT);
     1433
     1434         -- this would also work, but be slower, because it has to search all vendor dictionaries --
     1435         ret = fd_dict_search ( dict, DICT_AVP, AVP_BY_NAME_ALL_VENDORS, "Sample-Boolean", &avp_sampleboolean, ENOENT);
    14471436         
    14481437 }
  • include/freeDiameter/libfdproto.h

    r958 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdcore/cnxctx.c

    r928 r961  
    229229       
    230230        if (TRACE_BOOL(INFO)) {
    231                 fd_log_debug("%s : accepted new client [", fd_cnx_getid(serv));
    232                 sSA_DUMP_NODE( &ss, NI_NUMERICHOST );
    233                 fd_log_debug("].\n");
     231                char buf[1024];
     232                sSA_DUMP_NODE( buf, sizeof(buf), &ss, NI_NUMERICHOST );
     233                fd_log_debug("%s : accepted new client [%s].\n", fd_cnx_getid(serv), buf);
    234234        }
    235235       
     
    312312       
    313313        if (TRACE_BOOL(INFO)) {
    314                 fd_log_debug("Connection established to server '");
    315                 sSA_DUMP_NODE_SERV( sa, NI_NUMERICSERV);
    316                 fd_log_debug("' (TCP:%d).\n", sock);
     314                char buf[1024];
     315                sSA_DUMP_NODE_SERV( buf, sizeof(buf), sa, NI_NUMERICSERV);
     316                fd_log_debug("Connection established to server '%s' (TCP:%d).\n", buf, sock);
    317317        }
    318318       
     
    404404       
    405405        if (TRACE_BOOL(INFO)) {
    406                 fd_log_debug("Connection established to server '");
    407                 sSA_DUMP_NODE_SERV( &primary, NI_NUMERICSERV);
    408                 fd_log_debug("' (SCTP:%d, %d/%d streams).\n", sock, cnx->cc_sctp_para.str_in, cnx->cc_sctp_para.str_out);
     406                char buf[1024];
     407                sSA_DUMP_NODE_SERV( buf, sizeof(buf), &primary, NI_NUMERICSERV);
     408                fd_log_debug("Connection established to server '%s' (SCTP:%d, %d/%d streams).\n", buf, sock, cnx->cc_sctp_para.str_in, cnx->cc_sctp_para.str_out);
    409409        }
    410410       
  • libfdcore/cnxctx.c

    r946 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
     
    561561                        continue;
    562562               
     563                if (cur->ifa_addr == NULL) /* may happen with ppp interfaces */
     564                        continue;
     565               
    563566                if (fd_g_config->cnf_flags.no_ip4 && (cur->ifa_addr->sa_family == AF_INET))
    564567                        continue;
  • libfdcore/core.c

    r928 r961  
    226226
    227227/* Parse the freeDiameter.conf configuration file, load the extensions */
    228 int fd_core_parseconf(char * conffile)
     228int fd_core_parseconf(const char * conffile)
    229229{
    230230        TRACE_ENTRY("%p", conffile);
  • libfdcore/core.c

    r947 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdcore/fdd.l

    r950 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2011, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
     
    6767/* %option noinput ? */
    6868#define YY_NO_INPUT
     69
     70/* Additional for files inclusion */
     71#include <glob.h>
     72#include <string.h>
     73
     74#define MAX_NESTED_CONF_FILES   5
     75
     76struct nested_conffiles_t {
     77        YY_BUFFER_STATE parent_level_state;
     78        glob_t filelist;
     79        int current_file;
     80} nested_conffiles[MAX_NESTED_CONF_FILES];
     81
     82int current_nested_level = 0;
     83
     84int globerrfct(const char *epath, int eerrno)
     85{
     86        TRACE_DEBUG_ERROR("Failed to scan %s: %s\n", epath, strerror(eerrno));
     87        return 1;
     88}
     89
    6990%}
    7091
     
    7394%option nounput
    7495
     96%x in_include
     97
    7598/* Quoted string. Multilines do not match. */
    7699qstring         \"[^\"\n]*\"
    77100
    78101%%
    79 
    80102<*>\n                   {
    81103                                /* Update the line count */
     
    87109<*>([[:space:]]{-}[\n])+        ; /* Eat all spaces, not new lines */
    88110<*>#.*$                 ; /* Eat all comments */
     111
     112
     113include         BEGIN(in_include);
     114        /* Following an "include" keyword */
     115<in_include>{
     116{qstring}       { /* Name of the file to include. This is directly sent to glob. */
     117                        int globerror=0;
     118                        char * buf = strdup(yytext+1);
     119                        if (buf[yyleng-2] != '"')
     120                        {
     121                                TRACE_DEBUG_ERROR("Unterminated string: %s\n", yytext);
     122                                return LEX_ERROR;
     123                        }
     124                        buf[yyleng-2] = '\0';
     125
     126                        if (current_nested_level >= MAX_NESTED_CONF_FILES)
     127                        {
     128                                TRACE_DEBUG_ERROR("Too many recursion levels in configuration files includes\n");
     129                                return LEX_ERROR;
     130                        }
     131
     132                        /* glob the include */
     133                        globerror = glob(buf, GLOB_ERR, globerrfct, &nested_conffiles[current_nested_level].filelist);
     134
     135                        if (globerror == GLOB_NOSPACE)
     136                        {
     137                                TRACE_DEBUG_ERROR("Not enough memory to parse include directive.\n");
     138                                return LEX_ERROR;
     139                        }
     140                        if (globerror == GLOB_ABORTED)
     141                        {
     142                                TRACE_DEBUG_ERROR("An error was encountered in include directive.\n");
     143                                return LEX_ERROR;
     144                        }
     145                        if (globerror == GLOB_NOMATCH)
     146                        {
     147                                globfree(&nested_conffiles[current_nested_level].filelist);
     148                                goto nomatch;
     149                        }
     150                        if (globerror)
     151                        {
     152                                TRACE_DEBUG_ERROR("Unexpected error in glob (%d).\n", globerror);
     153                                return LEX_ERROR;
     154                        }
     155
     156                        /* We have a list of files to include. */
     157
     158                        /* save the current buffer for returning when this include has been parsed */
     159                        nested_conffiles[current_nested_level].parent_level_state = YY_CURRENT_BUFFER;
     160
     161                        /* Start with the first match */
     162                        nested_conffiles[current_nested_level].current_file = 0;
     163
     164                        yyin = fopen( nested_conffiles[current_nested_level].filelist.gl_pathv[0], "r" );
     165
     166                        if ( ! yyin )
     167                        {
     168                                TRACE_DEBUG_ERROR("Error in %s: %s", nested_conffiles[current_nested_level].filelist.gl_pathv[0], strerror(errno));
     169                                return LEX_ERROR;
     170                        }
     171
     172                        yy_switch_to_buffer(yy_create_buffer( yyin, YY_BUF_SIZE ));
     173
     174                        /* In case of recursive includes */
     175                        current_nested_level++;
     176
     177nomatch:
     178                        BEGIN(INITIAL);
     179                }
     180}
     181
     182<<EOF>> {
     183                        if (current_nested_level == 0)
     184                        {
     185                              /* We are at the end of parsing */
     186                              yyterminate();
     187                        }
     188
     189                        /* Otherwise we are doing an include statement */
     190                        --current_nested_level;
     191                        yy_delete_buffer(YY_CURRENT_BUFFER);
     192
     193                        /* Go to next file, if any */
     194                        nested_conffiles[current_nested_level].current_file++;
     195                        if ( nested_conffiles[current_nested_level].filelist.gl_pathv[nested_conffiles[current_nested_level].current_file] == NULL )
     196                        {
     197                                /* We have finished with this list of includes */
     198                                globfree(&nested_conffiles[current_nested_level].filelist);
     199                                yy_switch_to_buffer(nested_conffiles[current_nested_level].parent_level_state);
     200                        }
     201                        else
     202                        {
     203                                /* Proceed to next included file */
     204                                yyin = fopen( nested_conffiles[current_nested_level].filelist.gl_pathv[nested_conffiles[current_nested_level].current_file], "r" );
     205
     206                                if ( ! yyin )
     207                                {
     208                                        TRACE_DEBUG_ERROR("Error in %s: %s", nested_conffiles[current_nested_level].filelist.gl_pathv[nested_conffiles[current_nested_level].current_file], strerror(errno));
     209                                        return LEX_ERROR;
     210                                }
     211
     212                                yy_switch_to_buffer(yy_create_buffer( yyin, YY_BUF_SIZE ));
     213
     214                                /* In case of recursive includes */
     215                                current_nested_level++;
     216                        }
     217
     218}
    89219
    90220{qstring}               {
  • libfdcore/fdd.y

    r950 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdcore/peers.c

    r933 r961  
    9191
    9292/* Add a new peer entry */
    93 int fd_peer_add ( struct peer_info * info, char * orig_dbg, void (*cb)(struct peer_info *, void *), void * cb_data )
     93int fd_peer_add ( struct peer_info * info, const char * orig_dbg, void (*cb)(struct peer_info *, void *), void * cb_data )
    9494{
    9595        struct fd_peer *p = NULL;
  • libfdcore/peers.c

    r950 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
     
    515515                peer->p_flags.pf_delete = 1;
    516516               
     517#ifndef DISABLE_PEER_EXPIRY
    517518                /* Set this peer to expire on inactivity */
    518519                peer->p_hdr.info.config.pic_flags.exp   = PI_EXP_INACTIVE;
    519520                peer->p_hdr.info.config.pic_lft         = 3600; /* 1 hour without any message
    520521                -- RFC3539 states that this must not be inferior to BRINGDOWN_INTERVAL = 5 minutes */
     522               
    521523                CHECK_FCT_DO( ret = fd_p_expi_update( peer ), goto out );
    522 
     524#endif /* DISABLE_PEER_EXPIRY */
    523525               
    524526                /* Insert the new peer in the list (the PSM will take care of setting the expiry after validation) */
  • libfdcore/sctp.c

    r928 r961  
    909909        }
    910910        if (TRACE_BOOL(SCTP_LEVEL)) {
     911                char buf[1024];
     912                sSA_DUMP_NODE_SERV(buf, sizeof(buf), &status.sstat_primary.spinfo_address, NI_NUMERICHOST | NI_NUMERICSERV );
    911913                fd_log_debug( "SCTP_STATUS : sstat_state                  : %i\n" , status.sstat_state);
    912914                fd_log_debug( "              sstat_rwnd                   : %u\n" , status.sstat_rwnd);
     
    916918                fd_log_debug( "              sstat_outstrms               : %hu\n", status.sstat_outstrms);
    917919                fd_log_debug( "              sstat_fragmentation_point    : %u\n" , status.sstat_fragmentation_point);
    918                 fd_log_debug( "              sstat_primary.spinfo_address : ");
    919                 sSA_DUMP_NODE_SERV(&status.sstat_primary.spinfo_address, NI_NUMERICHOST | NI_NUMERICSERV );
    920                 fd_log_debug( "\n" );
     920                fd_log_debug( "              sstat_primary.spinfo_address : %s\n" , buf);
    921921                fd_log_debug( "              sstat_primary.spinfo_state   : %d\n" , status.sstat_primary.spinfo_state);
    922922                fd_log_debug( "              sstat_primary.spinfo_cwnd    : %u\n" , status.sstat_primary.spinfo_cwnd);
  • libfdcore/sctp.c

    r950 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdproto/dictionary.c

    r928 r961  
    12781278                _OBINFO(obj).dump_data(&obj->data);
    12791279       
    1280         fd_log_debug("\n");
    1281        
    12821280        if (depth) {
    12831281                int i;
     
    14701468       
    14711469        /* Done! */
    1472         CHECK_FCT( dump_add_str(outstr, offset, outlen, "\n") );
    14731470        return 0;
    14741471}
     
    17251722                switch (type) {
    17261723                        case DICT_VENDOR:
     1724                                TRACE_DEBUG(FULL, "Vendor %s already in dictionary", new->data.vendor.vendor_name);
    17271725                                /* if we are here, it means the two vendors id are identical */
    17281726                                if (fd_os_cmp(locref->data.vendor.vendor_name, locref->datastr_len,
     
    17361734
    17371735                        case DICT_APPLICATION:
     1736                                TRACE_DEBUG(FULL, "Application %s already in dictionary", new->data.application.application_name);
    17381737                                /* got same id */
    17391738                                if (fd_os_cmp(locref->data.application.application_name, locref->datastr_len,
     
    17461745
    17471746                        case DICT_TYPE:
     1747                                TRACE_DEBUG(FULL, "Type %s already in dictionary", new->data.type.type_name);
    17481748                                /* got same name */
    17491749                                if (locref->data.type.type_base != new->data.type.type_base) {
     
    17681768
    17691769                        case DICT_ENUMVAL:
     1770                                TRACE_DEBUG(FULL, "Enum %s already in dictionary", new->data.enumval.enum_name);
    17701771                                /* got either same name or same value. We check that both are true */
    17711772                                if (order_enum_by_name(locref, new)) {
     
    17811782
    17821783                        case DICT_AVP:
     1784                                TRACE_DEBUG(FULL, "AVP %s already in dictionary", new->data.avp.avp_name);
    17831785                                /* got either same name or code */
    17841786                                if (order_avp_by_code(locref, new)) {
     
    18101812
    18111813                        case DICT_COMMAND:
     1814                                TRACE_DEBUG(FULL, "Command %s already in dictionary", new->data.cmd.cmd_name);
    18121815                                /* We got either same name, or same code + R flag */
    18131816                                if (order_cmd_by_name(locref, new)) {
  • libfdproto/dictionary.c

    r952 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdproto/log.c

    r928 r961  
    4444int fd_g_debug_lvl = INFO;
    4545
     46static void fd_internal_logger( int, const char *, va_list );
     47
    4648/* These may be used to pass specific debug requests via the command-line parameters */
    4749char * fd_debug_one_function = NULL;
     
    5355
    5456/* Allow passing of the log and debug information from base stack to extensions */
    55 void (*fd_external_logger)( const char * format, va_list *args ) = NULL;
     57void (*fd_logger)( int loglevel, const char * format, va_list args ) = fd_internal_logger;
    5658
    57 /* Register an dexternal call back for tracing and debug */
    58 int fd_log_handler_register( void (*logger)(const char * format, va_list *args))
     59/* Register an external call back for tracing and debug */
     60int fd_log_handler_register( void (*logger)(int loglevel, const char * format, va_list args) )
    5961{
    6062        CHECK_PARAMS( logger );
    6163
    62         if ( fd_external_logger != NULL )
     64        if ( fd_logger != fd_internal_logger )
    6365        {
    6466               return EALREADY; /* only one registration allowed */
     
    6668        else
    6769        {
    68                fd_external_logger = logger;
     70               fd_logger = logger;
    6971        }
     72
    7073        return 0;
    7174}
     
    7477int fd_log_handler_unregister ( void )
    7578{
    76         fd_external_logger = NULL;
     79        fd_logger = fd_internal_logger;
    7780        return 0; /* Successfull in all cases. */
    7881}
     
    8386}
    8487
     88
     89static void fd_internal_logger( int loglevel, const char *format, va_list ap )
     90{
     91    char buf[25];
     92    FILE *fstr = fd_g_debug_fstr ?: stdout;
     93
     94    /* logging has been decided by macros outside already */
     95
     96    /* add timestamp */
     97    fprintf(fd_g_debug_fstr, "%s\t", fd_log_time(NULL, buf, sizeof(buf)));
     98    vfprintf(fd_g_debug_fstr, format, ap);
     99    if (format && (format[strlen(format)-1] != '\n')) {
     100        fprintf(fd_g_debug_fstr, "\n");
     101    }
     102    fflush(fd_g_debug_fstr);
     103}
     104
    85105/* Log a debug message */
    86 void fd_log_debug_fstr ( FILE * fstr, const char * format, ... )
     106void fd_log ( int loglevel, const char * format, ... )
    87107{
    88108        va_list ap;
     
    93113       
    94114        va_start(ap, format);
    95         if ( fd_external_logger != NULL )
    96         {
    97                fd_external_logger( format, &ap );
    98         }
    99         else
    100         {
    101                vfprintf( fstr ?: stdout, format, ap);
    102                fflush(fstr ?: stdout);
    103         }
     115        fd_logger(loglevel, format, ap);
    104116        va_end(ap);
    105117
     
    107119       
    108120        (void)pthread_mutex_unlock(&fd_log_lock);
     121}
     122
     123/* Log debug message to file. */
     124void fd_log_debug_fstr( FILE * fstr, const char * format, ... )
     125{
     126        va_list ap;
     127       
     128        va_start(ap, format);
     129        vfprintf(fstr, format, ap);
     130        va_end(ap);
    109131}
    110132
  • libfdproto/log.c

    r945 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
  • libfdproto/messages.c

    r928 r961  
    683683        struct tm tm;
    684684       
    685         CHECK_FCT( dump_add_str(outstr, offset, outlen, "%*sMSG: %p\n", INOBJHDRVAL, msg) );
     685        CHECK_FCT( dump_add_str(outstr, offset, outlen, "%*sMSG: %p|", INOBJHDRVAL, msg) );
    686686       
    687687        if (!CHECK_MSG(msg)) {
    688                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!\n", INOBJHDRVAL) );
     688                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!", INOBJHDRVAL) );
    689689                return 0;
    690690        }
     
    693693                tsoffset += strftime(buftime + tsoffset, sizeof(buftime) - tsoffset, "%D,%T", localtime_r( &msg->msg_ts_rcv.tv_sec , &tm ));
    694694                tsoffset += snprintf(buftime + tsoffset, sizeof(buftime) - tsoffset, ".%6.6ld", msg->msg_ts_rcv.tv_nsec / 1000);
    695                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "Received: %s\n", INOBJHDRVAL, buftime) );
     695                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "Received: %s|", INOBJHDRVAL, buftime) );
    696696        }
    697697        if ((msg->msg_ts_sent.tv_sec != 0) || (msg->msg_ts_sent.tv_nsec != 0)) {
    698698                tsoffset += strftime(buftime + tsoffset, sizeof(buftime) - tsoffset, "%D,%T", localtime_r( &msg->msg_ts_sent.tv_sec , &tm ));
    699699                tsoffset += snprintf(buftime + tsoffset, sizeof(buftime) - tsoffset, ".%6.6ld", msg->msg_ts_sent.tv_nsec / 1000);
    700                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "Sent    : %s\n", INOBJHDRVAL, buftime) );
     700                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "Sent    : %s|", INOBJHDRVAL, buftime) );
    701701        }
    702702       
    703703        if (!msg->msg_model) {
    704704               
    705                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model)\n", INOBJHDRVAL) );
     705                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model)|", INOBJHDRVAL) );
    706706               
    707707        } else {
     
    711711                ret = fd_dict_gettype(msg->msg_model, &dicttype);
    712712                if (ret || (dicttype != DICT_COMMAND)) {
    713                         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype) );
     713                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)|", INOBJHDRVAL, ret, dicttype) );
    714714                        goto public;
    715715                }
    716716                ret = fd_dict_getval(msg->msg_model, &dictdata);
    717717                if (ret != 0) {
    718                         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret)) );
     718                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)|", INOBJHDRVAL, strerror(ret)) );
    719719                        goto public;
    720720                }
    721                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %u \"%s\"\n", INOBJHDRVAL,
     721                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_CMDFL_str "/" DUMP_CMDFL_str ", %u \"%s\"|", INOBJHDRVAL,
    722722                        DUMP_CMDFL_val(dictdata.cmd_flag_val), DUMP_CMDFL_val(dictdata.cmd_flag_mask), dictdata.cmd_code, dictdata.cmd_name) );
    723723        }
    724724public:
    725         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: V:%d L:%d fl:" DUMP_CMDFL_str " CC:%u A:%d hi:%x ei:%x\n", INOBJHDRVAL,
     725        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: V:%d L:%d fl:" DUMP_CMDFL_str " CC:%u A:%d hi:%x ei:%x|", INOBJHDRVAL,
    726726                msg->msg_public.msg_version,
    727727                msg->msg_public.msg_length,
     
    732732                msg->msg_public.msg_eteid
    733733                ) );
    734         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: rwb:%p rt:%d cb:%p(%p) qry:%p asso:%d sess:%p src:%s(%zd)\n",
     734        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: rwb:%p rt:%d cb:%p(%p) qry:%p asso:%d sess:%p src:%s(%zd)|",
    735735                        INOBJHDRVAL, msg->msg_rawbuffer, msg->msg_routable, msg->msg_cb.fct, msg->msg_cb.data, msg->msg_query, msg->msg_associated, msg->msg_sess, msg->msg_src_id?:"(nil)", msg->msg_src_id_len) );
    736736        return 0;
     
    743743       
    744744        if (!CHECK_AVP(avp)) {
    745                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!\n", INOBJHDRVAL) );
     745                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "INVALID!", INOBJHDRVAL) );
    746746                return 0;
    747747        }
     
    749749        if (!avp->avp_model) {
    750750               
    751                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model resolved)\n", INOBJHDRVAL) );
     751                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(no model resolved)|", INOBJHDRVAL) );
    752752               
    753753        } else {
     
    757757                ret = fd_dict_gettype(avp->avp_model, &dicttype);
    758758                if (ret || (dicttype != DICT_AVP)) {
    759                         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)\n", INOBJHDRVAL, ret, dicttype) );
     759                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(invalid model: %d %d)|", INOBJHDRVAL, ret, dicttype) );
    760760                        goto public;
    761761                }
    762762                ret = fd_dict_getval(avp->avp_model, &dictdata);
    763763                if (ret != 0) {
    764                         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)\n", INOBJHDRVAL, strerror(ret)) );
     764                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(error getting model data: %s)|", INOBJHDRVAL, strerror(ret)) );
    765765                        goto public;
    766766                }
    767                 CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %u \"%s\"\n", INOBJHDRVAL,
     767                CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "model : v/m:" DUMP_AVPFL_str "/" DUMP_AVPFL_str ", %12s, %u \"%s\"|", INOBJHDRVAL,
    768768                        DUMP_AVPFL_val(dictdata.avp_flag_val),
    769769                        DUMP_AVPFL_val(dictdata.avp_flag_mask),
     
    773773        }
    774774public:
    775         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: C:%u fl:" DUMP_AVPFL_str " L:%d V:%u  data:@%p\n", INOBJHDRVAL,
     775        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "public: C:%u fl:" DUMP_AVPFL_str " L:%d V:%u  data:@%p|", INOBJHDRVAL,
    776776                avp->avp_public.avp_code,
    777777                DUMP_AVPFL_val(avp->avp_public.avp_flags),
     
    783783        if (avp->avp_public.avp_value) {
    784784                if (!avp->avp_model) {
    785                         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(data set but no model: ERROR)\n", INOBJHDRVAL) );
     785                        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "(data set but no model: ERROR)|", INOBJHDRVAL) );
    786786                } else {
    787787                        CHECK_FCT( fd_dict_dump_avp_value(avp->avp_public.avp_value, avp->avp_model, indent, outstr, offset, outlen) );
     
    789789        }
    790790
    791         CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: src:%p mf:%d raw:%p(%d)\n", INOBJHDRVAL, avp->avp_source, avp->avp_mustfreeos, avp->avp_rawdata, avp->avp_rawlen) );
     791        CHECK_FCT( dump_add_str(outstr, offset, outlen, INOBJHDR "intern: src:%p mf:%d raw:%p(%d)|", INOBJHDRVAL, avp->avp_source, avp->avp_mustfreeos, avp->avp_rawdata, avp->avp_rawlen) );
    792792        return 0;
    793793}
     
    880880        /* now really output this in one shot, so it is not interrupted */
    881881        TRACE_DEBUG(level, "------ Dumping object %p (w)-------", obj);
    882         fd_log_debug_fstr(fd_g_debug_fstr, "%s", outstr);
     882        TRACE_DEBUG(level, "%s", outstr);
    883883        TRACE_DEBUG(level, "------ /end of object %p -------", obj);
    884884       
     
    896896                        fd_log_debug_fstr(fd_g_debug_fstr, "Error while dumping %p\n", obj) );
    897897        TRACE_DEBUG(level, "------ Dumping object %p (s)-------", obj);
    898         fd_log_debug_fstr(fd_g_debug_fstr, "%s", outstr);
     898        TRACE_DEBUG(level, "%s", outstr);
    899899        TRACE_DEBUG(level, "------ /end of object %p -------", obj);
    900900        free(outstr);
  • libfdproto/messages.c

    r951 r961  
    33* Author: Sebastien Decugis <sdecugis@freediameter.net>                                                  *
    44*                                                                                                        *
    5 * Copyright (c) 2012, WIDE Project and NICT                                                              *
     5* Copyright (c) 2013, WIDE Project and NICT                                                              *
    66* All rights reserved.                                                                                   *
    77*                                                                                                        *
Note: See TracChangeset for help on using the changeset viewer.