asLib.h File Reference

#include "libComAPI.h"
#include "ellLib.h"
#include "errMdef.h"
#include "errlog.h"

Include dependency graph for asLib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	asBase
struct	UAGNAME
struct	uag
struct	HAGNAME
struct	hag
struct	ASGUAG
struct	ASGHAG
struct	ASGRULE
struct	ASGINP
struct	asg
struct	asgMember
struct	asgClient

Macros
#define	asCheckGet(asClientPvt)   (!asActive || ((asClientPvt)->access >= asREAD))
#define	asCheckPut(asClientPvt)   (!asActive || ((asClientPvt)->access >= asWRITE))
#define	asTrapWriteWithData(asClientPvt, user, host, addr, type, count, data)
#define	asTrapWriteAfter(pvt)   if (pvt) asTrapWriteAfterWrite(pvt)
#define	asTrapWriteBefore(asClientPvt, user, host, addr)   asTrapWriteWithData(asClientPvt, user, host, addr, 0, 0, NULL)
#define	S_asLib_clientsExist   (M_asLib| 1) /*Client Exists*/
#define	S_asLib_noUag   (M_asLib| 2) /*User Access Group does not exist*/
#define	S_asLib_noHag   (M_asLib| 3) /*Host Access Group does not exist*/
#define	S_asLib_noAccess   (M_asLib| 4) /*access security: no access allowed*/
#define	S_asLib_noModify   (M_asLib| 5) /*access security: no modification allowed*/
#define	S_asLib_badConfig   (M_asLib| 6) /*access security: bad configuration file*/
#define	S_asLib_badCalc   (M_asLib| 7) /*access security: bad calculation espression*/
#define	S_asLib_dupAsg   (M_asLib| 8) /*Duplicate Access Security Group */
#define	S_asLib_InitFailed   (M_asLib| 9) /*access security: Init failed*/
#define	S_asLib_asNotActive   (M_asLib|10) /*access security is not active*/
#define	S_asLib_badMember   (M_asLib|11) /*access security: bad ASMEMBERPVT*/
#define	S_asLib_badClient   (M_asLib|12) /*access security: bad ASCLIENTPVT*/
#define	S_asLib_badAsg   (M_asLib|13) /*access security: bad ASG*/
#define	S_asLib_noMemory   (M_asLib|14) /*access security: no Memory */
#define	AS_TRAP_WRITE   1

Typedefs
typedef struct asgMember *	ASMEMBERPVT
typedef struct asgClient *	ASCLIENTPVT
typedef int(*	ASINPUTFUNCPTR) (char *buf, int max_size)
typedef void(*	ASCLIENTCALLBACK) (ASCLIENTPVT, asClientStatus)
typedef struct asBase	ASBASE
typedef struct uag	UAG
typedef struct hag	HAG
typedef struct asg	ASG
typedef struct asgMember	ASGMEMBER
typedef struct asgClient	ASGCLIENT

Enumerations
enum	asClientStatus { asClientCOAR }
enum	asAccessRights { asNOACCESS, asREAD, asWRITE }

Functions
LIBCOM_API long epicsStdCall	asInitialize (ASINPUTFUNCPTR inputfunction)
LIBCOM_API long epicsStdCall	asInitFile (const char *filename, const char *substitutions)
LIBCOM_API long epicsStdCall	asInitFP (FILE *fp, const char *substitutions)
LIBCOM_API long epicsStdCall	asInitMem (const char *acf, const char *substitutions)
LIBCOM_API long epicsStdCall	asAddMember (ASMEMBERPVT *asMemberPvt, const char *asgName)
LIBCOM_API long epicsStdCall	asRemoveMember (ASMEMBERPVT *asMemberPvt)
LIBCOM_API long epicsStdCall	asChangeGroup (ASMEMBERPVT *asMemberPvt, const char *newAsgName)
LIBCOM_API void *epicsStdCall	asGetMemberPvt (ASMEMBERPVT asMemberPvt)
LIBCOM_API void epicsStdCall	asPutMemberPvt (ASMEMBERPVT asMemberPvt, void *userPvt)
LIBCOM_API long epicsStdCall	asAddClient (ASCLIENTPVT *asClientPvt, ASMEMBERPVT asMemberPvt, int asl, const char *user, char *host)
LIBCOM_API long epicsStdCall	asChangeClient (ASCLIENTPVT asClientPvt, int asl, const char *user, char *host)
LIBCOM_API long epicsStdCall	asRemoveClient (ASCLIENTPVT *asClientPvt)
LIBCOM_API void *epicsStdCall	asGetClientPvt (ASCLIENTPVT asClientPvt)
LIBCOM_API void epicsStdCall	asPutClientPvt (ASCLIENTPVT asClientPvt, void *userPvt)
LIBCOM_API long epicsStdCall	asRegisterClientCallback (ASCLIENTPVT asClientPvt, ASCLIENTCALLBACK pcallback)
LIBCOM_API long epicsStdCall	asComputeAllAsg (void)
LIBCOM_API long epicsStdCall	asCompute (ASCLIENTPVT asClientPvt)
LIBCOM_API int epicsStdCall	asDump (void(*memcallback)(ASMEMBERPVT, FILE *), void(*clientcallback)(ASCLIENTPVT, FILE *), int verbose)
LIBCOM_API int epicsStdCall	asDumpFP (FILE *fp, void(*memcallback)(ASMEMBERPVT, FILE *), void(*clientcallback)(ASCLIENTPVT, FILE *), int verbose)
LIBCOM_API int epicsStdCall	asDumpUag (const char *uagname)
LIBCOM_API int epicsStdCall	asDumpUagFP (FILE *fp, const char *uagname)
LIBCOM_API int epicsStdCall	asDumpHag (const char *hagname)
LIBCOM_API int epicsStdCall	asDumpHagFP (FILE *fp, const char *hagname)
LIBCOM_API int epicsStdCall	asDumpRules (const char *asgname)
LIBCOM_API int epicsStdCall	asDumpRulesFP (FILE *fp, const char *asgname)
LIBCOM_API int epicsStdCall	asDumpMem (const char *asgname, void(*memcallback)(ASMEMBERPVT, FILE *), int clients)
LIBCOM_API 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	asTrapWriteBeforeWithData (const char *userid, const char *hostid, void *addr, int dbrType, int no_elements, void *data)
LIBCOM_API void epicsStdCall	asTrapWriteAfterWrite (void *pvt)
LIBCOM_API long epicsStdCall	asComputeAsg (ASG *pasg)
LIBCOM_API void *epicsStdCall	asCalloc (size_t nobj, size_t size)
LIBCOM_API char *epicsStdCall	asStrdup (unsigned char *str)
LIBCOM_API void	asFreeAll (ASBASE *pasbase)

Variables
LIBCOM_API int	asCheckClientIP
LIBCOM_API int	asActive
LIBCOM_API volatile ASBASE *	pasbase

Macro Definition Documentation

#define AS_TRAP_WRITE   1

Definition at line 190 of file asLib.h.

#define asCheckGet

(

asClientPvt

)

(!asActive || ((asClientPvt)->access >= asREAD))

Definition at line 43 of file asLib.h.

#define asCheckPut

(

asClientPvt

)

(!asActive || ((asClientPvt)->access >= asWRITE))

Definition at line 45 of file asLib.h.

#define asTrapWriteAfter

(

pvt

)

if (pvt) asTrapWriteAfterWrite(pvt)

Definition at line 58 of file asLib.h.

#define asTrapWriteBefore	(		asClientPvt,
			user,
			host,
			addr
	)		asTrapWriteWithData(asClientPvt, user, host, addr, 0, 0, NULL)

Definition at line 66 of file asLib.h.

#define asTrapWriteWithData	(		asClientPvt,
			user,
			host,
			addr,
			type,
			count,
			data
	)

Value:

((asActive && (asClientPvt)->trapMask) \
    ? asTrapWriteBeforeWithData((user), (host), (addr), (type), (count), (data)) \
    : 0)

Definition at line 54 of file asLib.h.

#define S_asLib_asNotActive   (M_asLib|10) /*access security is not active*/

Definition at line 137 of file asLib.h.

#define S_asLib_badAsg   (M_asLib|13) /*access security: bad ASG*/

Definition at line 140 of file asLib.h.

#define S_asLib_badCalc   (M_asLib| 7) /*access security: bad calculation espression*/

Definition at line 134 of file asLib.h.

#define S_asLib_badClient   (M_asLib|12) /*access security: bad ASCLIENTPVT*/

Definition at line 139 of file asLib.h.

#define S_asLib_badConfig   (M_asLib| 6) /*access security: bad configuration file*/

Definition at line 133 of file asLib.h.

#define S_asLib_badMember   (M_asLib|11) /*access security: bad ASMEMBERPVT*/

Definition at line 138 of file asLib.h.

#define S_asLib_clientsExist   (M_asLib| 1) /*Client Exists*/

Definition at line 128 of file asLib.h.

#define S_asLib_dupAsg   (M_asLib| 8) /*Duplicate Access Security Group */

Definition at line 135 of file asLib.h.

#define S_asLib_InitFailed   (M_asLib| 9) /*access security: Init failed*/

Definition at line 136 of file asLib.h.

#define S_asLib_noAccess   (M_asLib| 4) /*access security: no access allowed*/

Definition at line 131 of file asLib.h.

#define S_asLib_noHag   (M_asLib| 3) /*Host Access Group does not exist*/

Definition at line 130 of file asLib.h.

#define S_asLib_noMemory   (M_asLib|14) /*access security: no Memory */

Definition at line 141 of file asLib.h.

#define S_asLib_noModify   (M_asLib| 5) /*access security: no modification allowed*/

Definition at line 132 of file asLib.h.

#define S_asLib_noUag   (M_asLib| 2) /*User Access Group does not exist*/

Definition at line 129 of file asLib.h.

Typedef Documentation

typedef struct asBase ASBASE

typedef void(* ASCLIENTCALLBACK) (ASCLIENTPVT, asClientStatus)

Definition at line 37 of file asLib.h.

typedef struct asgClient* ASCLIENTPVT

Definition at line 30 of file asLib.h.

typedef struct asg ASG

typedef struct asgClient ASGCLIENT

typedef struct asgMember ASGMEMBER

typedef int(* ASINPUTFUNCPTR) (char *buf, int max_size)

Definition at line 31 of file asLib.h.

typedef struct asgMember* ASMEMBERPVT

Definition at line 29 of file asLib.h.

typedef struct hag HAG

typedef struct uag UAG

Enumeration Type Documentation

enum asAccessRights

Enumerator
asNOACCESS
asREAD
asWRITE

Definition at line 147 of file asLib.h.

{asNOACCESS,asREAD,asWRITE} asAccessRights;

enum asClientStatus

Enumerator
asClientCOAR

Definition at line 32 of file asLib.h.

            {
    asClientCOAR        /*Change of access rights*/
    /*For now this is all*/
} asClientStatus;

Function Documentation

LIBCOM_API long epicsStdCall asAddClient	(	ASCLIENTPVT *	asClientPvt,
		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);
}

LIBCOM_API long epicsStdCall asAddMember	(	ASMEMBERPVT *	asMemberPvt,
		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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API int epicsStdCall asDump	(	void(*)(ASMEMBERPVT, FILE *)	memcallback,
		void(*)(ASCLIENTPVT, FILE *)	clientcallback,
		int	verbose
	)

LIBCOM_API int epicsStdCall asDumpFP	(	FILE *	fp,
		void(*)(ASMEMBERPVT, FILE *)	memcallback,
		void(*)(ASCLIENTPVT, FILE *)	clientcallback,
		int	verbose
	)

LIBCOM_API int epicsStdCall asDumpHag

(

const char *

hagname

)

Definition at line 688 of file asLibRoutines.c.

{
    return asDumpHagFP(stdout,hagname);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API int epicsStdCall asDumpRules

(

const char *

asgname

)

Definition at line 719 of file asLibRoutines.c.

{
    return asDumpRulesFP(stdout,asgname);
}

LIBCOM_API 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);
}

LIBCOM_API int epicsStdCall asDumpUag

(

const char *

uagname

)

Definition at line 657 of file asLibRoutines.c.

{
    return asDumpUagFP(stdout,uagname);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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;
}

LIBCOM_API 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;
}

LIBCOM_API 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;
}

LIBCOM_API 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);
}

LIBCOM_API 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);
}

LIBCOM_API 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;
}

LIBCOM_API void epicsStdCall asTrapWriteAfterWrite

(

void *

pvt

)

Definition at line 151 of file asTrapWrite.c.

{
    writeMessage *pwriteMessage = (writeMessage *)pvt;
    listenerPvt *plistenerPvt;

    if (pwriteMessage == 0 ||
        pasTrapWritePvt == 0) return;

    epicsMutexMustLock(pasTrapWritePvt->lock);
    plistenerPvt = (listenerPvt *)ellFirst(&pwriteMessage->listenerPvtList);
    while (plistenerPvt) {
        listenerPvt *pnext = (listenerPvt *)ellNext(&plistenerPvt->node);
        listener *plistener = plistenerPvt->plistener;

        pwriteMessage->message.userPvt = plistenerPvt->userPvt;
        plistener->func(&pwriteMessage->message, 1);
        ellDelete(&pwriteMessage->listenerPvtList, &plistenerPvt->node);
        freeListFree(pasTrapWritePvt->freeListListenerPvt, plistenerPvt);
        plistenerPvt = pnext;
    }
    ellDelete(&pasTrapWritePvt->writeMessageList, &pwriteMessage->node);
    freeListFree(pasTrapWritePvt->freeListWriteMessage, pwriteMessage);
    epicsMutexUnlock(pasTrapWritePvt->lock);
}

LIBCOM_API void* epicsStdCall asTrapWriteBeforeWithData	(	const char *	userid,
		const char *	hostid,
		void *	addr,
		int	dbrType,
		int	no_elements,
		void *	data
	)

Definition at line 113 of file asTrapWrite.c.

{
    writeMessage *pwriteMessage;
    listener *plistener;

    if (pasTrapWritePvt == 0 ||
        ellCount(&pasTrapWritePvt->listenerList) <= 0) return 0;

    pwriteMessage = (writeMessage *)freeListCalloc(
        pasTrapWritePvt->freeListWriteMessage);
    pwriteMessage->message.userid = userid;
    pwriteMessage->message.hostid = hostid;
    pwriteMessage->message.serverSpecific = addr;
    pwriteMessage->message.dbrType = dbrType;
    pwriteMessage->message.no_elements = no_elements;
    pwriteMessage->message.data = data;
    ellInit(&pwriteMessage->listenerPvtList);

    epicsMutexMustLock(pasTrapWritePvt->lock);
    ellAdd(&pasTrapWritePvt->writeMessageList, &pwriteMessage->node);
    plistener = (listener *)ellFirst(&pasTrapWritePvt->listenerList);
    while (plistener) {
        listenerPvt *plistenerPvt = (listenerPvt *)freeListCalloc(
            pasTrapWritePvt->freeListListenerPvt);

        plistenerPvt->plistener = plistener;
        pwriteMessage->message.userPvt = 0;
        plistener->func(&pwriteMessage->message, 0);
        plistenerPvt->userPvt = pwriteMessage->message.userPvt;
        ellAdd(&pwriteMessage->listenerPvtList, &plistenerPvt->node);
        plistener = (listener *)ellNext(&plistener->node);
    }
    epicsMutexUnlock(pasTrapWritePvt->lock);
    return pwriteMessage;
}

Variable Documentation

LIBCOM_API int asActive

Definition at line 40 of file asLibRoutines.c.

LIBCOM_API int asCheckClientIP

Definition at line 31 of file asLibRoutines.c.

LIBCOM_API volatile ASBASE* pasbase

Definition at line 38 of file asLibRoutines.c.