source: branches/fscctrl_safety_limits/dim/src/conn_handler.c@ 19102

/*
 * DNA (Delphi Network Access) implements the network layer for the DIM
 * (Delphi Information Managment) System.
 *
 * Started date   : 10-11-91
 * Written by     : C. Gaspar
 * UNIX adjustment: G.C. Ballintijn
 *
 */

/* This module can only handle one type of array, and DIC or DNS.
 * It cannot handle both simultaniously. It handles at same time
 * the NET and DNA array's. Although these have to be explicitly
 * created.
 */

#define DIMLIB
#include <dim.h>

static SRC_TYPES My_type;               /* Var. indicating type DIC or DIS */

#ifdef VMS
DIM_NOSHARE DNS_CONNECTION *Dns_conns;
DIM_NOSHARE DIC_CONNECTION *Dic_conns;
DIM_NOSHARE DNA_CONNECTION *Dna_conns;
DIM_NOSHARE NET_CONNECTION *Net_conns;
DIM_NOSHARE int Curr_N_Conns;
#else
DllExp DIM_NOSHARE DNS_CONNECTION *Dns_conns = 0;
DIM_NOSHARE DIC_CONNECTION *Dic_conns = 0;
DllExp DIM_NOSHARE DNA_CONNECTION *Dna_conns = 0;
DllExp DIM_NOSHARE NET_CONNECTION *Net_conns = 0;
DllExp DIM_NOSHARE int Curr_N_Conns = 0;
#endif

typedef struct id_item
{
        void *ptr;
        SRC_TYPES type;
}ID_ITEM;

static ID_ITEM *Id_arr;
/*
static void **Id_arr;
*/
static int Curr_N_Ids = 0;
static int Curr_id = 1;

void conn_arr_create(SRC_TYPES type)
{

        if( Curr_N_Conns == 0 )
                Curr_N_Conns = CONN_BLOCK;

        switch(type)
        {
        case SRC_DIC :
                Dic_conns = (DIC_CONNECTION *)
                                calloc( (size_t)Curr_N_Conns, sizeof(DIC_CONNECTION) );
                My_type = type;
                break;
        case SRC_DNS :
                Dns_conns = (DNS_CONNECTION *)
                                calloc( (size_t)Curr_N_Conns, sizeof(DNS_CONNECTION) );
                My_type = type;
                break;
        case SRC_DNA :
                Dna_conns = (DNA_CONNECTION *)
                                calloc( (size_t)Curr_N_Conns, sizeof(DNA_CONNECTION) );
                Net_conns = (NET_CONNECTION *)
                                calloc( (size_t)Curr_N_Conns, sizeof(NET_CONNECTION) );
                break;
        default:
                break;
        }
}


int conn_get()
{
        register DNA_CONNECTION *dna_connp;
        int i, n_conns, conn_id;

        DISABLE_AST
        for( i = 1, dna_connp = &Dna_conns[1]; i < Curr_N_Conns; i++, dna_connp++ )
        {
                if( !dna_connp->busy )
                {
                        dna_connp->busy = TRUE;
                        ENABLE_AST
                        return(i);
                }
        }
        n_conns = Curr_N_Conns + CONN_BLOCK;
        Dna_conns = arr_increase( Dna_conns, sizeof(DNA_CONNECTION), n_conns );
        Net_conns = arr_increase( Net_conns, sizeof(NET_CONNECTION), n_conns );
        switch(My_type)
        {
        case SRC_DIC :
                Dic_conns = arr_increase( Dic_conns, sizeof(DIC_CONNECTION),
                                          n_conns );
                break;
        case SRC_DNS :
                Dns_conns = arr_increase( Dns_conns, sizeof(DNS_CONNECTION),
                                          n_conns );
                break;
        default:
                break;
        }
        conn_id = Curr_N_Conns;
        Curr_N_Conns = n_conns;
        Dna_conns[conn_id].busy = TRUE;
        ENABLE_AST
        return(conn_id);
}


void conn_free(int conn_id)
{
        DISABLE_AST
        Dna_conns[conn_id].busy = FALSE;
        ENABLE_AST
}


void *arr_increase(void *conn_ptr, int conn_size, int n_conns)
{
        register char *new_ptr;

        new_ptr = realloc( conn_ptr, (size_t)(conn_size * n_conns) );
        memset( new_ptr + conn_size * Curr_N_Conns, 0, (size_t)(conn_size * CONN_BLOCK) );
        return(new_ptr);
}

void id_arr_create()
{

        Curr_N_Ids = ID_BLOCK;
        Id_arr = (void *) calloc( (size_t)Curr_N_Ids, sizeof(ID_ITEM));
}


void *id_arr_increase(void *id_ptr, int id_size, int n_ids)
{
        register char *new_ptr;

        new_ptr = realloc( id_ptr, (size_t)(id_size * n_ids) );
        memset( new_ptr + id_size * Curr_N_Ids, 0, (size_t)(id_size * ID_BLOCK) );
        return(new_ptr);
}

int id_get(void *ptr, SRC_TYPES type)
{
        register int i, id;
        register ID_ITEM *idp;

        DISABLE_AST
        if(!Curr_N_Ids)
        {
                id_arr_create();
        }
        for( i = Curr_id, idp = &Id_arr[Curr_id]; i < Curr_N_Ids; i++, idp++ )
        {
                if( !idp->type )
                {
                        idp->ptr = ptr;
                        idp->type = type;
                        Curr_id = i;
                        ENABLE_AST
                        return(i);
                }
        }
        Id_arr = id_arr_increase( Id_arr, sizeof(ID_ITEM), Curr_N_Ids + ID_BLOCK );
        id = Curr_N_Ids;
        idp = &Id_arr[id];
        idp->ptr = ptr;
        idp->type = type;
        Curr_N_Ids += ID_BLOCK;
        Curr_id = id;
        ENABLE_AST
        return(id);
}

void *id_get_ptr(int id, SRC_TYPES type)
{
        ID_ITEM *idp;
        void *ptr;
        DISABLE_AST

        if((id >= Curr_N_Ids) || (id <= 0))
        {
                ENABLE_AST
                return(0);
        }
        idp = &Id_arr[id];
        if(idp->type == type)
        {
                ptr = idp->ptr;
                ENABLE_AST
                return(ptr);
        }
        ENABLE_AST
        return(0);
}

void id_free(int id, SRC_TYPES type)
{
        ID_ITEM *idp;
        DISABLE_AST

        idp = &Id_arr[id];
        if(idp->type == type)
        {
                idp->type = 0;
                idp->ptr = 0;
        }
        Curr_id = 1;
        ENABLE_AST
}