peerstatemachine.c

Go to the documentation of this file.

#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"

extern dp_config *config;       
char *dp_states[]={"Closed","Wait_Conn_Ack","Wait_I_CEA","Wait_Conn_Ack_Elect","Wait_Returns","R_Open","I_Open","Closing"};
char *dp_events[]={"Start","Stop","Timeout","Win_Election","R_Conn_CER","I_Rcv_Conn_Ack","I_Rcv_Conn_NAck",
    "I_Rcv_CER","I_Rcv_CEA","R_Rcv_CER","R_Rcv_CEA","I_Rcv_Non_CEA",
    "I_Rcv_DPR","I_Rcv_DPA","R_Rcv_DPR","R_Rcv_DPA",
    "I_Rcv_DWR","I_Rcv_DWA","R_Rcv_DWR","R_Rcv_DWA",
    "Send_Message","I_Rcv_Message","R_Rcv_Message","I_Peer_Disc","R_Peer_Disc"};

int sm_process(peer *p,peer_event_t event,AAAMessage *msg,int peer_locked,int sock)
{
    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)
{
    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)
{
    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)
{
    Cleanup(p,sock);
}

static inline void Snd_CE_add_applications(AAAMessage *msg,peer *p)
{
    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)
{
    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.s6_addr,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)
{
    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)
{
    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){  
        LOG(L_ERR,"ERROR:save_peer_applications(): Error allocating %d bytes! No applications saved...\n",
            sizeof(app_config)*total_cnt);
        return;
    }
    for(avp=msg->avpList.head;avp;avp = avp->next)
    {
        switch (avp->code){
            case AVP_Auth_Application_Id:
                id = get_4bytes(avp->data.s);   
                add_peer_application(p,id,0,DP_AUTHORIZATION);  
                break;
            case AVP_Acct_Application_Id:
                id = get_4bytes(avp->data.s);   
                add_peer_application(p,id,0,DP_ACCOUNTING); 
                break;
            case AVP_Vendor_Specific_Application_Id:
                group = AAAUngroupAVPS(avp->data);
                avp_vendor = AAAFindMatchingAVPList(group,group.head,AVP_Vendor_Id,0,0);                
                avp2 = AAAFindMatchingAVPList(group,group.head,AVP_Auth_Application_Id,0,0);                
                if (avp_vendor&&avp2){
                    vendor = get_4bytes(avp_vendor->data.s);
                    id = get_4bytes(avp2->data.s);
                    add_peer_application(p,id,vendor,DP_AUTHORIZATION);                     
                }
                avp2 = AAAFindMatchingAVPList(group,group.head,AVP_Acct_Application_Id,0,0);                
                if (avp_vendor&&avp2){
                    vendor = get_4bytes(avp_vendor->data.s);
                    id = get_4bytes(avp2->data.s);
                    add_peer_application(p,id,vendor,DP_ACCOUNTING);                    
                }
                AAAFreeAVPList(&group);
                break;
                
        }
    }   
}

int Process_CEA(peer *p,AAAMessage *cea)
{
    AAA_AVP *avp;
    avp = AAAFindMatchingAVP(cea,cea->avpList.head,AVP_Result_Code,0,0);
    save_peer_applications(p,cea);
    AAAFreeMessage(&cea);
    if (!avp) return AAA_UNABLE_TO_COMPLY;
    else return get_4bytes(avp->data.s);
}   

void I_Disc(peer *p)
{
    if (p->I_sock>=0){
        close(p->I_sock);
        p->I_sock = -1;
    }
}

void R_Disc(peer *p)
{
    if (p->R_sock>=0){
        close(p->R_sock);
        p->R_sock = -1;
    }
}

int Process_DWR(peer *p,AAAMessage *dwr)
{
    return AAA_SUCCESS;
}

void Process_DWA(peer *p,AAAMessage *dwa)
{
    p->waitingDWA = 0;
    AAAFreeMessage(&dwa);
}

void Snd_DWR(peer *p)
{
    AAAMessage *dwr=0;
    
    dwr = AAANewMessage(Code_DW,0,0,0);
    if (!dwr) return;   
    dwr->hopbyhopId = next_hopbyhop();
    dwr->endtoendId = next_endtoend();
    if (p->state==I_Open)
        peer_send_msg(p,dwr);   
    else
        peer_send_msg(p,dwr);   
}

void Snd_DWA(peer *p,AAAMessage *dwr,int result_code,int sock)
{
    AAAMessage *dwa;
    char x[4];  

    dwa = AAANewMessage(Code_DW,0,0,dwr);
    if (!dwa) goto done;    

    set_4bytes(x,result_code);
    AAACreateAndAddAVPToMessage(dwa,AVP_Result_Code,AAA_AVP_FLAG_MANDATORY,0,x,4);
    
    peer_send_msg(p,dwa);
done:   
    AAAFreeMessage(&dwr);
}

void Snd_DPR(peer *p)
{
    AAAMessage *dpr=0;
    char x[4];
    
    dpr = AAANewMessage(Code_DP,0,0,0); 
    if (!dpr) return;
    dpr->hopbyhopId = next_hopbyhop();
    dpr->endtoendId = next_endtoend();

    set_4bytes(x,0/*busy*/);
    AAACreateAndAddAVPToMessage(dpr,AVP_Disconnect_Cause,AAA_AVP_FLAG_MANDATORY,0,x,4);

    if (p->state==I_Open)
        peer_send_msg(p,dpr);   
    else
        peer_send_msg(p,dpr);   
}

void Snd_DPA(peer *p,AAAMessage *dpr,int result_code,int sock)
{
    AAAMessage *dpa;

    dpa = AAANewMessage(Code_DP,0,0,dpr);   
    if (dpa) peer_send_msg(p,dpa);
    AAAFreeMessage(&dpr);
}

void R_Accept(peer *p,int sock)
{
    p->R_sock = sock;
    touch_peer(p);
}

void R_Reject(peer *p,int sock)
{
    close(sock);
}

int Process_CER(peer *p,AAAMessage *cer)
{
    int common_app=0;
    AAA_AVP *avp,*avp_vendor,*avp2;
    AAA_AVP_LIST group;
    int i,id,vendor;
    for(avp=cer->avpList.head;avp;avp = avp->next)
    {
        switch (avp->code){
            case AVP_Auth_Application_Id:
                id = get_4bytes(avp->data.s);   
                for(i=0;i<config->applications_cnt;i++)
                    if (id == config->applications[i].id &&
                        config->applications[i].vendor==0 &&
                        config->applications[i].type==DP_AUTHORIZATION) common_app++;   
                break;
            case AVP_Acct_Application_Id:
                id = get_4bytes(avp->data.s);   
                for(i=0;i<config->applications_cnt;i++)
                    if (id == config->applications[i].id &&
                        config->applications[i].vendor==0 &&
                        config->applications[i].type==DP_ACCOUNTING) common_app++;  
                break;
            case AVP_Vendor_Specific_Application_Id:
                group = AAAUngroupAVPS(avp->data);
                avp_vendor = AAAFindMatchingAVPList(group,group.head,AVP_Vendor_Id,0,0);                
                avp2 = AAAFindMatchingAVPList(group,group.head,AVP_Auth_Application_Id,0,0);                
                if (avp_vendor&&avp2){
                    vendor = get_4bytes(avp_vendor->data.s);
                    id = get_4bytes(avp2->data.s);
                    for(i=0;i<config->applications_cnt;i++)
                        if (id == config->applications[i].id &&
                            config->applications[i].vendor==vendor &&
                            config->applications[i].type==DP_AUTHORIZATION) common_app++;   
                    
                }
                avp2 = AAAFindMatchingAVPList(group,group.head,AVP_Acct_Application_Id,0,0);                
                if (avp_vendor&&avp2){
                    vendor = get_4bytes(avp_vendor->data.s);
                    id = get_4bytes(avp2->data.s);
                    for(i=0;i<config->applications_cnt;i++)
                        if (id == config->applications[i].id &&
                            config->applications[i].vendor==vendor &&
                            config->applications[i].type==