timer.c

Go to the documentation of this file.

#include <time.h> 
#include <stdlib.h>
#include <unistd.h>

#include "utils.h"
#include "globals.h"
#include "worker.h"

#include "timer.h"


/* defined in ../diameter_peer.c */
int dp_add_pid(pid_t pid);
void dp_del_pid(pid_t pid);


timer_cb_list_t *timers=0;  
gen_lock_t *timers_lock=0;  
#define TIMER_RESOLUTION 1

void timer_loop()
{
    time_t now;
    timer_cb_t *i;
    callback_f cb=0;
    void *ptr=0;
    
    while(1){
        if (shutdownx && *shutdownx) break;
        now = time(0);
        //LOG(L_DBG,"DBG:timer_loop(): The time is %u\n",(unsigned int)now);
    
        do {
            cb = 0;
            lock_get(timers_lock);
            i = timers->head;
            while(i && i->expires>now) i = i->next;
            if (i){
                cb = i->cb;
                ptr = *(i->ptr);
                if (i->one_time){
                    if (i->prev) i->prev->next = i->next;
                    else timers->head = i->next;
                    if (i->next) i->next->prev = i->prev;
                    else timers->tail = i->next;
                    shm_free(i);
                }else{
                    i->expires = now + i->interval;
                }
            }
            lock_release(timers_lock);
    
            if (cb) cb(now,ptr);
    
        } while(cb);
                
        sleep(TIMER_RESOLUTION);
    }
}

int add_timer(int expires_in,int one_time,callback_f cb,void *ptr)
{
    timer_cb_t *n;
    if (expires_in==0){
        LOG(L_ERR,"ERROR:add_timer(): Minimum expiration time is 1 second!\n");
        return 0;
    }
    n = shm_malloc(sizeof(timer_cb_t));
    if (!n){
        LOG_NO_MEM("shm",sizeof(timer_cb_t));
        return 0;
    }
    n->ptr = shm_malloc(sizeof(void*));
    if (!n){
        LOG_NO_MEM("shm",sizeof(void*));
        shm_free(n);
        return 0;
    }
    n->expires = expires_in + time(0);
    n->one_time = one_time;
    n->interval = expires_in;
    n->cb = cb;
    *(n->ptr) = ptr;

    lock_get(timers_lock);
        n->prev = timers->tail;
        n->next = 0;
        if (!timers->head) timers->head = n;
        if (timers->tail) timers->tail->next = n;
        timers->tail = n;
    lock_release(timers_lock);
    return 1;
}

void timer_cdp_init()
{
    timers = shm_malloc(sizeof(timer_cb_list_t));
    timers->head=0;
    timers->tail=0;
    timers_lock = lock_alloc();
    timers_lock = lock_init(timers_lock);   
}

void timer_cdp_destroy()
{
    timer_cb_t *n,*i;
/*  lock_get(timers_lock);*/
    i = timers->head;
    while(i){
        n = i->next;
        if (i->ptr) shm_free(i->ptr);
        shm_free(i);
        i = n;
    }
    shm_free(timers);
    lock_destroy(timers_lock);
    lock_dealloc((void*)timers_lock);
}

void timer_process(int returns)
{
    LOG(L_INFO,"INFO:Timer process starting up...\n");
        
    timer_loop();
    
    LOG(L_INFO,"INFO:... Timer process finished\n");
    if (!returns) {
#ifdef CDP_FOR_SER
#else
#ifdef PKG_MALLOC
    #ifdef PKG_MALLOC
        LOG(memlog, "Timer Memory status (pkg):\n");
        //pkg_status();
        #ifdef pkg_sums
            pkg_sums();
        #endif 
    #endif
#endif
        dp_del_pid(getpid());       
#endif      
        
        exit(0);
    }
}

---