peerstatemachine.h 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.h.

#include "utils.h"
#include "peer.h"
#include "diameter.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.
void	I_Snd_CER (peer *p)
	Send a Capability Exchange Request.
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.

---

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);
}

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.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);
}

int Process_CEA	(	peer *	p,
		AAAMessage *	cea
	)

Process a Capability Exchange Answer.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer that the CEA was received from
	cea	- the CEA message

Returns:

the result-code from CEA or AAA_UNABLE_TO_COMPLY if no result-code found

Definition at line 653 of file peerstatemachine.c.

References AAA_UNABLE_TO_COMPLY, AAAFindMatchingAVP(), AAAFreeMessage(), AVP_Result_Code, _message_t::avpList, avp::data, get_4bytes, _avp_list_t::head, and save_peer_applications().

Referenced by sm_process().

{
    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

)

Initiator - disconnect peer.

Note:

Must be called with a lock on the peer.

Parameters:

p

- the peer to disconnect

Definition at line 668 of file peerstatemachine.c.

References _peer_t::I_sock.

Referenced by sm_process().

{
    if (p->I_sock>=0){
        close(p->I_sock);
        p->I_sock = -1;
    }
}

void R_Disc

(

peer *

p

)

Receiver - disconnect peer.

Note:

Must be called with a lock on the peer.

Parameters:

p

- the peer to disconnect

Definition at line 681 of file peerstatemachine.c.

References _peer_t::R_sock.

Referenced by sm_process().

{
    if (p->R_sock>=0){
        close(p->R_sock);
        p->R_sock = -1;
    }
}

int Process_DWR	(	peer *	p,
		AAAMessage *	dwr
	)

Process a Diameter Watch-dog Request.

The last activity timer is updated in the sm_process(), on any message received.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer that the DWR was received from
	dwr	- the DWR message

Returns:

AAA_SUCCESS

Definition at line 697 of file peerstatemachine.c.

References AAA_SUCCESS.

Referenced by sm_process().

{
    return AAA_SUCCESS;
}

void Process_DWA	(	peer *	p,
		AAAMessage *	dwa
	)

Process a Diameter Watch-dog Answer.

The flag for waiting a DWA is reseted.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer that the DWR was received from
	dwa	- the DWA message

Definition at line 709 of file peerstatemachine.c.

References AAAFreeMessage(), and _peer_t::waitingDWA.

Referenced by sm_process().

{
    p->waitingDWA = 0;
    AAAFreeMessage(&dwa);
}

void Snd_DWR

(

peer *

p

)

Sends a Diameter Watch-dog Request.

The flag for waiting a DWA is set.

Note:

Must be called with a lock on the peer.

Parameters:

p

- the peer that the DWR was received from

Definition at line 721 of file peerstatemachine.c.

References AAANewMessage(), Code_DW, _message_t::endtoendId, _message_t::hopbyhopId, I_Open, next_endtoend(), next_hopbyhop(), peer_send_msg(), and _peer_t::state.

Referenced by peer_timer().

{
    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
	)

Sends a Diameter Watch-dog Answer.

Note:

Must be called with a lock on the peer.

Parameters:

	p	- the peer that the DWR was received from
	dwr	- the DWR message
	result_code	- the Result-Code to attach to DWA
	sock	- socket to send on

Definition at line 743 of file peerstatemachine.c.

References AAA_AVP_FLAG_MANDATORY, AAACreateAndAddAVPToMessage, AAAFreeMessage(), AAANewMessage(), AVP_Result_Code, Code_DW, peer_send_msg(), and set_4bytes.

Referenced by sm_process().

{
    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

)

Sends a Disconnect Peer Request.

Note:

Must be called with a lock on the peer.

Parameters:

p

- the peer to send to

Definition at line 764 of file peerstatemachine.c.

References AAA_AVP_FLAG_MANDATORY, AAACreateAndAddAVPToMessage, AAANewMessage(), AVP_Disconnect_Cause, Code_DP, _message_t::endtoendId, _message_t::hopbyhopId, I_Open, next_endtoend(), next_hopbyhop(), peer_send_msg(), set_4bytes, and _peer_t::state.

Referenced by sm_process().

{
    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(