Changeset 78:a58f0757c06a in freeDiameter

Timestamp:

Dec 1, 2009, 4:24:06 PM (14 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Added code for DPR/DPA

Files:

• freeDiameter/fD.h (modified) (3 diffs)
• freeDiameter/messages.c (modified) (2 diffs)
• freeDiameter/p_ce.c (modified) (1 diff)
• freeDiameter/p_cnx.c (modified) (2 diffs)
• freeDiameter/p_dp.c (modified) (1 diff)
• freeDiameter/p_expiry.c (modified) (1 diff)
• freeDiameter/p_psm.c (modified) (8 diffs)
• freeDiameter/peers.c (modified) (1 diff)
• include/freeDiameter/freeDiameter.h (modified) (1 diff)

freeDiameter/fD.h

@@ -91 +91 @@
 struct dict_object * fd_dict_cmd_CER; /* Capabilities-Exchange-Request */
 struct dict_object * fd_dict_cmd_DWR; /* Device-Watchdog-Request */
+struct dict_object * fd_dict_avp_DC;  /* Disconnect-Cause */
 struct dict_object * fd_dict_cmd_DPR; /* Disconnect-Peer-Request */
 
@@ -257 +258 @@
 int  fd_psm_start();
 int  fd_psm_begin(struct fd_peer * peer );
-int  fd_psm_terminate(struct fd_peer * peer );
+int  fd_psm_terminate(struct fd_peer * peer, char * reason );
 void fd_psm_abord(struct fd_peer * peer );
 void fd_psm_next_timeout(struct fd_peer * peer, int add_random, int delay);
@@ -287 +288 @@
 int fd_p_dw_reopen(struct fd_peer * peer);
 int fd_p_dp_handle(struct msg ** msg, int req, struct fd_peer * peer);
-int fd_p_dp_initiate(struct fd_peer * peer);
+int fd_p_dp_initiate(struct fd_peer * peer, char * reason);
 
 /* Active peers -- routing process should only ever take the read lock, the write lock is managed by PSMs */

freeDiameter/messages.c

@@ -45 +45 @@
 struct dict_object * fd_dict_cmd_CER = NULL; /* Capabilities-Exchange-Request */
 struct dict_object * fd_dict_cmd_DWR = NULL; /* Device-Watchdog-Request */
+struct dict_object * fd_dict_avp_DC  = NULL; /* Disconnect-Cause */
 struct dict_object * fd_dict_cmd_DPR = NULL; /* Disconnect-Peer-Request */
 
@@ -61 +62 @@
         CHECK_FCT(  fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Error-Reporting-Host", &dict_avp_ERH , ENOENT)  );
         CHECK_FCT(  fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Failed-AVP",         &dict_avp_FAVP, ENOENT)  );
+        
+        CHECK_FCT(  fd_dict_search( fd_g_config->cnf_dict, DICT_AVP, AVP_BY_NAME, "Disconnect-Cause",   &fd_dict_avp_DC , ENOENT)  );
         
         CHECK_FCT( fd_dict_search ( fd_g_config->cnf_dict, DICT_COMMAND, CMD_BY_NAME, "Capabilities-Exchange-Request", &fd_dict_cmd_CER, ENOENT ) );

freeDiameter/p_ce.c

@@ -763 +763 @@
                                 {
                                         TRACE_DEBUG(INFO, "Validation callback rejected the peer %s after handshake", peer->p_hdr.info.pi_diamid);
-                                        CHECK_FCT( fd_psm_terminate( peer ) );
+                                        CHECK_FCT( fd_psm_terminate( peer, "DO_NOT_WANT_TO_TALK_TO_YOU" ) );
                                         return 0;
                                 }  );

freeDiameter/p_cnx.c

@@ -88 +88 @@
                 if (ret) {
                         fd_log_debug("Unable to resolve address for peer '%s' (%s), aborting\n", peer->p_hdr.info.pi_diamid, gai_strerror(ret));
-                        fd_psm_terminate( peer );
+                        fd_psm_terminate( peer, NULL );
                         return 0;
                 }
@@ -110 +110 @@
         if (FD_IS_LIST_EMPTY(&peer->p_hdr.info.pi_endpoints)) {
                 fd_log_debug("No address %savailable to connect to peer '%s', aborting\n", peer->p_hdr.info.config.pic_flags.pro3 ? "in the configured family " : "", peer->p_hdr.info.pi_diamid);
-                fd_psm_terminate( peer );
+                fd_psm_terminate( peer, NULL );
                 return 0;
         }

freeDiameter/p_dp.c

@@ -41 +41 @@
 int fd_p_dp_handle(struct msg ** msg, int req, struct fd_peer * peer)
 {
-        TODO("Handle depending on DPR or DPA and peer state");
+        int delay = 0;
+        TRACE_ENTRY("%p %d %p", msg, req, peer);
         
-        return ENOTSUP;
+        if (req) {
+                /* We received a DPR, save the Disconnect-Cause and terminate the connection */
+                struct avp * dc;
+                
+                CHECK_FCT_DO( fd_msg_search_avp ( *msg, fd_dict_avp_DC, &dc ), return );
+                if (dc) {
+                        /* Check the value is consistent with the saved one */
+                        struct avp_hdr * hdr;
+                        CHECK_FCT_DO(  fd_msg_avp_hdr( dc, &hdr ), return  );
+                        if (hdr->avp_value == NULL) {
+                                /* This is a sanity check */
+                                TRACE_DEBUG(NONE, "BUG: Unset value in Disconnect-Cause in DPR");
+                                fd_msg_dump_one(NONE, dc);
+                                ASSERT(0); /* To check if this really happens, and understand why... */
+                        }
+
+                        peer->p_hdr.info.runtime.pir_lastDC = hdr->avp_value->u32;
+                }
+                if (TRACE_BOOL(INFO)) {
+                        if (dc) {
+                                struct dict_object * dictobj = NULL;
+                                struct dict_enumval_request er;
+                                memset(&er, 0, sizeof(er));
+                                CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, fd_dict_avp_DC, &er.type_obj, ENOENT )  );
+                                er.search.enum_value.u32 = peer->p_hdr.info.runtime.pir_lastDC;
+                                CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &er, &dictobj, 0 )  );
+                                if (dictobj) {
+                                        CHECK_FCT( fd_dict_getval( dictobj, &er.search ) );
+                                        fd_log_debug("Peer '%s' sent a DPR with cause: %s\n", peer->p_hdr.info.pi_diamid, er.search.enum_name);
+                                } else {
+                                        fd_log_debug("Peer '%s' sent a DPR with unknown cause: %u\n", peer->p_hdr.info.pi_diamid, peer->p_hdr.info.runtime.pir_lastDC);
+                                }
+                        } else {
+                                fd_log_debug("Peer '%s' sent a DPR without Disconnect-Cause AVP\n", peer->p_hdr.info.pi_diamid);
+                        }
+                }
+                
+                /* Now reply with a DPA */
+                CHECK_FCT( fd_msg_new_answer_from_req ( fd_g_config->cnf_dict, msg, 0 ) );
+                CHECK_FCT( fd_msg_rescode_set( *msg, "DIAMETER_SUCCESS", NULL, NULL, 0 ) );
+                CHECK_FCT( fd_msg_add_origin ( *msg, 0 ) );
+                
+                /* Move to CLOSING state to failover outgoing messages (and avoid failing the DPA...) */
+                CHECK_FCT( fd_psm_change_state(peer, STATE_CLOSING) );
+                
+                /* Now send the DPA */
+                CHECK_FCT( fd_out_send( msg, NULL, peer) );
+                
+        } else {
+                /* We received a DPA */
+                if (peer->p_hdr.info.runtime.pir_state != STATE_CLOSING) {
+                        TRACE_DEBUG(INFO, "Ignore DPA received in state %s", STATE_STR(peer->p_hdr.info.runtime.pir_state));
+                }
+                        
+        }
+        
+        if (*msg) {
+                /* In theory, we should control the Result-Code AVP. But since we will not go back to OPEN state here, let's skip it */
+                CHECK_FCT_DO( fd_msg_free( *msg ), /* continue */ );
+                *msg = NULL;
+        }
+        
+        /* The calling function handles cleaning the PSM and terminating the peer */
+        return 0;
 }
 
 /* Start disconnection of a peer: send DPR */
-int fd_p_dp_initiate(struct fd_peer * peer)
+int fd_p_dp_initiate(struct fd_peer * peer, char * reason)
 {
-        TODO("Create the DPR message");
-        TODO("Send it");
-        TODO("Mark the peer as CLOSING");
-        TODO("Reset the timer");
+        struct msg * msg = NULL;
+        struct dict_object * dictobj = NULL;
+        struct avp * avp = NULL;
+        struct dict_enumval_request er;
+        union avp_value val;
         
-        return ENOTSUP;
+        TRACE_ENTRY("%p %p", peer, reason);
+        
+        /* Create a new DWR instance */
+        CHECK_FCT( fd_msg_new ( fd_dict_cmd_DPR, MSGFL_ALLOC_ETEID, &msg ) );
+        
+        /* Add the Origin information */
+        CHECK_FCT( fd_msg_add_origin ( msg, 0 ) );
+        
+        /* Add the Disconnect-Cause */
+        CHECK_FCT( fd_msg_avp_new ( fd_dict_avp_DC, 0, &avp ) );
+        
+        /* Search the value in the dictionary */
+        memset(&er, 0, sizeof(er));
+        CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_TYPE, TYPE_OF_AVP, fd_dict_avp_DC, &er.type_obj, ENOENT )  );
+        er.search.enum_name = reason ?: "REBOOTING";
+        CHECK_FCT( fd_dict_search( fd_g_config->cnf_dict, DICT_ENUMVAL, ENUMVAL_BY_STRUCT, &er, &dictobj, ENOENT )  );
+        CHECK_FCT( fd_dict_getval( dictobj, &er.search ) );
+        
+        /* Set the value in the AVP */
+        val.u32 = er.search.enum_value.u32;
+        CHECK_FCT( fd_msg_avp_setvalue( avp, &val ) );
+        CHECK_FCT( fd_msg_avp_add( msg, MSG_BRW_LAST_CHILD, avp ) );
+        
+        /* Save the value also in the peer */
+        peer->p_hdr.info.runtime.pir_lastDC = val.u32;
+        
+        /* Now send this message */
+        CHECK_FCT( fd_out_send(&msg, NULL, peer) );
+        
+        /* Update the peer state and timer */
+        CHECK_FCT( fd_psm_change_state(peer, STATE_CLOSING) );
+        fd_psm_next_timeout(peer, 0, DPR_TIMEOUT);
+        
+        return 0;
 }

freeDiameter/p_expiry.c

@@ -132 +132 @@
                 /* Now, the first peer in the list is expired; signal it */
                 fd_list_unlink( &first->p_expiry );
-                CHECK_FCT_DO( fd_event_send(first->p_events, FDEVP_TERMINATE, 0, NULL), goto error );
+                CHECK_FCT_DO( fd_event_send(first->p_events, FDEVP_TERMINATE, 0, "DO_NOT_WANT_TO_TALK_TO_YOU"), goto error );
                 
         } while (1);

freeDiameter/p_psm.c

@@ -94 +94 @@
                 CHECK_FCT_DO( (*peer->p_cb2)(&peer->p_hdr.info),
                         {
-                                TRACE_DEBUG(FULL, "Validation failed, moving to state CLOSING");
-                                peer->p_hdr.info.runtime.pir_state = STATE_CLOSING;
-                                fd_psm_terminate(peer);
+                                TRACE_DEBUG(FULL, "Validation failed, terminating the connection");
+                                fd_psm_terminate(peer, "DO_NOT_WANT_TO_TALK_TO_YOU" );
                         } );
                 peer->p_cb2 = NULL;
@@ -161 +160 @@
                         break;
                         
+                        case FDEVP_TERMINATE:
+                                /* Do not free the string since it is a constant */
+                        break;
+                        
                         case FDEVP_CNX_INCOMING: {
                                 struct cnx_incoming * evd = ev->data;
@@ -216 +219 @@
 void fd_psm_next_timeout(struct fd_peer * peer, int add_random, int delay)
 {
+        TRACE_DEBUG(FULL, "Peer timeout reset to %d seconds%s", delay, add_random ? " (+/- 2)" : "" );
+        
         /* Initialize the timer */
         CHECK_POSIX_DO(  clock_gettime( CLOCK_REALTIME,  &peer->p_psm_timer ), ASSERT(0) );
@@ -235 +240 @@
         
         peer->p_psm_timer.tv_sec += delay;
-        
-        TRACE_DEBUG(FULL, "Peer timeout reset to %d seconds%s", delay, add_random ? " (+/- 2)" : "" );
         
 #ifdef SLOW_PSM
@@ -348 +351 @@
                         case STATE_REOPEN:
                                 /* We cannot just close the conenction, we have to send a DPR first */
-                                CHECK_FCT_DO( fd_p_dp_initiate(peer), goto psm_end );
+                                CHECK_FCT_DO( fd_p_dp_initiate(peer, ev_data), goto psm_end );
                                 goto psm_loop;
                         
@@ -471 +474 @@
                         case CC_DISCONNECT_PEER:
                                 CHECK_FCT_DO( fd_p_dp_handle(&msg, (hdr->msg_flags & CMD_FLAG_REQUEST), peer), goto psm_end );
+                                if (peer->p_hdr.info.runtime.pir_state == STATE_CLOSING)
+                                        goto psm_end;
                                 break;
                         
@@ -712 +717 @@
 
 /* End the PSM (clean ending) */
-int fd_psm_terminate(struct fd_peer * peer )
+int fd_psm_terminate(struct fd_peer * peer, char * reason )
 {
         TRACE_ENTRY("%p", peer);
@@ -718 +723 @@
         
         if (peer->p_hdr.info.runtime.pir_state != STATE_ZOMBIE) {
-                CHECK_FCT( fd_event_send(peer->p_events, FDEVP_TERMINATE, 0, NULL) );
+                CHECK_FCT( fd_event_send(peer->p_events, FDEVP_TERMINATE, 0, reason) );
         } else {
                 TRACE_DEBUG(FULL, "Peer '%s' was already terminated", peer->p_hdr.info.pi_diamid);

freeDiameter/peers.c

@@ -255 +255 @@
                 
                 if (peer->p_hdr.info.runtime.pir_state != STATE_ZOMBIE) {
-                        CHECK_FCT_DO( fd_psm_terminate(peer), /* continue */ );
+                        CHECK_FCT_DO( fd_psm_terminate(peer, "REBOOTING"), /* continue */ );
                 } else {
                         li = li->prev; /* to avoid breaking the loop */

include/freeDiameter/freeDiameter.h

@@ -338 +338 @@
                 int             pir_isi;        /* Inband-Security-Id advertised (PI_SEC_* bits) */
                 
+                uint32_t        pir_lastDC;     /* The last Disconnect-Cause value received */
+                
                 int             pir_proto;      /* The L4 protocol currently used with the peer (IPPROTO_TCP or IPPROTO_SCTP) */
                 const gnutls_datum_t    *pir_cert_list;         /* The (valid) credentials that the peer has presented, or NULL if TLS is not used */