asLibRoutines.c File Reference

#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "osiSock.h"
#include "epicsTypes.h"
#include "epicsStdio.h"
#include "dbDefs.h"
#include "epicsThread.h"
#include "cantProceed.h"
#include "epicsMutex.h"
#include "errlog.h"
#include "gpHash.h"
#include "freeList.h"
#include "macLib.h"
#include "postfix.h"
#include "asLib.h"

Include dependency graph for asLibRoutines.c:

Go to the source code of this file.

Macros
#define	LOCK   epicsMutexMustLock(asLock)
#define	UNLOCK   epicsMutexUnlock(asLock)
#define	DEFAULT   "DEFAULT"
#define	BUF_SIZE   200

Functions
long epicsStdCall	asInitialize (ASINPUTFUNCPTR inputfunction)
long epicsStdCall	asInitFile (const char *filename, const char *substitutions)
long epicsStdCall	asInitFP (FILE *fp, const char *substitutions)
long epicsStdCall	asInitMem (const char *acf, const char *substitutions)
long epicsStdCall	asAddMember (ASMEMBERPVT *pasMemberPvt, const char *asgName)
long epicsStdCall	asRemoveMember (ASMEMBERPVT *asMemberPvt)
long epicsStdCall	asChangeGroup (ASMEMBERPVT *asMemberPvt, const char *newAsgName)
void *epicsStdCall	asGetMemberPvt (ASMEMBERPVT asMemberPvt)
void epicsStdCall	asPutMemberPvt (ASMEMBERPVT asMemberPvt, void *userPvt)
long epicsStdCall	asAddClient (ASCLIENTPVT *pasClientPvt, ASMEMBERPVT asMemberPvt, int asl, const char *user, char *host)
long epicsStdCall	asChangeClient (ASCLIENTPVT asClientPvt, int asl, const char *user, char *host)
long epicsStdCall	asRemoveClient (ASCLIENTPVT *asClientPvt)
long epicsStdCall	asRegisterClientCallback (ASCLIENTPVT asClientPvt, ASCLIENTCALLBACK pcallback)
void *epicsStdCall	asGetClientPvt (ASCLIENTPVT asClientPvt)
void epicsStdCall	asPutClientPvt (ASCLIENTPVT asClientPvt, void *userPvt)
long epicsStdCall	asComputeAllAsg (void)
long epicsStdCall	asComputeAsg (ASG *pasg)
long epicsStdCall	asCompute (ASCLIENTPVT asClientPvt)
int epicsStdCall	asDump (void(*memcallback)(struct asgMember *, FILE *), void(*clientcallback)(struct asgClient *, FILE *), int verbose)
int epicsStdCall	asDumpFP (FILE *fp, void(*memcallback)(struct asgMember *, FILE *), void(*clientcallback)(struct asgClient *, FILE *), int verbose)
int epicsStdCall	asDumpUag (const char *uagname)
int epicsStdCall	asDumpUagFP (FILE *fp, const char *uagname)
int epicsStdCall	asDumpHag (const char *hagname)
int epicsStdCall	asDumpHagFP (FILE *fp, const char *hagname)
int epicsStdCall	asDumpRules (const char *asgname)
int epicsStdCall	asDumpRulesFP (FILE *fp, const char *asgname)
int epicsStdCall	asDumpMem (const char *asgname, void(*memcallback)(ASMEMBERPVT, FILE *), int clients)
int epicsStdCall	asDumpMemFP (FILE *fp, const char *asgname, void(*memcallback)(ASMEMBERPVT, FILE *), int clients)
LIBCOM_API int epicsStdCall	asDumpHash (void)
LIBCOM_API int epicsStdCall	asDumpHashFP (FILE *fp)
LIBCOM_API void *epicsStdCall	asCalloc (size_t nobj, size_t size)
LIBCOM_API char *epicsStdCall	asStrdup (unsigned char *str)
void	asFreeAll (ASBASE *pasbase)

Variables
int	asCheckClientIP
ASBASE volatile *	pasbase =NULL
int	asActive = FALSE

Macro Definition Documentation

#define BUF_SIZE   200

Definition at line 187 of file asLibRoutines.c.

#define DEFAULT   "DEFAULT"

Definition at line 45 of file asLibRoutines.c.

#define LOCK   epicsMutexMustLock(asLock)

Definition at line 34 of file asLibRoutines.c.

#define UNLOCK   epicsMutexUnlock(asLock)

Definition at line 35 of file asLibRoutines.c.

Function Documentation

long epicsStdCall asAddClient	(	ASCLIENTPVT *	pasClientPvt,
		ASMEMBERPVT	asMemberPvt,
		int	asl,
		const char *	user,
		char *	host
	)

Definition at line 362 of file asLibRoutines.c.

{
    ASGMEMBER   *pasgmember = asMemberPvt;
    ASGCLIENT   *pasgclient;
    int         len, i;

    long        status;
    if(!asActive) return(S_asLib_asNotActive);
    if(!pasgmember) return(S_asLib_badMember);
    pasgclient = freeListCalloc(freeListPvt);
    if(!pasgclient) return(S_asLib_noMemory);
    len = strlen(host);
    for (i = 0; i < len; i++) {
        host[i] = (char)tolower((int)host[i]);
    }
    *pasClientPvt = pasgclient;
    pasgclient->pasgMember = asMemberPvt;
    pasgclient->level = asl;
    pasgclient->user = user;
    pasgclient->host = host;
    LOCK;
    ellAdd(&pasgmember->clientList,&pasgclient->node);
    status = asComputePvt(pasgclient);
    UNLOCK;
    return(status);
}

long epicsStdCall asAddMember	(	ASMEMBERPVT *	pasMemberPvt,
		const char *	asgName
	)

Definition at line 286 of file asLibRoutines.c.

{
    long        status;

    if(!asActive) return(S_asLib_asNotActive);
    LOCK;
    status = asAddMemberPvt(pasMemberPvt,asgName);
    UNLOCK;
    return(status);
}

LIBCOM_API void* epicsStdCall asCalloc	(	size_t	nobj,
		size_t	size
	)

Definition at line 874 of file asLibRoutines.c.

{
    void *p;

    p=callocMustSucceed(nobj,size,"asCalloc");
    return(p);
}

long epicsStdCall asChangeClient	(	ASCLIENTPVT	asClientPvt,
		int	asl,
		const char *	user,
		char *	host
	)

Definition at line 390 of file asLibRoutines.c.

{
    ASGCLIENT   *pasgclient = asClientPvt;
    long        status;
    int         len, i;

    if(!asActive) return(S_asLib_asNotActive);
    if(!pasgclient) return(S_asLib_badClient);
    len = strlen(host);
    for (i = 0; i < len; i++) {
        host[i] = (char)tolower((int)host[i]);
    }
    LOCK;
    pasgclient->level = asl;
    pasgclient->user = user;
    pasgclient->host = host;
    status = asComputePvt(pasgclient);
    UNLOCK;
    return(status);
}

long epicsStdCall asChangeGroup	(	ASMEMBERPVT *	asMemberPvt,
		const char *	newAsgName
	)

Definition at line 322 of file asLibRoutines.c.

{
    ASGMEMBER   *pasgmember;
    long        status;

    if(!asActive) return(S_asLib_asNotActive);
    pasgmember = *asMemberPvt;
    if(!pasgmember) return(S_asLib_badMember);
    LOCK;
    if(pasgmember->pasg) {
        ellDelete(&pasgmember->pasg->memberList,&pasgmember->node);
    } else {
        errMessage(-1,"Logic error in asChangeGroup");
        UNLOCK;
        return(-1);
    }
    status = asAddMemberPvt(asMemberPvt,newAsgName);
    UNLOCK;
    return(status);
}

long epicsStdCall asCompute

(

ASCLIENTPVT

asClientPvt

)

Definition at line 488 of file asLibRoutines.c.

{
    long status;

    if(!asActive) return(S_asLib_asNotActive);
    LOCK;
    status = asComputePvt(asClientPvt);
    UNLOCK;
    return(status);
}

long epicsStdCall asComputeAllAsg

(

void

)

Definition at line 466 of file asLibRoutines.c.

{
    long status;

    if(!asActive) return(S_asLib_asNotActive);
    LOCK;
    status = asComputeAllAsgPvt();
    UNLOCK;
    return(status);
}

long epicsStdCall asComputeAsg

(

ASG *

pasg

)

Definition at line 477 of file asLibRoutines.c.

{
    long status;

    if(!asActive) return(S_asLib_asNotActive);
    LOCK;
    status = asComputeAsgPvt(pasg);
    UNLOCK;
    return(status);
}

int epicsStdCall asDump	(	void(*)(struct asgMember *, FILE *)	memcallback,
		void(*)(struct asgClient *, FILE *)	clientcallback,
		int	verbose
	)

Definition at line 504 of file asLibRoutines.c.

{
    return asDumpFP(stdout,memcallback,clientcallback,verbose);
}

int epicsStdCall asDumpFP	(	FILE *	fp,
		void(*)(struct asgMember *, FILE *)	memcallback,
		void(*)(struct asgClient *, FILE *)	clientcallback,
		int	verbose
	)

Definition at line 512 of file asLibRoutines.c.

{
    UAG         *puag;
    UAGNAME     *puagname;
    HAG         *phag;
    HAGNAME     *phagname;
    ASG         *pasg;
    ASGINP      *pasginp;
    ASGRULE     *pasgrule;
    ASGHAG      *pasghag;
    ASGUAG      *pasguag;
    ASGMEMBER   *pasgmember;
    ASGCLIENT   *pasgclient;

    if(!asActive) return(0);
    puag = (UAG *)ellFirst(&pasbase->uagList);
    if(!puag) fprintf(fp,"No UAGs\n");
    while(puag) {
        fprintf(fp,"UAG(%s)",puag->name);
        puagname = (UAGNAME *)ellFirst(&puag->list);
        if(puagname) fprintf(fp," {"); else fprintf(fp,"\n");
        while(puagname) {
            fprintf(fp,"%s",puagname->user);
            puagname = (UAGNAME *)ellNext(&puagname->node);
            if(puagname) fprintf(fp,","); else fprintf(fp,"}\n");
        }
        puag = (UAG *)ellNext(&puag->node);
    }
    phag = (HAG *)ellFirst(&pasbase->hagList);
    if(!phag) fprintf(fp,"No HAGs\n");
    while(phag) {
        fprintf(fp,"HAG(%s)",phag->name);
        phagname = (HAGNAME *)ellFirst(&phag->list);
        if(phagname) fprintf(fp," {"); else fprintf(fp,"\n");
        while(phagname) {
            fprintf(fp,"%s",phagname->host);
            phagname = (HAGNAME *)ellNext(&phagname->node);
            if(phagname) fprintf(fp,","); else fprintf(fp,"}\n");
        }
        phag = (HAG *)ellNext(&phag->node);
    }
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    if(!pasg) fprintf(fp,"No ASGs\n");
    while(pasg) {
        int print_end_brace;

        fprintf(fp,"ASG(%s)",pasg->name);
        pasginp = (ASGINP *)ellFirst(&pasg->inpList);
        pasgrule = (ASGRULE *)ellFirst(&pasg->ruleList);
        if(pasginp || pasgrule) {
            fprintf(fp," {\n");
            print_end_brace = TRUE;
        } else {
            fprintf(fp,"\n");
            print_end_brace = FALSE;
        }
        while(pasginp) {

            fprintf(fp,"\tINP%c(%s)",(pasginp->inpIndex + 'A'),pasginp->inp);
            if(verbose) {
                if((pasg->inpBad & (1ul << pasginp->inpIndex)))
                        fprintf(fp," INVALID");
                else
                        fprintf(fp,"   VALID");
                fprintf(fp," value=%f",pasg->pavalue[pasginp->inpIndex]);
            }
            fprintf(fp,"\n");
            pasginp = (ASGINP *)ellNext(&pasginp->node);
        }
        while(pasgrule) {
            int print_end_brace;

            fprintf(fp,"\tRULE(%d,%s,%s)",
                pasgrule->level,asAccessName[pasgrule->access],
                asTrapOption[pasgrule->trapMask]);
            pasguag = (ASGUAG *)ellFirst(&pasgrule->uagList);
            pasghag = (ASGHAG *)ellFirst(&pasgrule->hagList);
            if(pasguag || pasghag || pasgrule->calc) {
                fprintf(fp," {\n");
                print_end_brace = TRUE;
            } else {
                fprintf(fp,"\n");
                print_end_brace = FALSE;
            }
            if(pasguag) fprintf(fp,"\t\tUAG(");
            while(pasguag) {
                fprintf(fp,"%s",pasguag->puag->name);
                pasguag = (ASGUAG *)ellNext(&pasguag->node);
                if(pasguag) fprintf(fp,","); else fprintf(fp,")\n");
            }
            pasghag = (ASGHAG *)ellFirst(&pasgrule->hagList);
            if(pasghag) fprintf(fp,"\t\tHAG(");
            while(pasghag) {
                fprintf(fp,"%s",pasghag->phag->name);
                pasghag = (ASGHAG *)ellNext(&pasghag->node);
                if(pasghag) fprintf(fp,","); else fprintf(fp,")\n");
            }
            if(pasgrule->calc) {
                fprintf(fp,"\t\tCALC(\"%s\")",pasgrule->calc);
                if(verbose)
                    fprintf(fp," result=%s",(pasgrule->result==1 ? "TRUE" : "FALSE"));
                fprintf(fp,"\n");
            }
            if(print_end_brace) fprintf(fp,"\t}\n");
            pasgrule = (ASGRULE *)ellNext(&pasgrule->node);
        }
        pasgmember = (ASGMEMBER *)ellFirst(&pasg->memberList);
        if(!verbose) pasgmember = NULL;
        if(pasgmember) fprintf(fp,"\tMEMBERLIST\n");
        while(pasgmember) {
            if(strlen(pasgmember->asgName)==0)
                fprintf(fp,"\t\t<null>");
            else
                fprintf(fp,"\t\t%s",pasgmember->asgName);
            if(memcallback) memcallback(pasgmember,fp);
            fprintf(fp,"\n");
            pasgclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList);
            while(pasgclient) {
                fprintf(fp,"\t\t\t %s %s",pasgclient->user,pasgclient->host);
                if(pasgclient->level>=0 && pasgclient->level<=1)
                        fprintf(fp," %s",asLevelName[pasgclient->level]);
                else
                        fprintf(fp," Illegal Level %d",pasgclient->level);
                if(pasgclient->access<=2)
                        fprintf(fp," %s %s",
                            asAccessName[pasgclient->access],
                            asTrapOption[pasgclient->trapMask]);
                else
                        fprintf(fp," Illegal Access %d",pasgclient->access);
                if(clientcallback) clientcallback(pasgclient,fp);
                fprintf(fp,"\n");
                pasgclient = (ASGCLIENT *)ellNext(&pasgclient->node);
            }
            pasgmember = (ASGMEMBER *)ellNext(&pasgmember->node);
        }
        if(print_end_brace) fprintf(fp,"}\n");
        pasg = (ASG *)ellNext(&pasg->node);
    }
    return(0);
}

int epicsStdCall asDumpHag

(

const char *

hagname

)

Definition at line 688 of file asLibRoutines.c.

{
    return asDumpHagFP(stdout,hagname);
}

int epicsStdCall asDumpHagFP	(	FILE *	fp,
		const char *	hagname
	)

Definition at line 693 of file asLibRoutines.c.

{
    HAG         *phag;
    HAGNAME     *phagname;

    if(!asActive) return(0);
    phag = (HAG *)ellFirst(&pasbase->hagList);
    if(!phag) fprintf(fp,"No HAGs\n");
    while(phag) {
        if(hagname && strcmp(hagname,phag->name)!=0) {
            phag = (HAG *)ellNext(&phag->node);
            continue;
        }
        fprintf(fp,"HAG(%s)",phag->name);
        phagname = (HAGNAME *)ellFirst(&phag->list);
        if(phagname) fprintf(fp," {"); else fprintf(fp,"\n");
        while(phagname) {
            fprintf(fp,"%s",phagname->host);
            phagname = (HAGNAME *)ellNext(&phagname->node);
            if(phagname) fprintf(fp,","); else fprintf(fp,"}\n");
        }
        phag = (HAG *)ellNext(&phag->node);
    }
    return(0);
}

LIBCOM_API int epicsStdCall asDumpHash

(

void

)

Definition at line 860 of file asLibRoutines.c.

{
    return asDumpHashFP(stdout);
}

LIBCOM_API int epicsStdCall asDumpHashFP

(

FILE *

fp

)

Definition at line 865 of file asLibRoutines.c.

{
    if(!asActive) return(0);
    gphDumpFP(fp,pasbase->phash);
    return(0);
}

int epicsStdCall asDumpMem	(	const char *	asgname,
		void(*)(ASMEMBERPVT, FILE *)	memcallback,
		int	clients
	)

Definition at line 803 of file asLibRoutines.c.

{
    return asDumpMemFP(stdout,asgname,memcallback,clients);
}

int epicsStdCall asDumpMemFP	(	FILE *	fp,
		const char *	asgname,
		void(*)(ASMEMBERPVT, FILE *)	memcallback,
		int	clients
	)

Definition at line 809 of file asLibRoutines.c.

{
    ASG         *pasg;
    ASGMEMBER   *pasgmember;
    ASGCLIENT   *pasgclient;

    if(!asActive) return(0);
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    if(!pasg) fprintf(fp,"No ASGs\n");
    while(pasg) {

        if(asgname && strcmp(asgname,pasg->name)!=0) {
            pasg = (ASG *)ellNext(&pasg->node);
            continue;
        }
        fprintf(fp,"ASG(%s)\n",pasg->name);
        pasgmember = (ASGMEMBER *)ellFirst(&pasg->memberList);
        if(pasgmember) fprintf(fp,"\tMEMBERLIST\n");
        while(pasgmember) {
            if(strlen(pasgmember->asgName)==0)
                fprintf(fp,"\t\t<null>");
            else
                fprintf(fp,"\t\t%s",pasgmember->asgName);
            if(memcallback) memcallback(pasgmember,fp);
            fprintf(fp,"\n");
            pasgclient = (ASGCLIENT *)ellFirst(&pasgmember->clientList);
            if(!clients) pasgclient = NULL;
            while(pasgclient) {
                fprintf(fp,"\t\t\t %s %s",
                    pasgclient->user,pasgclient->host);
                if(pasgclient->level>=0 && pasgclient->level<=1)
                    fprintf(fp," %s",asLevelName[pasgclient->level]);
                else
                    fprintf(fp," Illegal Level %d",pasgclient->level);
                if(pasgclient->access<=2)
                    fprintf(fp," %s %s",
                        asAccessName[pasgclient->access],
                        asTrapOption[pasgclient->trapMask]);
                else
                    fprintf(fp," Illegal Access %d",pasgclient->access);
                fprintf(fp,"\n");
                pasgclient = (ASGCLIENT *)ellNext(&pasgclient->node);
            }
            pasgmember = (ASGMEMBER *)ellNext(&pasgmember->node);
        }
        pasg = (ASG *)ellNext(&pasg->node);
    }
    return(0);
}

int epicsStdCall asDumpRules

(

const char *

asgname

)

Definition at line 719 of file asLibRoutines.c.

{
    return asDumpRulesFP(stdout,asgname);
}

int epicsStdCall asDumpRulesFP	(	FILE *	fp,
		const char *	asgname
	)

Definition at line 724 of file asLibRoutines.c.

{
    ASG         *pasg;
    ASGINP      *pasginp;
    ASGRULE     *pasgrule;
    ASGHAG      *pasghag;
    ASGUAG      *pasguag;

    if(!asActive) return(0);
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    if(!pasg) fprintf(fp,"No ASGs\n");
    while(pasg) {
        int print_end_brace;

        if(asgname && strcmp(asgname,pasg->name)!=0) {
            pasg = (ASG *)ellNext(&pasg->node);
            continue;
        }
        fprintf(fp,"ASG(%s)",pasg->name);
        pasginp = (ASGINP *)ellFirst(&pasg->inpList);
        pasgrule = (ASGRULE *)ellFirst(&pasg->ruleList);
        if(pasginp || pasgrule) {
            fprintf(fp," {\n");
            print_end_brace = TRUE;
        } else {
            fprintf(fp,"\n");
            print_end_brace = FALSE;
        }
        while(pasginp) {

            fprintf(fp,"\tINP%c(%s)",(pasginp->inpIndex + 'A'),pasginp->inp);
            if ((pasg->inpBad & (1ul << pasginp->inpIndex)))
                fprintf(fp," INVALID");
            fprintf(fp," value=%f",pasg->pavalue[pasginp->inpIndex]);
            fprintf(fp,"\n");
            pasginp = (ASGINP *)ellNext(&pasginp->node);
        }
        while(pasgrule) {
            int print_end_brace;

            fprintf(fp,"\tRULE(%d,%s,%s)",
                pasgrule->level,asAccessName[pasgrule->access],
                asTrapOption[pasgrule->trapMask]);
            pasguag = (ASGUAG *)ellFirst(&pasgrule->uagList);
            pasghag = (ASGHAG *)ellFirst(&pasgrule->hagList);
            if(pasguag || pasghag || pasgrule->calc) {
                fprintf(fp," {\n");
                print_end_brace = TRUE;
            } else {
                fprintf(fp,"\n");
                print_end_brace = FALSE;
            }
            if(pasguag) fprintf(fp,"\t\tUAG(");
            while(pasguag) {
                fprintf(fp,"%s",pasguag->puag->name);
                pasguag = (ASGUAG *)ellNext(&pasguag->node);
                if(pasguag) fprintf(fp,","); else fprintf(fp,")\n");
            }
            pasghag = (ASGHAG *)ellFirst(&pasgrule->hagList);
            if(pasghag) fprintf(fp,"\t\tHAG(");
            while(pasghag) {
                fprintf(fp,"%s",pasghag->phag->name);
                pasghag = (ASGHAG *)ellNext(&pasghag->node);
                if(pasghag) fprintf(fp,","); else fprintf(fp,")\n");
            }
            if(pasgrule->calc) {
                fprintf(fp,"\t\tCALC(\"%s\")",pasgrule->calc);
                fprintf(fp," result=%s",(pasgrule->result==1 ? "TRUE" : "FALSE"));
                fprintf(fp,"\n");
            }
            if(print_end_brace) fprintf(fp,"\t}\n");
            pasgrule = (ASGRULE *)ellNext(&pasgrule->node);
        }
        if(print_end_brace) fprintf(fp,"}\n");
        pasg = (ASG *)ellNext(&pasg->node);
    }
    return(0);
}

int epicsStdCall asDumpUag

(

const char *

uagname

)

Definition at line 657 of file asLibRoutines.c.

{
    return asDumpUagFP(stdout,uagname);
}

int epicsStdCall asDumpUagFP	(	FILE *	fp,
		const char *	uagname
	)

Definition at line 662 of file asLibRoutines.c.

{
    UAG         *puag;
    UAGNAME     *puagname;

    if(!asActive) return(0);
    puag = (UAG *)ellFirst(&pasbase->uagList);
    if(!puag) fprintf(fp,"No UAGs\n");
    while(puag) {
        if(uagname && strcmp(uagname,puag->name)!=0) {
            puag = (UAG *)ellNext(&puag->node);
            continue;
        }
        fprintf(fp,"UAG(%s)",puag->name);
        puagname = (UAGNAME *)ellFirst(&puag->list);
        if(puagname) fprintf(fp," {"); else fprintf(fp,"\n");
        while(puagname) {
            fprintf(fp,"%s",puagname->user);
            puagname = (UAGNAME *)ellNext(&puagname->node);
            if(puagname) fprintf(fp,","); else fprintf(fp,"}\n");
        }
        puag = (UAG *)ellNext(&puag->node);
    }
    return(0);
}

void asFreeAll

(

ASBASE *

pasbase

)

Definition at line 1047 of file asLibRoutines.c.

{
    UAG         *puag;
    UAGNAME     *puagname;
    HAG         *phag;
    HAGNAME     *phagname;
    ASG         *pasg;
    ASGINP      *pasginp;
    ASGRULE     *pasgrule;
    ASGHAG      *pasghag;
    ASGUAG      *pasguag;
    void        *pnext;

    puag = (UAG *)ellFirst(&pasbase->uagList);
    while(puag) {
        puagname = (UAGNAME *)ellFirst(&puag->list);
        while(puagname) {
            pnext = ellNext(&puagname->node);
            ellDelete(&puag->list,&puagname->node);
            free(puagname);
            puagname = pnext;
        }
        pnext = ellNext(&puag->node);
        ellDelete(&pasbase->uagList,&puag->node);
        free(puag);
        puag = pnext;
    }
    phag = (HAG *)ellFirst(&pasbase->hagList);
    while(phag) {
        phagname = (HAGNAME *)ellFirst(&phag->list);
        while(phagname) {
            pnext = ellNext(&phagname->node);
            ellDelete(&phag->list,&phagname->node);
            free(phagname);
            phagname = pnext;
        }
        pnext = ellNext(&phag->node);
        ellDelete(&pasbase->hagList,&phag->node);
        free(phag);
        phag = pnext;
    }
    pasg = (ASG *)ellFirst(&pasbase->asgList);
    while(pasg) {
        free(pasg->pavalue);
        pasginp = (ASGINP *)ellFirst(&pasg->inpList);
        while(pasginp) {
            pnext = ellNext(&pasginp->node);
            ellDelete(&pasg->inpList,&pasginp->node);
            free(pasginp);
            pasginp = pnext;
        }
        pasgrule = (ASGRULE *)ellFirst(&pasg->ruleList);
        while(pasgrule) {
            free(pasgrule->calc);
            free(pasgrule->rpcl);
            pasguag = (ASGUAG *)ellFirst(&pasgrule->uagList);
            while(pasguag) {
                pnext = ellNext(&pasguag->node);
                ellDelete(&pasgrule->uagList,&pasguag->node);
                free(pasguag);
                pasguag = pnext;
            }
            pasghag = (ASGHAG *)ellFirst(&pasgrule->hagList);
            while(pasghag) {
                pnext = ellNext(&pasghag->node);
                ellDelete(&pasgrule->hagList,&pasghag->node);
                free(pasghag);
                pasghag = pnext;
            }
            pnext = ellNext(&pasgrule->node);
            ellDelete(&pasg->ruleList,&pasgrule->node);
            free(pasgrule);
            pasgrule = pnext;
        }
        pnext = ellNext(&pasg->node);
        ellDelete(&pasbase->asgList,&pasg->node);
        free(pasg);
        pasg = pnext;
    }
    gphFreeMem(pasbase->phash);
    free(pasbase);
}

void* epicsStdCall asGetClientPvt

(

ASCLIENTPVT

asClientPvt

)

Definition at line 447 of file asLibRoutines.c.

{
    ASGCLIENT   *pasgclient = asClientPvt;

    if(!asActive) return(NULL);
    if(!pasgclient) return(NULL);
    return(pasgclient->userPvt);
}

void* epicsStdCall asGetMemberPvt

(

ASMEMBERPVT

asMemberPvt

)

Definition at line 343 of file asLibRoutines.c.

{
    ASGMEMBER   *pasgmember = asMemberPvt;

    if(!asActive) return(NULL);
    if(!pasgmember) return(NULL);
    return(pasgmember->userPvt);
}

long epicsStdCall asInitFile	(	const char *	filename,
		const char *	substitutions
	)

Definition at line 169 of file asLibRoutines.c.

{
    FILE *fp;
    long status;

    fp = fopen(filename,"r");
    if(!fp) {
        errlogPrintf("asInitFile: Can't open file '%s'\n", filename);
        return(S_asLib_badConfig);
    }
    status = asInitFP(fp,substitutions);
    if(fclose(fp)==EOF) {
        errMessage(0,"asInitFile: fclose failed!");
        if(!status) status = S_asLib_badConfig;
    }
    return(status);
}

long epicsStdCall asInitFP	(	FILE *	fp,
		const char *	substitutions
	)

Definition at line 224 of file asLibRoutines.c.

{
    char        buffer[BUF_SIZE];
    char        mac_buffer[BUF_SIZE];
    long        status;
    char        **macPairs;

    buffer[0] = 0;
    my_buffer = buffer;
    my_buffer_ptr = my_buffer;
    stream = fp;
    if(substitutions) {
        if((status = macCreateHandle(&macHandle,NULL))) {
            errMessage(status,"asInitFP: macCreateHandle error");
            return(status);
        }
        macParseDefns(macHandle,substitutions,&macPairs);
        if(macPairs ==NULL) {
            macDeleteHandle(macHandle);
            macHandle = NULL;
        } else {
            macInstallMacros(macHandle,macPairs);
            free(macPairs);
            mac_input_buffer = mac_buffer;
        }
    }
    status = asInitialize(myInputFunction);
    if(macHandle) {
        macDeleteHandle(macHandle);
        macHandle = NULL;
    }
    return(status);
}

long epicsStdCall asInitialize

(

ASINPUTFUNCPTR

inputfunction

)

Definition at line 84 of file asLibRoutines.c.

{
    ASG         *pasg;
    long        status;
    ASBASE      *pasbaseold;
    GPHENTRY    *pgphentry;
    UAG         *puag;
    UAGNAME     *puagname;
    HAG         *phag;
    HAGNAME     *phagname;
    static epicsThreadOnceId asInitializeOnceFlag = EPICS_THREAD_ONCE_INIT;

    epicsThreadOnce(&asInitializeOnceFlag,asInitializeOnce,(void *)0);
    LOCK;
    pasbasenew = asCalloc(1,sizeof(ASBASE));
    if(!freeListPvt) freeListInitPvt(&freeListPvt,sizeof(ASGCLIENT),20);
    ellInit(&pasbasenew->uagList);
    ellInit(&pasbasenew->hagList);
    ellInit(&pasbasenew->asgList);
    asAsgAdd(DEFAULT);
    status = myParse(inputfunction);
    if(status) {
        status = S_asLib_badConfig;
        /*Not safe to call asFreeAll */
        UNLOCK;
        return(status);
    }
    pasg = (ASG *)ellFirst(&pasbasenew->asgList);
    while(pasg) {
        pasg->pavalue = asCalloc(CALCPERFORM_NARGS, sizeof(double));
        pasg = (ASG *)ellNext(&pasg->node);
    }
    gphInitPvt(&pasbasenew->phash, 256);
    /*Hash each uagname and each hagname*/
    puag = (UAG *)ellFirst(&pasbasenew->uagList);
    while(puag) {
        puagname = (UAGNAME *)ellFirst(&puag->list);
        while(puagname) {
            pgphentry = gphAdd(pasbasenew->phash,puagname->user,puag);
            if(!pgphentry) {
                errlogPrintf("Duplicated user '%s' in UAG '%s'\n",
                    puagname->user, puag->name);
            }
            puagname = (UAGNAME *)ellNext(&puagname->node);
        }
        puag = (UAG *)ellNext(&puag->node);
    }
    phag = (HAG *)ellFirst(&pasbasenew->hagList);
    while(phag) {
        phagname = (HAGNAME *)ellFirst(&phag->list);
        while(phagname) {
            pgphentry = gphAdd(pasbasenew->phash,phagname->host,phag);
            if(!pgphentry) {
                errlogPrintf("Duplicated host '%s' in HAG '%s'\n",
                    phagname->host, phag->name);
            }
            phagname = (HAGNAME *)ellNext(&phagname->node);
        }
        phag = (HAG *)ellNext(&phag->node);
    }
    pasbaseold = (ASBASE *)pasbase;
    pasbase = (ASBASE volatile *)pasbasenew;
    if(pasbaseold) {
        ASG             *poldasg;
        ASGMEMBER       *poldmem;
        ASGMEMBER       *pnextoldmem;

        poldasg = (ASG *)ellFirst(&pasbaseold->asgList);
        while(poldasg) {
            poldmem = (ASGMEMBER *)ellFirst(&poldasg->memberList);
            while(poldmem) {
                pnextoldmem = (ASGMEMBER *)ellNext(&poldmem->node);
                ellDelete(&poldasg->memberList,&poldmem->node);
                status = asAddMemberPvt(&poldmem,poldmem->asgName);
                poldmem = pnextoldmem;
            }
            poldasg = (ASG *)ellNext(&poldasg->node);
        }
        asFreeAll(pasbaseold);
    }
    asActive = TRUE;
    UNLOCK;
    return(0);
}

long epicsStdCall asInitMem	(	const char *	acf,
		const char *	substitutions
	)

Definition at line 274 of file asLibRoutines.c.

{
    long ret = S_asLib_InitFailed;
    if(!acf) return ret;

    membuf = acf;
    ret = asInitialize(&memInputFunction);
    membuf = NULL;

    return ret;
}

void epicsStdCall asPutClientPvt	(	ASCLIENTPVT	asClientPvt,
		void *	userPvt
	)

Definition at line 456 of file asLibRoutines.c.

{
    ASGCLIENT   *pasgclient = asClientPvt;
    if(!asActive) return;
    if(!pasgclient) return;
    LOCK;
    pasgclient->userPvt = userPvt;
    UNLOCK;
}

void epicsStdCall asPutMemberPvt	(	ASMEMBERPVT	asMemberPvt,
		void *	userPvt
	)

Definition at line 352 of file asLibRoutines.c.

{
    ASGMEMBER   *pasgmember = asMemberPvt;

    if(!asActive) return;
    if(!pasgmember) return;
    pasgmember->userPvt = userPvt;
    return;
}

long epicsStdCall asRegisterClientCallback	(	ASCLIENTPVT	asClientPvt,
		ASCLIENTCALLBACK	pcallback
	)

Definition at line 433 of file asLibRoutines.c.

{
    ASGCLIENT   *pasgclient = asClientPvt;

    if(!asActive) return(S_asLib_asNotActive);
    if(!pasgclient) return(S_asLib_badClient);
    LOCK;
    pasgclient->pcallback = pcallback;
    (*pasgclient->pcallback)(pasgclient,asClientCOAR);
    UNLOCK;
    return(0);
}

long epicsStdCall asRemoveClient

(

ASCLIENTPVT *

asClientPvt

)

Definition at line 412 of file asLibRoutines.c.

{
    ASGCLIENT   *pasgclient = *asClientPvt;
    ASGMEMBER   *pasgMember;

    if(!asActive) return(S_asLib_asNotActive);
    if(!pasgclient) return(S_asLib_badClient);
    LOCK;
    pasgMember = pasgclient->pasgMember;
    if(!pasgMember) {
        errMessage(-1,"asRemoveClient: No ASGMEMBER");
        UNLOCK;
        return(-1);
    }
    ellDelete(&pasgMember->clientList,&pasgclient->node);
    UNLOCK;
    freeListFree(freeListPvt,pasgclient);
    *asClientPvt = NULL;
    return(0);
}

long epicsStdCall asRemoveMember

(

ASMEMBERPVT *

asMemberPvt

)

Definition at line 297 of file asLibRoutines.c.

{
    ASGMEMBER   *pasgmember;

    if(!asActive) return(S_asLib_asNotActive);
    pasgmember = *asMemberPvt;
    if(!pasgmember) return(S_asLib_badMember);
    LOCK;
    if (ellCount(&pasgmember->clientList) > 0) {
        UNLOCK;
        return(S_asLib_clientsExist);
    }
    if(pasgmember->pasg) {
        ellDelete(&pasgmember->pasg->memberList,&pasgmember->node);
    } else {
        errMessage(-1,"Logic error in asRemoveMember");
        UNLOCK;
        return(-1);
    }
    free(pasgmember);
    *asMemberPvt = NULL;
    UNLOCK;
    return(0);
}

LIBCOM_API char* epicsStdCall asStrdup

(

unsigned char *

str

)

Definition at line 881 of file asLibRoutines.c.

{
        size_t len = strlen((char *) str);
        char *buf = asCalloc(1, len + 1);
        strcpy(buf, (char *) str);
        return buf;
}

Variable Documentation

int asActive = FALSE

Definition at line 40 of file asLibRoutines.c.

int asCheckClientIP

Definition at line 31 of file asLibRoutines.c.

ASBASE volatile* pasbase =NULL

Definition at line 38 of file asLibRoutines.c.