Changeset 717:571b3abaa5df in freeDiameter

Timestamp:

Feb 18, 2011, 2:50:37 PM (13 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Support for Diameter Redirects through rt_redirect.fdx extension (EXPERIMENTAL)

Files:

• contrib/debian/changelog (modified) (1 diff)
• extensions/CMakeLists.txt (modified) (1 diff)
• extensions/app_radgw/rgw_clients.c (modified) (3 diffs)
• extensions/app_radgw/rgwx_sip.c (modified) (1 diff)
• extensions/rt_redirect/CMakeLists.txt (added)
• extensions/rt_redirect/redir_entries.c (added)
• extensions/rt_redirect/redir_expiry.c (added)
• extensions/rt_redirect/redir_fwd.c (added)
• extensions/rt_redirect/redir_out.c (added)
• extensions/rt_redirect/rt_redir.c (added)
• extensions/rt_redirect/rt_redir.h (added)
• include/freeDiameter/libfdcore.h (modified) (2 diffs)
• include/freeDiameter/libfdproto.h (modified) (2 diffs)
• libfdcore/routing_dispatch.c (modified) (2 diffs)
• libfdproto/ostr.c (modified) (5 diffs)
• libfdproto/rt_data.c (modified) (1 diff)
• tests/testostr.c (modified) (2 diffs)

contrib/debian/changelog

@@ -20 +20 @@
   * Improved peer state machine algorithm to counter SCTP multistream race 
     condition.
+  * New extension rt_redirect.fdx that handles the Diameter Redirect errors.
 
- -- Sebastien Decugis <sdecugis@nict.go.jp>  Mon, 07 Feb 2011 17:24:20 +0900
+ -- Sebastien Decugis <sdecugis@nict.go.jp>  Fri, 18 Feb 2011 14:47:24 +0900
 
 freediameter (1.0.4) UNRELEASED; urgency=low

extensions/CMakeLists.txt

@@ -62 +62 @@
 # Routing extensions
 
-FD_EXTENSION_SUBDIR(rt_default "Configurable routing rules for freeDiameter"                 ON)
-FD_EXTENSION_SUBDIR(rt_ereg    "Configurable routing based on regexp matching of AVP values" OFF)
+FD_EXTENSION_SUBDIR(rt_default   "Configurable routing rules for freeDiameter"                  ON)
+FD_EXTENSION_SUBDIR(rt_redirect  "Handling of Diameter Redirect messages"                       ON)
+FD_EXTENSION_SUBDIR(rt_ereg      "Configurable routing based on regexp matching of AVP values" OFF)
 
 

extensions/app_radgw/rgw_clients.c

@@ -215 +215 @@
         struct rgw_client *tmp = NULL;
         DiamId_t fqdn;
-        size_t fqdn_len;
+        size_t fqdn_len = 0;
         int ret, i;
         int loc = 0;
@@ -550 +550 @@
         struct radius_attr_hdr *nas_ip = NULL, *nas_ip6 = NULL, *nas_id = NULL;
         size_t nas_id_len;
-        char * oh_str = NULL; size_t oh_strlen; int oh_free = 0;
-        char * or_str = NULL; size_t or_strlen;
-        char * rr_str = NULL; size_t rr_strlen;
+        char * oh_str = NULL; size_t oh_strlen = 0; int oh_free = 0;
+        char * or_str = NULL; size_t or_strlen = 0;
+        char * rr_str = NULL; size_t rr_strlen = 0;
         char buf[REVERSE_DNS_SIZE_MAX]; /* to store DNS lookups results */
         
@@ -789 +789 @@
                                         }
                                         oh_str = &buf[0]; /* The canonname resolved */
+                                        oh_strlen = 0;
                                         CHECK_FCT_DO( ret = fd_os_validate_DiameterIdentity(&oh_str, &oh_strlen, 1),
                                                 {

extensions/app_radgw/rgwx_sip.c

@@ -595 +595 @@
                                 //We extract Realm from Digest_URI
                                 DiamId_t realm=NULL;
-                                size_t realm_len;
+                                size_t realm_len = 0;
                                 os0_t temp;
                                 

include/freeDiameter/libfdcore.h

@@ -658 +658 @@
 enum fd_rt_out_score {
         FD_SCORE_NO_DELIVERY     = -70, /* We should not send this message to this candidate */
+        FD_SCORE_SENT_REDIRECT   = -60, /* If this peer previously sent a Redirect indication that applies to this message */
         FD_SCORE_INI             =  -2, /* All candidates are initialized with this value */
         FD_SCORE_LOAD_BALANCE    =   1, /* Use this to differentiate between several peers with the same score */
@@ -669 +670 @@
         FD_SCORE_REDIR_USER      =  45, /* If there is a redirect rule with ALL_USER for these message and peer */
         FD_SCORE_REDIR_SESSION   =  50, /* If there is a redirect rule with ALL_SESSION for these message and peer */
+        FD_SCORE_REDIR_ONCE      =  55, /* If there is a redirect rule with DONT_CACHE for these message and peer */
         FD_SCORE_FINALDEST       = 100  /* If the peer is the final recipient of the message (i.e. matching Destination-Host), it receives a big score. */
 };

include/freeDiameter/libfdproto.h

@@ -607 +607 @@
 int fd_os_is_valid_DiameterIdentity(uint8_t * os, size_t ossz);
 
-/* This checks a string is a valid DiameterIdentity and applies IDNA transformations otherwise (xn--...) */
-int fd_os_validate_DiameterIdentity(char ** id, size_t * outsz, int memory /* 0: *id can be realloc'd. 1: *id must be malloc'd on output (was static) */ );
+/* The following function validates a string as a Diameter Identity or applies the IDNA transformation on it 
+ if *inoutsz is != 0 on entry, *id may not be \0-terminated.
+ memory has the following meaning: 0: *id can be realloc'd. 1: *id must be malloc'd on output (was static)
+*/
+int fd_os_validate_DiameterIdentity(char ** id, size_t * inoutsz, int memory);
 
 /* Create an order relationship for binary strings (not needed to be \0 terminated). 
@@ -627 +630 @@
 #define fd_os_almostcasecmp(_o1, _l1, _o2, _l2)  fd_os_almostcasecmp_int((os0_t)(_o1), _l1, (os0_t)(_o2), _l2)
 
+/* Analyze a DiameterURI and return its components. 
+  Return EINVAL if the URI is not valid. 
+  *diamid is malloc'd on function return and must be freed (it is processed by fd_os_validate_DiameterIdentity).
+  *secure is 0 (no security) or 1 (security enabled) on return.
+  *port is 0 (default) or a value in host byte order on return.
+  *transport is 0 (default) or IPPROTO_* on return.
+  *proto is 0 (default) or 'd' (diameter), 'r' (radius), or 't' (tacacs+) on return.
+  */
+int fd_os_parse_DiameterURI(uint8_t * uri, size_t urisz, DiamId_t * diamid, size_t * diamidlen, int * secure, uint16_t * port, int * transport, char *proto);
 
 /*============================================================*/

libfdcore/routing_dispatch.c

@@ -722 +722 @@
                         return 0;
                 }
-
+                
                 /* From that point, for answers, we will call the registered callbacks, then pass it to the dispatch module or forward it */
         }
@@ -1106 +1106 @@
         CHECK_FCT( fd_rt_out_register( score_destination_avp, NULL, 10, NULL ) );
         
-        TODO("built-in callbacks for Redirect messages?");
-        
         return 0;
 }

libfdproto/ostr.c

@@ -167 +167 @@
 }
 
-/* The following function validates a string as a Diameter Identity or applies the IDNA transformation on it */
-int fd_os_validate_DiameterIdentity(char ** id, size_t * outsz, int memory /* 0: *id can be realloc'd. 1: *id must be malloc'd on output (was static) */)
-{
-        TRACE_ENTRY("%p %p", id, outsz);
-        
-        *outsz = strlen(*id);
+/* The following function validates a string as a Diameter Identity or applies the IDNA transformation on it 
+ if *inoutsz is != 0 on entry, *id may not be \0-terminated.
+ memory has the following meaning: 0: *id can be realloc'd. 1: *id must be malloc'd on output (was static)
+*/
+int fd_os_validate_DiameterIdentity(char ** id, size_t * inoutsz, int memory)
+{
+        int gotsize = 0;
+        
+        TRACE_ENTRY("%p %p", id, inoutsz);
+        CHECK_PARAMS( id && *id && inoutsz );
+        
+        if (!*inoutsz)
+                *inoutsz = strlen(*id);
+        else
+                gotsize = 1;
         
 #ifndef DIAMID_IDNA_IGNORE
         
-        if (!fd_os_is_valid_DiameterIdentity((os0_t)*id, *outsz)) {
+        if (!fd_os_is_valid_DiameterIdentity((os0_t)*id, *inoutsz)) {
         
 #ifdef DIAMID_IDNA_REJECT
@@ -188 +197 @@
                 char *processed;
                 int ret;
+                
+                if (gotsize) { /* make it \0-terminated */
+                        if (memory) {
+                                CHECK_MALLOC( *id = os0dup(*id, *inoutsz) );
+                                memory = 0;
+                        } else {
+                                CHECK_MALLOC( *id = realloc(*id, *inoutsz + 1) );
+                                (*id)[*inoutsz] = '0';
+                        }
+                }
                 
                 ret = idna_to_ascii_8z ( *id, &processed, IDNA_USE_STD3_ASCII_RULES );
@@ -195 +214 @@
                                 free(*id);
                         *id = processed;
-                        *outsz = strlen(processed);
+                        *inoutsz = strlen(processed);
                         /* Done! */
                 } else {
@@ -207 +226 @@
         {
                 if (memory == 1) {
-                        CHECK_MALLOC( *id = os0dup(*id, *outsz) );
+                        CHECK_MALLOC( *id = os0dup(*id, *inoutsz) );
                 }
         }
@@ -213 +232 @@
 }
 
+/* Analyze a DiameterURI and return its components. 
+  Return EINVAL if the URI is not valid. 
+  *diamid is malloc'd on function return and must be freed (it is processed by fd_os_validate_DiameterIdentity).
+  *secure is 0 (no security) or 1 (security enabled) on return.
+  *port is 0 (default) or a value in host byte order on return.
+  *transport is 0 (default) or IPPROTO_* on return.
+  *proto is 0 (default) or 'd' (diameter), 'r' (radius), or 't' (tacacs+) on return.
+  */
+int fd_os_parse_DiameterURI(uint8_t * uri, size_t urisz, DiamId_t * diamid, size_t * diamidlen, int * secure, uint16_t * port, int * transport, char *proto)
+{
+        size_t offset = 0;
+        DiamId_t fqdn = NULL;
+        size_t   fqdnlen;
+        TRACE_ENTRY("%p %zd %p %p %p %p %p %p", uri, urisz, diamid, diamidlen, secure, port, transport, proto);
+        CHECK_PARAMS( uri && urisz );
+        
+        CHECK_PARAMS( urisz > 7 ); /* "aaa" + "://" + something else at least */
+        
+        /* Initialize values */
+        if (secure)
+                *secure = 0;
+        if (port)
+                *port = 0;
+        if (transport)
+                *transport = 0;
+        if (proto)
+                *proto = 0;
+        
+        /* Check the beginning */
+        if (memcmp( uri, "aaa", 3)) {
+                TRACE_DEBUG(INFO, "Invalid DiameterURI prefix: got '%.*s', expected 'aaa'", 3, uri);
+                return EINVAL;
+        }
+        offset += 3;
+        
+        /* Secure? */
+        if (uri[offset] == (uint8_t)'s') {
+                if (secure)
+                        *secure = 1;
+                offset += 1;
+        }
+        
+        /* Remaining of URI marker */
+        if (memcmp( uri + offset, "://", 3)) {
+                TRACE_DEBUG(INFO, "Invalid DiameterURI prefix: got '%.*s', expected 'aaa://' or 'aaas://'", offset + 3, uri);
+                return EINVAL;
+        }
+        offset += 3;
+        
+        /* This is the start of the FQDN */
+        fqdn = (DiamId_t)uri + offset;
+        for ( ; offset < urisz ; offset++ ) {
+                /* Stop only when we find ':' or ';' */
+                if ((uri[offset] == (uint8_t)':') || (uri[offset] == (uint8_t)';'))
+                        break;
+        }
+        fqdnlen = offset - (fqdn - (DiamId_t)uri);
+        CHECK_FCT(fd_os_validate_DiameterIdentity(&fqdn, &fqdnlen, 1));
+        if (diamid)
+                *diamid = fqdn;
+        else
+                free(fqdn);
+        if (diamidlen)
+                *diamidlen = fqdnlen;
+        
+        if (offset == urisz)
+                return 0; /* Finished */
+        
+        /* Is there a port ? */
+        if (uri[offset] == ':') {
+                uint16_t p = 0;
+                do {
+                        offset++;
+
+                        if (offset == urisz)
+                                break;
+
+                        uint32_t t = (uint32_t)((char)uri[offset] - '0');
+                        if (t > 9)
+                                break; /* we did not get a digit */
+
+                        t += p * 10; /* the port is specified in decimal base */
+                        
+                        if (t >= (1<<16)) {
+                                TRACE_DEBUG(INFO, "Invalid DiameterURI: port value is too big, ignored.");
+                                p = 0;
+                                break;
+                        }
+
+                        p = t;
+                } while (1);
+
+                if (port)
+                        *port = p;
+        }
+        
+        if (offset == urisz)
+                return 0; /* Finished */
+        
+        /* Is there a transport? */
+        if ( (urisz - offset > CONSTSTRLEN(";transport=")) 
+                && !strncasecmp((char *)uri + offset, ";transport=", CONSTSTRLEN(";transport=")) ) {
+        
+                offset += CONSTSTRLEN(";transport=");
+
+                if (urisz - offset < 3) {
+                        TRACE_DEBUG(INFO, "Invalid DiameterURI: transport string is too short, ignored.");
+                        return 0;
+                }               
+                if (!strncasecmp((char *)uri + offset, "tcp", CONSTSTRLEN("tcp"))) {
+                        if (transport)
+                                *transport = IPPROTO_TCP;
+                        offset += CONSTSTRLEN("tcp");
+                        goto after_transport;
+                }
+                if (!strncasecmp((char *)uri + offset, "udp", CONSTSTRLEN("udp"))) {
+                        if (transport)
+                                *transport = IPPROTO_UDP;
+                        offset += CONSTSTRLEN("udp");
+                        goto after_transport;
+                }
+                if ((urisz - offset > 3) && !strncasecmp((char *)uri + offset, "sctp", CONSTSTRLEN("sctp"))) {
+                        if (transport) {
+#ifndef DISABLE_SCTP
+                                *transport = IPPROTO_SCTP;
+#else /* DISABLE_SCTP */
+                                TRACE_DEBUG(INFO, "Received DiameterURI with 'transport=sctp' but DISABLE_SCTP was selected");
+                                *transport = 0;
+#endif /* DISABLE_SCTP */
+                        }
+                        offset += CONSTSTRLEN("sctp");
+                        goto after_transport;
+                }
+                
+                TRACE_DEBUG(INFO, "Invalid DiameterURI: transport string is not recognized ('%.*s'), ignored.", urisz - offset, uri + offset);
+                
+                /* eat the remaining of invalid transport until a ';' */
+                for (; (offset < urisz) && ((char)uri[offset] != ';'); offset++);
+        }
+after_transport:
+        if (offset == urisz)
+                return 0; /* Finished */
+        
+        /* Is there a protocol? */
+        if ( ((urisz - offset) > CONSTSTRLEN(";protocol=")) 
+                && (!strncasecmp((char *)uri + offset, ";protocol=", CONSTSTRLEN(";protocol="))) ) {
+        
+                offset += CONSTSTRLEN(";protocol=");
+
+                if ( ((urisz - offset) >= CONSTSTRLEN("diameter")) 
+                    && (!strncasecmp((char *)uri + offset, "diameter", CONSTSTRLEN("diameter"))) ) {
+                        if (proto)
+                                *proto = 'd';
+                        offset += CONSTSTRLEN("diameter");
+                        goto after_proto;
+                }
+                
+                if ( ((urisz - offset) >= CONSTSTRLEN("radius")) 
+                    && (!strncasecmp((char *)uri + offset, "radius", CONSTSTRLEN("radius"))) ) {
+                        if (proto)
+                                *proto = 'r';
+                        offset += CONSTSTRLEN("radius");
+                        goto after_proto;
+                }
+                
+                if ( ((urisz - offset) >= CONSTSTRLEN("tacacs+")) 
+                    && (!strncasecmp((char *)uri + offset, "tacacs+", CONSTSTRLEN("tacacs+"))) ) {
+                        if (proto)
+                                *proto = 't';
+                        offset += CONSTSTRLEN("tacacs+");
+                        goto after_proto;
+                }
+                
+                TRACE_DEBUG(INFO, "Invalid DiameterURI: protocol string is not recognized ('%.*s'), ignored.", urisz - offset, uri + offset);
+                
+                /* eat the remaining of invalid transport until a ';' */
+                for (; (offset < urisz) && ((char)uri[offset] != ';'); offset++);
+        }
+after_proto:
+        if (offset == urisz)
+                return 0; /* Finished */
+        
+        TRACE_DEBUG(INFO, "Invalid DiameterURI: string is not recognized ('%.*s'), ignored.", urisz - offset, uri + offset);
+        return 0;
+}
 
 

libfdproto/rt_data.c

@@ -132 +132 @@
         CHECK_MALLOC( new = malloc(sizeof(struct rtd_candidate)) );
         memset(new, 0, sizeof(struct rtd_candidate) );
-        fd_list_init(&new->chain, NULL);
+        fd_list_init(&new->chain, new);
         CHECK_MALLOC( new->diamid = os0dup(peerid, peeridlen) )
         new->diamidlen = peeridlen;

tests/testostr.c

@@ -75 +75 @@
         {
                 char * res;
-                size_t len;
+                size_t len=0;
                 
                 /* A valid ASCII domain name */
@@ -88 +88 @@
                 /* Now, an invalid string */
                 res = TEST_IDN_UTF8;
+                len = 0;
                 
                 #ifdef DIAMID_IDNA_IGNORE