diameter_api.c File Reference

---

Detailed Description

CDiameterPeer - Diameter API interface.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file diameter_api.c.

#include "diameter_api.h"
#include "peer.h"
#include "peermanager.h"
#include "receiver.h"
#include "transaction.h"
#include "api_process.h"
#include "routing.h"

Go to the source code of this file.

Functions
AAATransaction *	AAACreateTransaction (AAAApplicationId app_id, AAACommandCode cmd_code)
	Create a AAATransaction for the given request.
int	AAADropTransaction (AAATransaction *trans)
	Free the memory allocated for the AAATransaction.
int	AAAAddRequestHandler (AAARequestHandler_f *f, void *param)
	Add a handler function for incoming requests.
int	AAAAddResponseHandler (AAAResponseHandler_f *f, void *param)
	Add a handler function for incoming responses.
AAAReturnCode	AAASendMessage (AAAMessage *message, AAATransactionCallback_f *callback_f, void *callback_param)
	Send a AAAMessage asynchronously.
AAAReturnCode	AAASendMessageToPeer (AAAMessage *message, str *peer_id, AAATransactionCallback_f *callback_f, void *callback_param)
	Send a AAAMessage asynchronously.
void	sendrecv_cb (int is_timeout, void *param, AAAMessage *ans)
	Generic callback used by AAASendRecvMessage() to block until a transactional response is received.
AAAMessage *	AAASendRecvMessage (AAAMessage *message)
	Send a AAAMessage synchronously.
AAAMessage *	AAASendRecvMessageToPeer (AAAMessage *message, str *peer_id)
	Send a AAAMessage synchronously.
Variables
handler_list *	handlers
	list of handlers
gen_lock_t *	handlers_lock
	lock for list of handlers

---

Function Documentation

AAATransaction* AAACreateTransaction	(	AAAApplicationId	app_id,
		AAACommandCode	cmd_code
	)

Create a AAATransaction for the given request.

Parameters:

	app_id	- id of the request's application
	cmd_code	- request's code

Returns:

the AAATransaction*

Definition at line 73 of file diameter_api.c.

References _AAATransaction::application_id, and _AAATransaction::command_code.

Referenced by load_cdp().

{
    AAATransaction *t;
    t = shm_malloc(sizeof(AAATransaction));
    if (!t) return 0;
    memset(t,0,sizeof(AAATransaction)); 
    t->application_id=app_id;
    t->command_code=cmd_code;           
    return t;
}

int AAADropTransaction

(

AAATransaction *

trans

)

Free the memory allocated for the AAATransaction.

Parameters:

trans

- the AAATransaction to be deallocated

Returns:

1 on success, 0 on failure

Definition at line 89 of file diameter_api.c.

Referenced by load_cdp().

{
    if (!trans) return 0;
//  LOG(L_ERR,"\nCALLED HERE %d %d\n",trans->done,trans->with_callback);
    shm_free(trans);
    return 1;
}

int AAAAddRequestHandler	(	AAARequestHandler_f *	f,
		void *	param
	)

Add a handler function for incoming requests.

Parameters:

	f	- the callback function
	param	- generic parameter to be used when calling the callback functions

Returns:

1 on success, 0 on failure

Definition at line 109 of file diameter_api.c.

References handler_t::handler, handlers, handlers_lock, handler_list_t::head, handler_t::next, handler_t::param, handler_t::prev, REQUEST_HANDLER, handler_t::requestHandler, handler_list_t::tail, and handler_t::type.

Referenced by load_cdp().

{
    handler *h = shm_malloc(sizeof(handler));
    if (!h) {
        LOG(L_ERR,"ERR:AAAAddRequestHandler: error allocating %d bytes in shm\n",
            sizeof(handler));
        return 0;
    }
    h->type = REQUEST_HANDLER;
    h->handler.requestHandler = f;
    h->param = param;
    h->next = 0;
    lock_get(handlers_lock);
    h->prev = handlers->tail;
    if (handlers->tail) handlers->tail->next = h;
    handlers->tail = h;
    if (!handlers->head) handlers->head = h;
    lock_release(handlers_lock);
    return 1;
}

int AAAAddResponseHandler	(	AAAResponseHandler_f *	f,
		void *	param
	)

Add a handler function for incoming responses.

Parameters:

	f	- the callback function
	param	- generic parameter to be used when calling the callback functions

Returns:

1 on success, 0 on failure

Definition at line 136 of file diameter_api.c.

References handler_t::handler, handlers, handlers_lock, handler_list_t::head, handler_t::next, handler_t::param, handler_t::prev, RESPONSE_HANDLER, handler_t::responseHandler, handler_list_t::tail, and handler_t::type.

Referenced by load_cdp().

{
    handler *h = shm_malloc(sizeof(handler));
    if (!h) {
        LOG(L_ERR,"ERR:AAAAddResponseHandler: error allocating %d bytes in shm\n",
            sizeof(handler));
        return 0;
    }
    h->type = RESPONSE_HANDLER;
    h->handler.responseHandler = f;
    h->param = param;
    h->next = 0;
    lock_get(handlers_lock);
    h->prev = handlers->tail;
    if (handlers->tail) handlers->tail->next = h;
    handlers->tail = h;
    if (!handlers->head) handlers->head = h;
    lock_release(handlers_lock);
    return 1;
}

AAAReturnCode AAASendMessage	(	AAAMessage *	message,
		AAATransactionCallback_f *	callback_f,
		void *	callback_param
	)

Send a AAAMessage asynchronously.

When the response is received, the callback_f(callback_param,...) is called.

Parameters:

	message	- the request to be sent
	peer_id	- FQDN of the peer to send
	callback_f	- callback to be called on transactional response or transaction timeout
	callback_param	- generic parameter to call the transactional callback function with

Returns:

1 on success, 0 on failure

Todo:

remove peer_id and add Realm routing

Definition at line 170 of file diameter_api.c.

References AAAFreeMessage(), add_trans(), DP_TRANS_TIMEOUT, _peer_t::fqdn, get_routing_peer(), I_Open, is_req, peer_send_msg(), R_Open, and _peer_t::state.

Referenced by load_cdp().

{
    peer *p;
    p = get_routing_peer(message);
    if (!p) {
        LOG(L_ERR,"ERROR:AAASendMessage(): Can't find a suitable connected peer in the routing table.\n");
        goto error;
    }
    if (p->state!=I_Open && p->state!=R_Open){
        LOG(L_ERR,"ERROR:AAASendMessage(): Peer not connected to %.*s\n",p->fqdn.len,p->fqdn.s);
        goto error;
    }
    /* only add transaction following when required */
    if (callback_f){
        if (is_req(message))
            add_trans(message,callback_f,callback_param,DP_TRANS_TIMEOUT,1);
        else
            LOG(L_ERR,"ERROR:AAASendMessage(): can't add transaction callback for answer.\n");
    }
        
    if (!peer_send_msg(p,message))
        goto error;
        
    return 1;
error:  
    AAAFreeMessage(&message);
    return 0;
}

AAAReturnCode AAASendMessageToPeer	(	AAAMessage *	message,
		str *	peer_id,
		AAATransactionCallback_f *	callback_f,
		void *	callback_param
	)

Send a AAAMessage asynchronously.

When the response is received, the callback_f(callback_param,...) is called.

Parameters:

	message	- the request to be sent
	peer_id	- FQDN of the peer to send
	callback_f	- callback to be called on transactional response or transaction timeout
	callback_param	- generic parameter to call the transactional callback function with

Returns:

1 on success, 0 on failure

Todo:

remove peer_id and add Realm routing

Definition at line 212 of file diameter_api.c.

References AAAFreeMessage(), add_trans(), DP_TRANS_TIMEOUT, get_peer_by_fqdn(), I_Open, is_req, peer_send_msg(), R_Open, and _peer_t::state.

Referenced by load_cdp().

{
    peer *p;
    p = get_peer_by_fqdn(peer_id);
    if (!p) {
        LOG(L_ERR,"ERROR:AAASendMessageToPeer(): Peer unknown %.*s\n",peer_id->len,peer_id->s);
        goto error;
    }
    if (p->state!=I_Open && p->state!=R_Open){
        LOG(L_ERR,"ERROR:AAASendMessageToPeer(): Peer not connected to %.*s\n",peer_id->len,peer_id->s);
        goto error;
    }
    /* only add transaction following when required */
    if (callback_f){
        if (is_req(message))
            add_trans(message,callback_f,callback_param,DP_TRANS_TIMEOUT,1);
        else
            LOG(L_ERR,"ERROR:AAASendMessageToPeer(): can't add transaction callback for answer.\n");
    }
        
    if (!peer_send_msg(p,message))
        goto error;
        
    return 1;
error:  
    AAAFreeMessage(&message);
    return 0;
}

void sendrecv_cb	(	int	is_timeout,
		void *	param,
		AAAMessage *	ans
	)

Generic callback used by AAASendRecvMessage() to block until a transactional response is received.

The AAASendRecvMessage() is basically a AAASendMessage() that has a callback (this function) that blocks until a transactional response or timeout is received and then it returns that.

Parameters:

	is_timeout	- if this is a time-out or response event
	param	- generic parameter to call the transactional callback function with
	ans	- the answer for the callback

Definition at line 257 of file diameter_api.c.

Referenced by AAASendRecvMessage(), and AAASendRecvMessageToPeer().

{
    lock_release((gen_lock_t*)param);
}

AAAMessage* AAASendRecvMessage

(

AAAMessage *

message

)

Send a AAAMessage synchronously.

This blocks until a response is received or a transactional time-out happens.

Parameters:

	message	- the request to be sent
	peer_id	- FQDN of the peer to send

Returns:

1 on success, 0 on failure

Todo:

remove peer_id and add Realm routing

Todo:

replace the busy-waiting lock in here with one that does not consume CPU

Definition at line 271 of file diameter_api.c.

References AAAFreeMessage(), add_trans(), _cdp_trans_t::ans, DP_TRANS_TIMEOUT, _peer_t::fqdn, free_trans(), get_routing_peer(), I_Open, is_req, peer_send_msg(), R_Open, sendrecv_cb(), and _peer_t::state.

Referenced by load_cdp().

{
    peer *p;
    gen_lock_t *lock;
    cdp_trans_t *t;
    AAAMessage *ans;
    
    p = get_routing_peer(message);
    if (!p) {
        LOG(L_ERR,"ERROR:AAASendRecvMessage(): Can't find a suitable connected peer in the routing table.\n");
        goto error;
    }
    if (p->state!=I_Open && p->state!=R_Open){
        LOG(L_ERR,"ERROR:AAASendRecvMessage(): Peer not connected to %.*s\n",p->fqdn.len,p->fqdn.s);
        goto error;
    }
    
    
    if (is_req(message)){
        lock = lock_alloc();
        lock = lock_init(lock);
        lock_get(lock);
        t = add_trans(message,sendrecv_cb,(void*)lock,DP_TRANS_TIMEOUT,0);

        if (!peer_send_msg(p,message)) {
            lock_destroy(lock);
            lock_dealloc((void*)lock);  
            goto error;
        }

        /* block until callback is executed */
        lock_get(lock);     
        lock_destroy(lock);
        lock_dealloc((void*)lock);
        ans = t->ans;
        free_trans(t);
        return ans;
    }
    else
    {
        LOG(L_ERR,"ERROR:AAASendRecvMessage(): can't add wait for answer to answer.\n");
        goto error;
    }

        
error:  
    AAAFreeMessage(&message);
    return 0;
}

AAAMessage* AAASendRecvMessageToPeer	(	AAAMessage *	message,
		str *	peer_id
	)

Send a AAAMessage synchronously.

This blocks until a response is received or a transactional time-out happens.

Parameters:

	message	- the request to be sent
	peer_id	- FQDN of the peer to send

Returns:

1 on success, 0 on failure

Todo:

remove peer_id and add Realm routing

Todo:

replace the busy-waiting lock in here with one that does not consume CPU

Definition at line 330 of file diameter_api.c.

References AAAFreeMessage(), add_trans(), _cdp_trans_t::ans, DP_TRANS_TIMEOUT, free_trans(), get_peer_by_fqdn(), I_Open, is_req, peer_send_msg(), R_Open, sendrecv_cb(), and _peer_t::state.

Referenced by load_cdp().

{
    peer *p;
    gen_lock_t *lock;
    cdp_trans_t *t;
    AAAMessage *ans;
    
    p = get_peer_by_fqdn(peer_id);
    if (!p) {
        LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): Peer unknown %.*s\n",peer_id->len,peer_id->s);
        goto error;
    }
    if (p->state!=I_Open && p->state!=R_Open){
        LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): Peer not connected to %.*s\n",peer_id->len,peer_id->s);
        goto error;
    }
    
    
    if (is_req(message)){
        lock = lock_alloc();
        lock = lock_init(lock);
        lock_get(lock);
        t = add_trans(message,sendrecv_cb,(void*)lock,DP_TRANS_TIMEOUT,0);

        if (!peer_send_msg(p,message)) {
            lock_destroy(lock);
            lock_dealloc((void*)lock);  
            goto error;
        }

        /* block until callback is executed */
        lock_get(lock);     
        lock_destroy(lock);
        lock_dealloc((void*)lock);
        ans = t->ans;
        free_trans(t);
        return ans;
    }
    else
    {
        LOG(L_ERR,"ERROR:AAASendRecvMessageToPeer(): can't add wait for answer to answer.\n");
        goto error;
    }

        
error:  
    AAAFreeMessage(&message);
    return 0;
}

---

Variable Documentation

handler_list* handlers

list of handlers

Definition at line 60 of file api_process.c.

gen_lock_t* handlers_lock

lock for list of handlers

Definition at line 61 of file api_process.c.

---