diameter_peer.c File Reference

---

Detailed Description

CDiameterPeer General procedures for init/start-up/shut-down.

Author:

Dragos Vingarzan vingarzan -at- fokus dot fraunhofer dot de

Definition in file diameter_peer.c.

#include <stdlib.h>
#include <sys/wait.h>
#include <signal.h>
#include <stdio.h>
#include "utils.h"
#include "diameter_peer.h"
#include "config.h"
#include "acceptor.h"
#include "timer.h"
#include "peermanager.h"
#include "worker.h"
#include "api_process.h"
#include "transaction.h"
#include "session.h"
#include "../../pt.h"

Go to the source code of this file.

Functions
int	dp_add_pid (pid_t pid)
	Add a pid to the local process list.
int	dp_last_pid ()
	Returns the last pid in the local process list.
void	dp_del_pid (pid_t pid)
	Delete a pid from the process list.
int	diameter_peer_init (char *cfg_filename)
	Initialize the CDiameterPeer from a configuration file.
int	diameter_peer_start (int blocking)
	Start the CDiameterPeer operations.
void	diameter_peer_destroy ()
	Shutdown the CDiameterPeer nicely.
Variables
dp_config *	config = 0
	Configuration for this diameter peer.
int *	shutdownx = 0
	whether a shutdown is in progress
gen_lock_t *	shutdownx_lock
	lock used on shutdown
pid_t *	dp_first_pid
	first pid that we started from
pid_list_head_t *	pid_list
	list of local processes
gen_lock_t *	pid_list_lock
	lock for list of local processes
handler_list *	handlers
	list of handlers
gen_lock_t *	handlers_lock
	lock for list of handlers
int	memlog

---

Function Documentation

int dp_add_pid

(

pid_t

pid

)

[inline]

Add a pid to the local process list.

Parameters:

pid

newly forked pid

Returns:

1 on success or 0 on error

Definition at line 95 of file diameter_peer.c.

References pid_list_head_t::head, LOG_NO_MEM, _pid_list_t::next, _pid_list_t::pid, pid_list, pid_list_lock, _pid_list_t::prev, and pid_list_head_t::tail.

{
    pid_list_t *n;
    lock_get(pid_list_lock);
    n = shm_malloc(sizeof(pid_list_t));
    if (!n){
        LOG_NO_MEM("shm",sizeof(pid_list_t));
        lock_release(pid_list_lock);
        return 0;
    }
    n->pid = pid;
    n->next = 0;
    n->prev = pid_list->tail;
    if (!pid_list->head) pid_list->head = n;
    if (pid_list->tail) pid_list->tail->next = n;
    pid_list->tail = n;
    lock_release(pid_list_lock);
    return 1;
}

int dp_last_pid

(

)

[inline]

Returns the last pid in the local process list.

Definition at line 118 of file diameter_peer.c.

References _pid_list_t::pid, pid_list, pid_list_lock, and pid_list_head_t::tail.

Referenced by diameter_peer_destroy().

{
    int pid;
    lock_get(pid_list_lock);
    if (pid_list->tail) pid = pid_list->tail->pid;
    else pid = -1;
    lock_release(pid_list_lock);
    return pid;
}

void dp_del_pid

(

pid_t

pid

)

[inline]

Delete a pid from the process list.

Parameters:

pid

- the pid to remove

Definition at line 132 of file diameter_peer.c.

References pid_list_head_t::head, _pid_list_t::next, _pid_list_t::pid, pid_list, pid_list_lock, _pid_list_t::prev, and pid_list_head_t::tail.

{   
    pid_list_t *i;
    lock_get(pid_list_lock);
    i = pid_list->head;
    if (!i) {
        lock_release(pid_list_lock);
        return;
    }
    while(i && i->pid!=pid) i = i->next;
    if (i){
        if (i->prev) i->prev->next = i->next;
        else pid_list->head = i->next;
        if (i->next) i->next->prev = i->prev;
        else pid_list->tail = i->prev;
        shm_free(i);
    }
    lock_release(pid_list_lock);
}

int diameter_peer_init

(

char *

cfg_filename

)

Initialize the CDiameterPeer from a configuration file.

The file is kept as dtd. See configdtd.h for the DTD and ConfigExample.xml.

Parameters:

cfg_filename

- file with the configuration

Returns:

1 on success, 0 on error

Definition at line 159 of file diameter_peer.c.

References api_callback(), cb_add(), config, dp_first_pid, free_dp_config(), handlers, handlers_lock, handler_list_t::head, pid_list_head_t::head, log_dp_config(), LOG_NO_MEM, _pid_list_t::next, parse_dp_config(), peer_manager_init(), pid_list, pid_list_lock, session_init(), shutdownx, shutdownx_lock, handler_list_t::tail, timer_cdp_init(), trans_init(), and worker_init().

Referenced by cdp_init().

{   
    pid_list_t *i,*j;

    config = parse_dp_config(cfg_filename);
    if (!config) {
        LOG(L_ERR,"ERROR:init_diameter_peer(): Error loading configuration file. Aborting...\n");
        goto error;
    }
    log_dp_config(L_INFO,config);
    
    dp_first_pid = shm_malloc(sizeof(pid_t));
    if (!dp_first_pid){
        LOG_NO_MEM("shm",sizeof(pid_t));
        goto error;
    }
    *dp_first_pid = getpid();
    
    shutdownx = shm_malloc(sizeof(int));
    if (!shutdownx){
        LOG_NO_MEM("shm",sizeof(int));
        goto error;
    }
    *shutdownx = 0;
    
    shutdownx_lock = lock_alloc();
    if (!shutdownx_lock){
        LOG_NO_MEM("shm",sizeof(gen_lock_t));
        goto error;
    }
    shutdownx_lock = lock_init(shutdownx_lock);

    handlers_lock = lock_alloc();
    if (!handlers_lock){
        LOG_NO_MEM("shm",sizeof(gen_lock_t));
        goto error;
    }
    handlers_lock = lock_init(handlers_lock);

    handlers = shm_malloc(sizeof(handler_list));
    if (!handlers){
        LOG_NO_MEM("shm",sizeof(handler_list));
        goto error;
    }
    handlers->head=0;
    handlers->tail=0;

    /* init the pid list */
    pid_list = shm_malloc(sizeof(pid_list_head_t));
    pid_list_lock = lock_alloc();
    pid_list_lock = lock_init(pid_list_lock);

    /* init shared mem pointers before forking */
    timer_cdp_init();
    worker_init();

    /* init the peer manager */
    peer_manager_init(config);
    
    /* init the session */
    if (!session_init()) goto error;
    

    /* init diameter transactions */
    trans_init();
    
    /* add callback for messages - used to implement the API */
    cb_add(api_callback,0);
    
    return 1;
    
error:
    if (shutdownx) shm_free(shutdownx);
    if (config) free_dp_config(config);
    i = pid_list->head;
    while(i){
        j = i->next;
        shm_free(i);
        i = j;
    }
    shm_free(pid_list);
    lock_get(pid_list_lock);
    lock_destroy(pid_list_lock);
    lock_dealloc((void*)pid_list_lock);
    return 0;   

}

int diameter_peer_start

(

int

blocking

)

Start the CDiameterPeer operations.

It forks all the processes required.

Parameters:

blocking

- if this is set, use the calling processes for the timer and never return; else fork a new one for the timer and return

Returns:

1 on success, 0 on error, never if blocking

Definition at line 255 of file diameter_peer.c.

References acceptor_process(), CDP_FOR_SER, config, dp_add_pid(), process_no, timer_process(), worker_process(), and dp_config::workers.

Referenced by cdp_child_init().

{
    int pid;
    int k=0;


    /* Fork the acceptor process */
    #ifdef CDP_FOR_SER      
        pid = fork_process(1000,"cdp_acceptor",1);
    #else
        pid = fork();
    #endif
    if (pid==-1){
        LOG(L_CRIT,"ERROR:init_diameter_peer(): Error on fork() for acceptor!\n");
        return 0;
    }
    if (pid==0) {
        acceptor_process(config);
        LOG(L_CRIT,"ERROR:init_diameter_peer(): acceptor_process finished without exit!\n");
        exit(-1);       
    }else{
        dp_add_pid(pid);
    }

    /* fork workers */
    for(k=0;k<config->workers;k++){
        #ifdef CDP_FOR_SER      
            pid = fork_process(1001+k,"cdp_worker",1);
        #else
            pid = fork();
        #endif
        if (pid==-1){
            LOG(L_CRIT,"ERROR:init_diameter_peer(): Error on fork() for worker!\n");
            return 0;
        }
        if (pid==0) {
            srandom(time(0)*k);
            #ifdef CDP_FOR_SER
                snprintf(pt[process_no].desc, MAX_PT_DESC,
                    "cdp worker child=%d", k );
            #endif  
            worker_process(k);
            LOG(L_CRIT,"ERROR:init_diameter_peer(): worker_process finished without exit!\n");
            exit(-1);       
        }else{
            dp_add_pid(pid);
        }
    }
                
    /* fork/become timer */
    if (blocking) {
        dp_add_pid(getpid());
        timer_process(1);
    }       
    else{       
        #ifdef CDP_FOR_SER      
            pid = fork_process(1001,"cdp_timer",1);
        #else
            pid = fork();
        #endif
        if (pid==-1){
            LOG(L_CRIT,"ERROR:init_diameter_peer(): Error on fork() for timer!\n");
            return 0;
        }
        if (pid==0) {
            timer_process(0);
            LOG(L_CRIT,"ERROR:init_diameter_peer(): timer_process finished without exit!\n");
            exit(-1);       
        }else{          
            dp_add_pid(pid);
        }
    }
    
    return 1;
}

void diameter_peer_destroy

(

)

Shutdown the CDiameterPeer nicely.

It stops the workers, disconnects peers, drops timers and wait for all processes to exit.

Definition at line 337 of file diameter_peer.c.

References config, dp_del_pid(), dp_first_pid, dp_last_pid(), free_dp_config(), handlers, handlers_lock, handler_list_t::head, memlog, handler_t::next, peer_manager_destroy(), pid_list, pid_list_lock, session_destroy(), shutdownx, shutdownx_lock, pid_list_head_t::tail, timer_cdp_destroy(), worker_destroy(), and worker_poison_queue().

Referenced by cdp_exit().

{
    int pid,status;
    handler *h;
    
    lock_get(shutdownx_lock);
    if (*shutdownx) {
        /* already other process is cleaning stuff */
        lock_release(shutdownx_lock);           
        return;
    }else {
        /* indicating that we are shuting down */
        *shutdownx = 1;
        lock_release(shutdownx_lock);
    }


    worker_poison_queue();

    /* wait for all childs to clean up nicely (acceptor, receiver, timer, workers) */
    LOG(L_INFO,"INFO:destroy_diameter_peer(): Terminating all childs...\n");
    while(pid_list->tail){
        pid = dp_last_pid();
        if (pid<=0||pid==getpid()){
            dp_del_pid(pid);
            continue;
        }
        LOG(L_INFO,"INFO:destroy_diameter_peer(): Waiting for child [%d] to terminate...\n",pid);
        if (waitpid(pid,&status,0)<0){
            dp_del_pid(pid);
            continue;
        }
        if (!WIFEXITED(status) /*|| WIFSIGNALED(status)*/){
            worker_poison_queue();
            sleep(1);           
        } else {
            dp_del_pid(pid);
        }

    }
    LOG(L_INFO,"INFO:destroy_diameter_peer(): All processes terminated. Cleaning up.\n");
    
    /* clean upt the timer */
    timer_cdp_destroy();
    
    /* cleaning up workers */
    worker_destroy();
    
    /* cleaning peer_manager */
    peer_manager_destroy();
    
    /* cleaning up sessions */
    session_destroy();

    /* cleaning up global vars */
/*  lock_get(pid_list_lock);*/
    shm_free(dp_first_pid);
    shm_free(pid_list);
    lock_destroy(pid_list_lock);
    lock_dealloc((void*)pid_list_lock);
    
    shm_free(shutdownx);
    
    lock_destroy(shutdownx_lock);
    lock_dealloc((void*)shutdownx_lock);
    
    lock_get(handlers_lock);
    while(handlers->head){
        h = handlers->head->next;
        shm_free(handlers->head);
        handlers->head = h;
    }
    lock_destroy(handlers_lock);
    lock_dealloc((void*)handlers_lock);
    shm_free(handlers);
        
    free_dp_config(config); 
    LOG(L_CRIT,"INFO:destroy_diameter_peer(): Bye Bye from C Diameter Peer test\n");

#ifndef CDP_FOR_SER
    #ifdef PKG_MALLOC
        LOG(memlog, "Memory status (pkg):\n");
        //pkg_status();
        #ifdef pkg_sums
            pkg_sums();
        #endif 
    #endif
    #ifdef SHM_MEM
        LOG(memlog, "Memory status (shm):\n");
        //shm_status();
        #ifdef shm_sums
            shm_sums();
        #endif 
        /* zero all shmem alloc vars that we still use */
        shm_mem_destroy();
    #endif
#endif  
}

---

Variable Documentation

dp_config* config = 0

Configuration for this diameter peer.

Definition at line 76 of file diameter_peer.c.

int* shutdownx = 0

whether a shutdown is in progress

Definition at line 78 of file diameter_peer.c.

Referenced by accept_loop(), cdp_lock_get(), cdp_lock_release(), diameter_peer_destroy(), diameter_peer_init(), put_task(), receive_loop(), select_recv(), take_task(), timer_loop(), and worker_process().

gen_lock_t* shutdownx_lock

lock used on shutdown

Definition at line 79 of file diameter_peer.c.

Referenced by diameter_peer_destroy(), and diameter_peer_init().

pid_t* dp_first_pid

first pid that we started from

Definition at line 81 of file diameter_peer.c.

Referenced by diameter_peer_destroy(), and diameter_peer_init().

pid_list_head_t* pid_list

list of local processes

Definition at line 83 of file diameter_peer.c.

Referenced by diameter_peer_destroy(), diameter_peer_init(), dp_add_pid(), dp_del_pid(), and dp_last_pid().

gen_lock_t* pid_list_lock

lock for list of local processes

Definition at line 84 of file diameter_peer.c.

Referenced by diameter_peer_destroy(), diameter_peer_init(), dp_add_pid(), dp_del_pid(), and dp_last_pid().

handler_list* handlers

list of handlers

Definition at line 60 of file api_process.c.

Referenced by AAAAddRequestHandler(), AAAAddResponseHandler(), api_callback(), diameter_peer_destroy(), and diameter_peer_init().

gen_lock_t* handlers_lock

lock for list of handlers

Definition at line 61 of file api_process.c.

Referenced by AAAAddRequestHandler(), AAAAddResponseHandler(), api_callback(), diameter_peer_destroy(), and diameter_peer_init().

int memlog

Referenced by destroy_memory(), diameter_peer_destroy(), init_memory(), receiver_process(), timer_process(), and worker_process().

---