diameter_api.c

Go to the documentation of this file.

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

                /* TRANSACTIONS */
                
AAATransaction *AAACreateTransaction(AAAApplicationId app_id,AAACommandCode cmd_code)
{
    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)
{
    if (!trans) return 0;
//  LOG(L_ERR,"\nCALLED HERE %d %d\n",trans->done,trans->with_callback);
    shm_free(trans);
    return 1;
}


                /* CALLBACKS */

extern handler_list *handlers;      
extern gen_lock_t *handlers_lock;   
int AAAAddRequestHandler(AAARequestHandler_f *f,void *param)
{
    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)
{
    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;
}


                /* MESSAGE SENDING */

AAAReturnCode AAASendMessage(   
        AAAMessage *message,
        AAATransactionCallback_f *callback_f,
        void *callback_param)
{
    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)
{
    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)
{
    lock_release((gen_lock_t*)param);
}

AAAMessage* AAASendRecvMessage(AAAMessage *message)
{
    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)
{
    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;
}

---