peerstatemachine.c File Reference

---

Detailed Description

CDiameterPeer Diameter base protocol state-machine definition.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file peerstatemachine.c.

#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include "peerstatemachine.h"
#include "diameter_api.h"
#include "receiver.h"
#include "peermanager.h"
#include "config.h"
#include "worker.h"

Go to the source code of this file.

Functions
int	sm_process (peer *p, peer_event_t event, AAAMessage *msg, int peer_locked, int sock)
	Diameter base protocol state-machine processing.
peer_state_t	I_Snd_Conn_Req (peer *p)
	Initiator - Send Connection Request.
void	Cleanup (peer *p, int sock)
	Cleans a socket by closing it and removing the reference.
void	Error (peer *p, int sock)
	Error action for a peer, triggers a Cleanup action.
static void	Snd_CE_add_applications (AAAMessage *msg, peer *p)
	Adds the Applications to a Capability Exchange message.
void	I_Snd_CER (peer *p)
	Send a Capability Exchange Request.
void	add_peer_application (peer *p, int id, int vendor, app_type type)
void	save_peer_applications (peer *p, AAAMessage *msg)
int	Process_CEA (peer *p, AAAMessage *cea)
	Process a Capability Exchange Answer.
void	I_Disc (peer *p)
	Initiator - disconnect peer.
void	R_Disc (peer *p)
	Receiver - disconnect peer.
int	Process_DWR (peer *p, AAAMessage *dwr)
	Process a Diameter Watch-dog Request.
void	Process_DWA (peer *p, AAAMessage *dwa)
	Process a Diameter Watch-dog Answer.
void	Snd_DWR (peer *p)
	Sends a Diameter Watch-dog Request.
void	Snd_DWA (peer *p, AAAMessage *dwr, int result_code, int sock)
	Sends a Diameter Watch-dog Answer.
void	Snd_DPR (peer *p)
	Sends a Disconnect Peer Request.
void	Snd_DPA (peer *p, AAAMessage *dpr, int result_code, int sock)
	Sends a Disconnect Peer Answer.
void	R_Accept (peer *p, int sock)
	Receiver - Accept a connection.
void	R_Reject (peer *p, int sock)
	Receiver - Reject a connection.
int	Process_CER (peer *p, AAAMessage *cer)
	Process a Capabilities Exchange Request.
void	Snd_CEA (peer *p, AAAMessage *cer, int result_code, int sock)
	Send a Capabilities Exchange Answer.
int	Elect (peer *p, AAAMessage *cer)
	Perform the Election mechanism.
void	Snd_Message (peer *p, AAAMessage *msg)
	Sends a message to the peer.
void	Rcv_Process (peer *p, AAAMessage *msg)
	Processes an incoming message.
Variables
dp_config *	config
	Configuration for this diameter peer.
char *	dp_states [] = {"Closed","Wait_Conn_Ack","Wait_I_CEA","Wait_Conn_Ack_Elect","Wait_Returns","R_Open","I_Open","Closing"}
	Strings for the peer states.
char *	dp_events []
	Strings for the peer events.

---

Function Documentation

int sm_process	(	peer *	p,
		peer_event_t	event,
		AAAMessage *	msg,
		int	peer_locked,
		int	sock
	)

Diameter base protocol state-machine processing.

This function get's called for every event. It updates the states and can trigger other events.

Parameters:

	p	- the peer for which the event happened
	event	- the event that happened
	msg	- if a Diameter message was received this is it, or NULL if not
	peer_locked	- if the peer lock is already aquired
	sock	- socket that this event happened on, or NULL if unrelated

Returns:

1 on success, 0 on error. Also the peer states are updated

Definition at line 88 of file peerstatemachine.c.

References AAA_SUCCESS, Cleanup(), Closed, Closing, dp_events, dp_states, Elect(), Error(), _peer_t::fqdn, I_Disc(), I_Open, I_Peer_Disc, I_Rcv_CEA, I_Rcv_CER, I_Rcv_Conn_Ack, I_Rcv_Conn_NAck, I_Rcv_DPA, I_Rcv_DPR, I_Rcv_DWA, I_Rcv_DWR, I_Rcv_Message, I_Rcv_Non_CEA, I_Snd_CER(), I_Snd_Conn_Req(), _peer_t::I_sock, _peer_t::lock, log_peer_list(), Process_CEA(), Process_CER(), Process_DWA(), Process_DWR(), R_Accept(), R_Conn_CER, R_Disc(), R_Open, R_Peer_Disc, R_Rcv_CEA, R_Rcv_CER, R_Rcv_DPA, R_Rcv_DPR, R_Rcv_DWA, R_Rcv_DWR, R_Rcv_Message, R_Reject(), _peer_t::R_sock, Rcv_Process(), Send_Message, sm_process(), Snd_CEA(), Snd_DPA(), Snd_DPR(), Snd_DWA(), Snd_Message(), Start, _peer_t::state, Stop, Timeout, Wait_Conn_Ack, Wait_Conn_Ack_Elect, Wait_I_CEA, Wait_Returns, and Win_Election.

Referenced by peer_send(), peer_timer(), receive_loop(), receive_message(), and sm_process().

{
    int result_code;
    peer_event_t next_event;
    int msg_received=0;
        
    if (!peer_locked) lock_get(p->lock);
    LOG(L_INFO,"DBG:sm_process(): Peer %.*s \tState %s \tEvent %s\n",
        p->fqdn.len,p->fqdn.s,dp_states[p->state],dp_events[event-101]);

    switch (p->state){
        case Closed:
            switch (event){
                case Start:
                    p->state = Wait_Conn_Ack;
                    next_event = I_Snd_Conn_Req(p);
                    sm_process(p,next_event,0,1,p->I_sock);
                    break;  
                case R_Conn_CER:
                    R_Accept(p,sock);
                    result_code = Process_CER(p,msg);
                    Snd_CEA(p,msg,result_code,p->R_sock);
                    if (result_code>=2000 && result_code<3000)
                        p->state = R_Open;
                    else {
                        R_Disc(p);
                        p->state = Closed;
                    }
                    log_peer_list(L_INFO);
                    break;
                case Stop:
                    /* just ignore this state */
                    p->state = Closed;
                    break;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;      
        case Wait_Conn_Ack:
            switch(event){
                case I_Rcv_Conn_Ack:
                    I_Snd_CER(p);
                    p->state = Wait_I_CEA;
                    break;  
                case I_Rcv_Conn_NAck:
                    Cleanup(p,p->I_sock);
                    p->state = Closed;
                    break;
/* Commented as not reachable*/                     
                case R_Conn_CER:
                    R_Accept(p,sock);
                    result_code = Process_CER(p,msg);
                    if (result_code>=2000 && result_code<3000)
                        p->state = Wait_Conn_Ack_Elect;
                    else {
                        p->state = Wait_Conn_Ack;
                        close(sock);
                    }
                    break;
                case Timeout:
                    Error(p,p->I_sock);
                    p->state = Closed;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;
            
        case Wait_I_CEA:
            switch(event){
                case I_Rcv_CEA:
                    result_code = Process_CEA(p,msg);
                    if (result_code>=2000 && result_code<3000)
                        p->state = I_Open;                                              
                    else {
                        Cleanup(p,p->I_sock);
                        p->state = Closed;
                    }
                    log_peer_list(L_INFO);
                    break;
                case R_Conn_CER:
                    R_Accept(p,sock);
                    result_code = Process_CER(p,msg);
                    p->state = Wait_Returns;
                    if (Elect(p,msg))
                        sm_process(p,Win_Election,msg,1,sock);
                    break;
                case I_Peer_Disc:
                    I_Disc(p);
                    p->state = Closed;
                    break;
                case I_Rcv_Non_CEA:
                    Error(p,p->I_sock);
                    p->state = Closed;
                    break;
                case Timeout:
                    Error(p,p->I_sock);
                    p->state = Closed;
                    break;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;  
/* commented as not reachable */
        case Wait_Conn_Ack_Elect:
            switch(event){
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;
        case Wait_Returns:
            switch(event){
                case Win_Election:
                    I_Disc(p);
                    result_code = Process_CER(p,msg);
                    Snd_CEA(p,msg,result_code,p->R_sock);
                    if (result_code>=2000 && result_code<3000){
                        p->state = R_Open;
                    }else{
                        R_Disc(p);
                        p->state = Closed;
                    }
                    break;
                case I_Peer_Disc:
                    I_Disc(p);
                    result_code = Process_CER(p,msg);
                    Snd_CEA(p,msg,result_code,p->R_sock);
                    if (result_code>=2000 && result_code<3000){
                        p->state = R_Open;
                    }else{
                        R_Disc(p);
                        p->state = Closed;
                    }
                    break;
                case I_Rcv_CEA:
                    R_Disc(p);
                    result_code = Process_CEA(p,msg);
                    if (result_code>=2000 && result_code<3000)
                        p->state = I_Open; 
                    else {
                        Cleanup(p,p->I_sock);
                        p->state = Closed;
                    }
                    break;
                case R_Peer_Disc:
                    R_Disc(p);
                    p->state = Wait_I_CEA;
                    break;
                case R_Conn_CER:
                    R_Reject(p,p->R_sock);
                    p->state = Wait_Returns;
                    break;
                case Timeout:
                    if (p->I_sock>=0) Error(p,p->I_sock);
                    if (p->R_sock>=0) Error(p,p->R_sock);
                    p->state = Closed;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;
        case R_Open:
            switch (event){
                case Send_Message:
                    Snd_Message(p,msg);
                    p->state = R_Open;
                    break;
                case R_Rcv_Message:
                    // delayed processing until out of the critical zone
                    //Rcv_Process(p,msg);
                    msg_received = 1;
                    p->state = R_Open;
                    break;
                case R_Rcv_DWR:
                    result_code = Process_DWR(p,msg);
                    Snd_DWA(p,msg,result_code,p->R_sock);
                    p->state = R_Open;
                    break;
                case R_Rcv_DWA:
                    Process_DWA(p,msg);
                    p->state = R_Open;
                    break;
                case R_Conn_CER:
                    R_Reject(p,sock);
                    p->state = R_Open;
                    break;
                case Stop:
                    Snd_DPR(p);
                    p->state = Closing;
                    break;
                case R_Rcv_DPR:
                    Snd_DPA(p,msg,AAA_SUCCESS,p->R_sock);
                    R_Disc(p);
                    p->state = Closed;
                    log_peer_list(L_INFO);
                    break;
                case R_Peer_Disc:
                    R_Disc(p);
                    p->state = Closed;
                    log_peer_list(L_INFO);
                    break;
                case R_Rcv_CER:
                    result_code = Process_CER(p,msg);
                    Snd_CEA(p,msg,result_code,p->R_sock);
                    if (result_code>=2000 && result_code<3000)
                        p->state = R_Open;
                    else {
                        /*R_Disc(p);p.state = Closed;*/
                        p->state = R_Open; /* Or maybe I should disconnect it?*/
                    }
                    break;
                case R_Rcv_CEA:
                    result_code = Process_CEA(p,msg);
                    if (result_code>=2000 && result_code<3000)
                        p->state = R_Open;
                    else {
                        /*R_Disc(p);p.state = Closed;*/
                        p->state = R_Open; /* Or maybe I should disconnect it?*/
                    }
                    log_peer_list(L_INFO);
                    break;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;          
        case I_Open:
            switch (event){
                case Send_Message:
                    Snd_Message(p,msg);
                    p->state = I_Open;
                    break;
                case I_Rcv_Message:
                    // delayed processing until out of the critical zone
                    //Rcv_Process(p,msg);
                    msg_received = 1;
                    p->state = I_Open;
                    break;
                case I_Rcv_DWR:
                    result_code = Process_DWR(p,msg);
                    Snd_DWA(p,msg,result_code,p->I_sock);                       
                    p->state =I_Open;
                    break;
                case I_Rcv_DWA:
                    Process_DWA(p,msg);
                    p->state =I_Open;
                    break;
                case R_Conn_CER:
                    R_Reject(p,sock);
                    p->state = I_Open;
                    break;
                case Stop:
                    Snd_DPR(p);
                    p->state = Closing;
                    break;
                case I_Rcv_DPR:
                    Snd_DPA(p,msg,2001,p->I_sock);
                    R_Disc(p);
                    p->state = Closed;
                    log_peer_list(L_INFO);
                    break;
                case I_Peer_Disc:
                    I_Disc(p);
                    p->state = Closed;
                    log_peer_list(L_INFO);
                    break;
                case I_Rcv_CER:
                    result_code = Process_CER(p,msg);
                    Snd_CEA(p,msg,result_code,p->I_sock);
                    if (result_code>=2000 && result_code<3000)
                        p->state = I_Open;
                    else {
                        /*I_Disc(p);p.state = Closed;*/
                        p->state = I_Open; /* Or maybe I should disconnect it?*/
                    }
                    break;
                case I_Rcv_CEA:
                    result_code = Process_CEA(p,msg);
                    if (result_code>=2000 && result_code<3000)
                        p->state = I_Open;
                    else {
                        /*I_Disc(p);p.state = Closed;*/
                        p->state = I_Open; /* Or maybe I should disconnect it?*/
                    }
                    break;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;              
        case Closing:
            switch(event){
                case I_Rcv_DPA:
                    I_Disc(p);
                    p->state = Closed;
                    break;
                case R_Rcv_DPA:
                    R_Disc(p);
                    p->state = Closed;
                    break;
                case Timeout:
                    if (p->I_sock>=0) Error(p,p->I_sock);
                    if (p->R_sock>=0) Error(p,p->R_sock);
                    p->state = Closed;
                    break;
                case I_Peer_Disc:
                    I_Disc(p);
                    p->state = Closed;
                    break;
                case R_Peer_Disc:
                    R_Disc(p);
                    p->state = Closed;
                    break;
                default:
                    LOG(L_DBG,"DBG:sm_process(): In state %s invalid event %s\n",
                        dp_states[p->state],dp_events[event-101]);
                    goto error;
            }
            break;              
    }
    if (!peer_locked) lock_release(p->lock);
    
    if (msg_received)
        Rcv_Process(p,msg);
    
    return 1;   
error:
    if (!peer_locked) lock_release(p->lock);
    return 0;   
}

peer_state_t I_Snd_Conn_Req

(

peer *

p

)

Initiator - Send Connection Request.

Tries to connect to the remote peer's socket. If the connection is refused, the new state is I_Rcv_Conn_NAck, else I_Rcv_Conn_Ack.

Note:

Must be called with a lock on the peer.

Parameters:

p

- peer to send to

Returns:

the new state for the peer

Definition at line 437 of file peerstatemachine.c.

References _peer_t::fqdn, I_Rcv_Conn_Ack, I_Rcv_Conn_NAck, _peer_t::I_sock, and peer_connect().

Referenced by sm_process().

{
    LOG(L_INFO,"DBG:I_Snd_Conn_Req(): Peer %.*s \n",
        p->fqdn.len,p->fqdn.s);

    if (p->I_sock>0) close(p->I_sock);
    p->I_sock = -1;
    p->I_sock = peer_connect(p);
    if (p->I_sock<0){
        return I_Rcv_Conn_NAck;
    }
    
    return I_Rcv_Conn_Ack;
}

void Cleanup	(	peer *	p,
		int	sock
	)

Cleans a socket by closing it and removing the reference.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer
	sock	- socket to close

Definition at line 458 of file peerstatemachine.c.

References _peer_t::I_sock, and _peer_t::R_sock.

Referenced by Error(), and sm_process().

{
    if (sock<0) return;
    close(sock);
    if (p->I_sock == sock) p->I_sock = -1;
    if (p->R_sock == sock) p->R_sock = -1;
}

void Error	(	peer *	p,
		int	sock
	)

Error action for a peer, triggers a Cleanup action.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer
	sock	- socket to close

Definition at line 472 of file peerstatemachine.c.

References Cleanup().

Referenced by sm_process().

{
    Cleanup(p,sock);
}

static void Snd_CE_add_applications	(	AAAMessage *	msg,
		peer *	p
	)			[inline, static]

Adds the Applications to a Capability Exchange message.

Note:

Must be called with a lock on the peer.

Parameters:

	msg	- the message to add to (request/answer)
	p	- the peer to add applications from

Definition at line 483 of file peerstatemachine.c.

References AAA_AVP_FLAG_MANDATORY, AAAAddAVPToAVPList(), AAACreateAndAddAVPToMessage, AAACreateAVP(), AAAFreeAVPList(), AAAGroupAVPS(), dp_config::applications, dp_config::applications_cnt, AVP_Acct_Application_Id, AVP_Auth_Application_Id, AVP_DUPLICATE_DATA, AVP_Vendor_Id, AVP_Vendor_Specific_Application_Id, config, DP_AUTHORIZATION, _avp_list_t::head, app_config::id, if, set_4bytes, _avp_list_t::tail, app_config::type, and app_config::vendor.

Referenced by I_Snd_CER(), and Snd_CEA().

{
    int i;
    app_config *app;
    char x[4];
    AAA_AVP *avp1,*avp2;
    AAA_AVP_LIST list;
    str group;
    list.head=0;list.tail=0;
    
    for(i=0;i<config->applications_cnt;i++){
        app = config->applications+i;
        if (app->vendor==0){
            set_4bytes(x,app->id);
            AAACreateAndAddAVPToMessage(msg,
                (app->type==DP_AUTHORIZATION?AVP_Auth_Application_Id:AVP_Acct_Application_Id),
                AAA_AVP_FLAG_MANDATORY,0,x,4);
        }else{
            set_4bytes(x,app->vendor);
            avp1 = AAACreateAVP(AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4, AVP_DUPLICATE_DATA);            
            AAAAddAVPToAVPList(&list,avp1);
            
            set_4bytes(x,app->id);
            avp2 = AAACreateAVP((app->type==DP_AUTHORIZATION?AVP_Auth_Application_Id:AVP_Acct_Application_Id),
                AAA_AVP_FLAG_MANDATORY,0,x,4,AVP_DUPLICATE_DATA);           
            AAAAddAVPToAVPList(&list,avp2);
        
            group = AAAGroupAVPS(list); 
            AAAFreeAVPList(&list);
            
            AAACreateAndAddAVPToMessage(msg,
                AVP_Vendor_Specific_Application_Id,
                AAA_AVP_FLAG_MANDATORY,0,group.s,group.len);
            shm_free(group.s);
        }
    }
}

void I_Snd_CER

(

peer *

p

)

Send a Capability Exchange Request.

Note:

Must be called with a lock on the peer.

Parameters:

p

- the peer to send to

Definition at line 526 of file peerstatemachine.c.

References AAA_AVP_FLAG_MANDATORY, AAACreateAndAddAVPToMessage, AAANewMessage(), AVP_Host_IP_Address, AVP_Product_Name, AVP_Vendor_Id, Code_CE, config, _message_t::endtoendId, errno, _message_t::hopbyhopId, _peer_t::I_sock, next_endtoend(), next_hopbyhop(), peer_send_msg(), dp_config::product_name, set_2bytes, set_4bytes, Snd_CE_add_applications(), and dp_config::vendor_id.

Referenced by sm_process().

{
    AAAMessage *cer=0;
//  AAA_AVP *avp;
    unsigned long ip;
    struct sockaddr_in6 addr;
    socklen_t addrlen;
    char x[18];
    
    cer = AAANewMessage(Code_CE,0,0,0);
    if (!cer) return;
    cer->hopbyhopId = next_hopbyhop();
    cer->endtoendId = next_endtoend();
    addrlen = sizeof(struct sockaddr_in6);
    if (getsockname(p->I_sock,(struct sockaddr*) &addr, &addrlen) == -1) { 
        LOG(L_ERR,"ERROR:I_Snd_CER(): Error on finding local host address > %s\n",strerror(errno));
    }else{
        switch(addr.sin6_family){
            case AF_INET:
                set_2bytes(x,1);
                ip = htonl(((struct sockaddr_in*)&addr)->sin_addr.s_addr);
                set_4bytes(x+2,ip);
                AAACreateAndAddAVPToMessage(cer,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,6);
                break;
            case AF_INET6:
                set_2bytes(x,2);
                memcpy(x+2,addr.sin6_addr.in6_u.u6_addr8,16);
                AAACreateAndAddAVPToMessage(cer,AVP_Host_IP_Address,AAA_AVP_FLAG_MANDATORY,0,x,18);
                break;
            default:
                LOG(L_ERR,"ERROR:I_Snd_CER(): unknown address type with family %d\n",addr.sin6_family);
        }
    }

    set_4bytes(x,config->vendor_id);
    AAACreateAndAddAVPToMessage(cer,AVP_Vendor_Id,AAA_AVP_FLAG_MANDATORY,0,x,4);
            
    AAACreateAndAddAVPToMessage(cer,AVP_Product_Name,AAA_AVP_FLAG_MANDATORY,0,config->product_name.s,config->product_name.len);

    Snd_CE_add_applications(cer,p);
//  peer_send(p,p->I_sock,cer,1);
    peer_send_msg(p,cer);
}

void add_peer_application	(	peer *	p,
		int	id,
		int	vendor,
		app_type	type
	)

Definition at line 571 of file peerstatemachine.c.

References _peer_t::applications, _peer_t::applications_cnt, app_config::id, app_config::type, and app_config::vendor.

Referenced by save_peer_applications().

{
    int i;
    if (!p->applications) return;
    for(i=0;i<p->applications_cnt;i++)
        if (p->applications[i].id == id &&
            p->applications[i].vendor == vendor &&
            p->applications[i].type == type) return;

    p->applications[p->applications_cnt].id = id;
    p->applications[p->applications_cnt].vendor = vendor;
    p->applications[p->applications_cnt].type = type;
    p->applications_cnt++;   
}

void save_peer_applications	(	peer *	p,
		AAAMessage *	msg
	)

Definition at line 586 of file peerstatemachine.c.

References AAAFindMatchingAVPList(), AAAFreeAVPList(), AAAUngroupAVPS(), add_peer_application(), _peer_t::applications, _peer_t::applications_cnt, AVP_Acct_Application_Id, AVP_Auth_Application_Id, AVP_Vendor_Id, AVP_Vendor_Specific_Application_Id, _message_t::avpList, avp::code, avp::data, DP_ACCOUNTING, DP_AUTHORIZATION, get_4bytes, _avp_list_t::head, id, and avp::next.

Referenced by Process_CEA(), and Process_CER().

{
    int total_cnt=0;
    AAA_AVP *avp,*avp_vendor,*avp2;
    AAA_AVP_LIST group;
    int id,vendor;

    if (p->applications) {
        shm_free(p->applications);
        p->applications = 0;
        p->applications_cnt = 0;
    }
    for(avp=msg->avpList.head;avp;avp = avp->next)
        switch (avp->code){
            case AVP_Auth_Application_Id:
            case AVP_Acct_Application_Id:
            case AVP_Vendor_Specific_Application_Id:                
                total_cnt+=2;/* wasteful, but let's skip decoding */    
                break;              
        }
    p->applications_cnt = 0;
    p->applications = shm_malloc(sizeof(app_config)*total_cnt);
    if (!p->applications