DataMuseum.dk

top - metrics - download

    Length: 16747 (0x416b)
    Types: TextFile
    Names: »attrv.c«

└─⟦3d0c2be1b⟧ Bits:30001254 ISODE-5.0 Tape
    └─⟦eba4602b1⟧ »./isode-5.0.tar.Z« 
        └─⟦d3ac74d73⟧ 
            └─⟦this⟧ »isode-5.0/dsap/common/attrv.c« 

TextFile

/* attrv.c - Attribute Value routines */

#ifndef lint
static char *rcsid = "$Header: /f/osi/dsap/common/RCS/attrv.c,v 6.0 89/03/18 23:27:23 mrose Rel $";
#endif

/*
 * $Header: /f/osi/dsap/common/RCS/attrv.c,v 6.0 89/03/18 23:27:23 mrose Rel $
 *
 *
 * $Log:	attrv.c,v $
 * Revision 6.0  89/03/18  23:27:23  mrose
 * Release 5.0
 * 
 */

/*
 *                                NOTICE
 *
 *    Acquisition, use, and distribution of this module and related
 *    materials are subject to the restrictions of a license agreement.
 *    Consult the Preface in the User's Manual for the full terms of
 *    this agreement.
 *
 */


/* LINTLIBRARY */

#include "quipu/util.h"
#include "quipu/entry.h"
#include "quipu/ds_error.h"
#include "cmd_srch.h"
#include <sys/stat.h>

extern int oidformat;
extern struct PSAPaddr * psap_cpy ();
extern LLog * log_dsap;
PE asn2pe();
char * parse_file = NULLCP;
RDN parse_rdn = NULLRDN;
static int dflt_attr_file ();

AttrV_free (x)
register AttributeValue x;
{
int x_syntax;

	if (x == NULLAttrV)
		return;

	if (x->av_pe != NULLPE)
		pe_free (x->av_pe);

	if ( x->av_syntax >= AV_WRITE_FILE ) 
		x_syntax = x->av_syntax - AV_WRITE_FILE;
	else
		x_syntax = x->av_syntax;

	switch (x_syntax) {
		case AV_UNKNOWN:
		case AV_PHOTO:
			break;
		case AV_CASEEXACTSTRING:
		case AV_CASEIGNORESTRING:
			free (x->av_un.av_str);
			break;
		case AV_FILE:
			free (x->av_un.av_file.fs_name);
			break;
		case AV_NUMERICSTRING:
			free (x->av_un.av_num);
			break;
		case AV_ACL:
			acl_free (x->av_un.av_acl);
			break;
		case AV_ASN:
			break;  /* same PE as above */
		case AV_PRESENTATIONADDRESS:
			psap_free (x->av_un.av_psap);
			break;
		case AV_DN:
			dn_free (x->av_un.av_dn);
			break;
		case AV_SCHEMA:
			tree_struct_free (x->av_un.av_tree);
			break;
		case AV_UPDATE:
			edb_info_free (x->av_un.av_update);
			break;
		case AV_BOOLEAN:
		case AV_INTEGER:
		case AV_TIME:
			break;
		case AV_OID:
			oid_free (x->av_un.av_oid);
			break;
		case AV_OBJECTCLASS:
			break;          /* pointer to static table */
		default:
			LLOG (log_dsap,LLOG_EXCEPTIONS,("Unknown AttrV type (%d)",x->av_syntax));
	}
	free ((char *)  x);

}

AttributeValue str_at2AttrV (str,at)
char * str;
AttributeType at;
{
register char * ptr;
int syntax;
extern char * index();

static CMD_TABLE cmd_syntax [] = {
        "N",		AV_NUMERICSTRING,
        "PSAP",		AV_PRESENTATIONADDRESS,
        "DN",		AV_DN,
        "ACL",		AV_ACL,
        "SCHEMA",	AV_SCHEMA,
        "UPDATE",	AV_UPDATE,
        "OID",		AV_OID,
        "FILE",		AV_FILE,
	"ASN",		AV_ASN,
        0,              0,
        } ;

	if (str == NULLCP)
		return (NULLAttrV);

	if (at == NULLAttrT)
		return (NULLAttrV);

	str = SkipSpace (str);
	if (*str == 0)
		return (NULLAttrV);
	ptr = str;

	if (*ptr++ == '{') {
		/* look for syntax */	
		if (( str = index (ptr,'}')) == 0) {
			parse_error ("invalid {syntax} '%s'",ptr);
			return (NULLAttrV);
		}
		*str = 0;
		if ((syntax = cmd_srch (ptr,cmd_syntax)) == 0) {
			parse_error ("invalid syntax '%s'",ptr);
			return (NULLAttrV);
		}

		if (syntax != AV_FILE) {
			if (syntax != at->at_table->oa_syntax) {
				if (at->at_table->oa_syntax >= AV_WRITE_FILE ) 
					if (syntax != (at->at_table->oa_syntax - AV_WRITE_FILE)) { 
						parse_error ("file syntax mismatch '%s'",ptr);
						return (NULLAttrV);
					}
				
				if ((syntax == AV_OID) && (at->at_table->oa_syntax == AV_OBJECTCLASS)) {
					syntax = AV_OBJECTCLASS;
				} else {
					parse_error ("syntax mismatch '%s'",ptr);
					return (NULLAttrV);
				}
			}
		} else {
			/* see if file exists */
			AttributeValue x;
#ifdef CHECK_FILE_ATTRIBUTES
			struct stat filestat;
#endif

			x = AttrV_alloc();
			x->av_pe = NULLPE;
			x->av_syntax = syntax;
			if ((x->av_un.av_file.fs_real_syntax = at->at_table->oa_syntax) >= AV_WRITE_FILE)
				x->av_un.av_file.fs_real_syntax -= AV_WRITE_FILE; 

			if (*++str != 0) {
				x->av_un.av_file.fs_default = FALSE;
				x->av_un.av_file.fs_name = strdup (str);
			} else {
				if (dflt_attr_file (at,x) == NOTOK) {
					*str = '}';
					return (NULLAttrV);
				}
			}

#ifdef CHECK_FILE_ATTRIBUTES
			/* now check the file is OK */
			if (stat(x->av_un.av_file.fs_name,&filestat) != -1) {
				*str = '}';
				return (x);
			} else {
				*str = '}';
				parse_error ("can't find attribute file %s",x->av_un.av_file.fs_name);
				return (NULLAttrV);
			}
			/* NOTREACHED */
#else
			*str = '}';
			return (x);
#endif
		}
		*str++ = '}';
	} else
		syntax = at->at_table->oa_syntax;

	return (str2AttrV (str,syntax));
}

AttributeValue str2AttrV (str,syntax)
register char * str;
int syntax;
{
AttributeValue x;
register char * ptr;
long atol();

	if (str == NULLCP)
		return (NULLAttrV);

	x = AttrV_alloc();
	x->av_pe = NULLPE;
	x->av_syntax = syntax;
	switch (syntax) {
		case AV_NUMERICSTRING:
			x->av_un.av_num = strdup (str);
			break;
		case AV_FILE:
			x->av_un.av_file.fs_name = strdup (str);
			x->av_un.av_file.fs_real_syntax = AV_UNKNOWN;
			x->av_un.av_file.fs_default = FALSE;
			break;
		case AV_CASEEXACTSTRING:
		case AV_CASEIGNORESTRING:
			x->av_un.av_str = strdup (str);
			break;
		case AV_ACL:
			if ((x->av_un.av_acl = str2acl (str)) == (struct acl *) NULL) {
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		case AV_ASN:
		case AV_PHOTO:
			if ((x->av_un.av_asn = asn2pe (str)) == NULLPE) {
			parse_error ("invalid ASN attribute",NULLCP);
				free ((char *)x);
				return (NULLAttrV);
			}
			x->av_pe = x->av_un.av_asn;
			break;
		case AV_PRESENTATIONADDRESS:
			{
			struct PSAPaddr *pa;
                        x -> av_un.av_psap = (struct PSAPaddr *) calloc (1,sizeof (struct PSAPaddr));
                        if (pa=str2paddr(str))
				*x->av_un.av_psap = *pa;
			else {
				parse_error ("invalid presentation address %s",str);
				free ((char *)x->av_un.av_psap);
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
			}
		case AV_SCHEMA:
			if ((x->av_un.av_tree = str2schema (str)) == NULLTREE) {
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		case AV_UPDATE:
			if ((x->av_un.av_update = str2update (str)) == NULLEDB) {
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		case AV_BOOLEAN:
			if (lexequ (str,"TRUE") == 0)
				x->av_un.av_boolean = TRUE;
			else if (lexequ (str,"FALSE") == 0)
				x->av_un.av_boolean = FALSE;
			else {
				parse_error ("invalid boolean %s",str);
				free ((char *)x);
				return (NULLAttrV);
			}

			break;
		case AV_INTEGER:
			x->av_un.av_time = (time_t) atol (str);
			break;
		case AV_TIME:
			x->av_un.av_integer = atoi (str);
			break;
		case AV_OBJECTCLASS:
			if ((x->av_un.av_objectclass = name2oc (str)) == NULLOBJECTCLASS) {
				parse_error ("invalid objectclass %s",str);
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		case AV_OID:
			if ((x->av_un.av_oid = oid_cpy(name2oid (str))) == NULLOID) {
				parse_error ("invalid oid %s",str);
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		case AV_DN:
			if ((ptr = rindex (str,'#')) != 0) {
				/* a bit or reverse compatability... */
				if (*++ptr != 0) {
					parse_error ("invalid # in '%s'",str);
					free ((char *)x);
					return (NULLAttrV);
				} else
					*--ptr = 0;
			}
			if ((x->av_un.av_dn = str2dn(str)) == NULLDN) {
				free ((char *)x);
				return (NULLAttrV);
			}
			break;
		default:
			parse_error ("unknown syntax %d",(char *)syntax);
			free ((char *)x);
			return (NULLAttrV);
	}
	return (x);
}

AttributeValue AttrV_cpy (x)
register AttributeValue x;
{
register AttributeValue y;
int x_syntax;

	if ( x->av_syntax >= AV_WRITE_FILE ) 
		x_syntax = x->av_syntax - AV_WRITE_FILE;
	else
		x_syntax = x->av_syntax;

	y = (AttributeValue) smalloc (sizeof (attrVal));
	y->av_pe = ( x->av_pe == NULLPE ) ? NULLPE : pe_cpy (x->av_pe);
	y->av_syntax = x->av_syntax;
	switch (x_syntax) {
		case AV_UNKNOWN:
			break;
		case AV_CASEEXACTSTRING:
		case AV_CASEIGNORESTRING:
			y->av_un.av_str = strdup (x->av_un.av_str);
			break;
		case AV_FILE:
			y->av_un.av_file.fs_name = strdup (x->av_un.av_file.fs_name);
			y->av_un.av_file.fs_real_syntax = x->av_un.av_file.fs_real_syntax;
			y->av_un.av_file.fs_default = x->av_un.av_file.fs_default;
			break;
		case AV_NUMERICSTRING:
			y->av_un.av_str = strdup (x->av_un.av_num);
			break;
		case AV_ACL:
			y->av_un.av_acl = acl_cpy (x->av_un.av_acl);
			break;
		case AV_ASN:
		case AV_PHOTO:
			y->av_un.av_asn = y->av_pe;
			break;  /* same PE as above */
		case AV_PRESENTATIONADDRESS:
			y->av_un.av_psap = psap_cpy (x->av_un.av_psap);
			break;
		case AV_DN:
			y->av_un.av_dn = dn_cpy (x->av_un.av_dn);
			break;
		case AV_SCHEMA:
			y->av_un.av_tree = tree_struct_cpy (x->av_un.av_tree);
			break;
		case AV_UPDATE:
			y->av_un.av_update = edb_info_cpy(x->av_un.av_update);
			break;
		case AV_BOOLEAN:
			y->av_un.av_boolean = x->av_un.av_boolean;
			break;
		case AV_INTEGER:
			y->av_un.av_integer = x->av_un.av_integer;
			break;
		case AV_TIME:
			y->av_un.av_time = x->av_un.av_time;
			break;
		case AV_OID:
			y->av_un.av_oid = oid_cpy (x->av_un.av_oid);
			break;
		case AV_OBJECTCLASS:
			y->av_un.av_objectclass = x->av_un.av_objectclass;
			break;
		default:
			LLOG (log_dsap,LLOG_EXCEPTIONS,("Unknown AttrV type (%d)",x->av_syntax));
	}
	return (y);
}


AttrV_cmp (x,y,error)
register AttributeValue x,y;
struct DSError * error;
{
int x_syntax, y_syntax;

	if ( x->av_syntax >= AV_WRITE_FILE ) 
		x_syntax = x->av_syntax - AV_WRITE_FILE;
	else
		x_syntax = x->av_syntax;

	if ( y->av_syntax >= AV_WRITE_FILE )
		y_syntax = y->av_syntax - AV_WRITE_FILE;
	else
		y_syntax = y->av_syntax;

	if (x_syntax != y_syntax) {
		error->dse_type = DSE_ATTRIBUTEERROR;
		error->ERR_ATTRIBUTE.DSE_at_name = NULLDN;
		error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_what = DSE_AT_INAPPROPRIATEMATCHING;

		error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_type = NULLAttrT;  /* set later */
		error->ERR_ATTRIBUTE.DSE_at_plist.DSE_at_value = AttrV_cpy(x);
		error->ERR_ATTRIBUTE.DSE_at_plist.dse_at_next = DSE_AT_NOPROBLEM;
		return (-2);
	}

	switch (x_syntax) {
		case AV_UNKNOWN:
			return(quipu_pe_cmp(x->av_pe,y->av_pe));
		case AV_FILE:
			return (-1); 	/* cmp files or file names ??? */
		case AV_CASEEXACTSTRING:
			{
			int res;
			res = strcmp(x->av_un.av_str,y->av_un.av_str);
			return (res == 0 ? 0 : res < 0 ? -1 : 1);
			}
		case AV_CASEIGNORESTRING:
			return (lexequ(x->av_un.av_str,y->av_un.av_str));
		case AV_NUMERICSTRING:
			return (strcmp(x->av_un.av_str,y->av_un.av_num));
		case AV_ASN:
		case AV_PHOTO:
			return(quipu_pe_cmp(x->av_un.av_asn,y->av_un.av_asn));
		case AV_DN:
			return (dn_cmp (y->av_un.av_dn,x->av_un.av_dn));
		case AV_PRESENTATIONADDRESS:
			return (psap_cmp (x->av_un.av_psap,y->av_un.av_psap));
		case AV_BOOLEAN:
			return (y->av_un.av_boolean == x->av_un.av_boolean);
		case AV_INTEGER:
			return ( (y->av_un.av_integer == x->av_un.av_integer) ? 0 : ((y->av_un.av_integer > x->av_un.av_integer) ? -1 : 1));
		case AV_TIME:
			return ( (y->av_un.av_time == x->av_un.av_time) ? 0 : ((y->av_un.av_time > x->av_un.av_time) ? -1 : 1));
		case AV_OID:
			return ( quipu_oid_cmp (y->av_un.av_oid, x->av_un.av_oid));
		case AV_OBJECTCLASS:
			return ( objclass_cmp (x->av_un.av_objectclass, y->av_un.av_objectclass));
		case AV_UPDATE:
			return ( edb_info_cmp (x->av_un.av_update, y->av_un.av_update));
		case AV_ACL:
		case AV_SCHEMA:
			return (-1);	/* just say they are different !!! */
		default:
			LLOG (log_dsap,LLOG_EXCEPTIONS,("Matching error (%d)",x->av_syntax));
			return (-2);
	}
	/* NOT REACHED */
}

AttrV_print (ps,x,format)
register PS ps;
register AttributeValue x;
register int format;
{
extern int ps_printf ();
extern AttributeType last_at;

	if ( x->av_syntax >= AV_WRITE_FILE ) {
		x->av_syntax -= AV_WRITE_FILE;
		if (format != EDBOUT) {
			AttrV_print (ps,x,format);
		} else {
			FILE * fptr;
			PS fps;
			AttributeValue y;

			ps_print (ps,"{FILE}");

			y = AttrV_alloc ();
			y->av_pe = NULLPE;
			y->av_syntax = AV_FILE;
			y->av_un.av_file.fs_real_syntax = x->av_syntax;
			if (dflt_attr_file (last_at,y) == NOTOK) {
				LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not make default attribute file"));
				x->av_syntax += AV_WRITE_FILE;
				return;
			}
			
			if ((fptr = fopen (y->av_un.av_file.fs_name,"w")) != NULL) {
				if ((fps = ps_alloc (std_open)) == NULLPS) {
					(void) fclose (fptr);
					LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not alloc PS file '%s'",x->av_un.av_file.fs_name));
					x->av_syntax += AV_WRITE_FILE;
					return;
				}				
				if ((std_setup (fps,fptr)) == NOTOK) {
					(void) fclose (fptr);
					ps_free (fps);
					LLOG (log_dsap,LLOG_EXCEPTIONS,("Could not open PS file '%s'",x->av_un.av_file.fs_name));
					x->av_syntax += AV_WRITE_FILE;
					return;
				}
			} else {
				LLOG ( log_dsap,LLOG_EXCEPTIONS,("Could not open attribute file '%s'",x->av_un.av_file.fs_name));
				x->av_syntax += AV_WRITE_FILE;
				return;
			}
			if ((x->av_syntax == AV_PHOTO) || (x->av_syntax == AV_ASN))
				(void) pe2ps (fps,x->av_pe);
			else
				AttrV_print (fps,x,format);
			(void) fclose (fptr);
			ps_free (fps);
		}
		x->av_syntax += AV_WRITE_FILE;
		return;
	}

	switch (x->av_syntax) {
		case AV_UNKNOWN:
			if (format == READOUT) {
				vpushpp ((caddr_t) ps, ps_printf, x->av_pe, "(unknown syntax)...", 1);
				vunknown (x->av_pe);
				vpopp ();
			}
			else if (x->av_pe != NULLPE)
				pe_print (ps,x->av_pe,format);
			break;
		case AV_PHOTO:
			if (format == READOUT)
				picture_print (ps,x->av_un.av_asn,format);
			else
				pe_print (ps,x->av_un.av_asn,format);
			break;
		case AV_FILE:
			if (format == EDBOUT)
				ps_print (ps,"{FILE}");
			if ( ! x->av_un.av_file.fs_default)
				ps_print (ps,x->av_un.av_file.fs_name);
/*
 *			else {
 *				check default file name - if OK fine,
 *				else copy file to new location !!!   
 *			}
 */
			break;
		case AV_CASEEXACTSTRING:
		case AV_CASEIGNORESTRING:
			ps_print (ps,x->av_un.av_str);
			break;
		case AV_NUMERICSTRING:
			ps_print (ps,x->av_un.av_num);
			break;
		case AV_ACL:
			acl_print (ps,x->av_un.av_acl,format);
			break;
		case AV_ASN:
			if (x->av_un.av_asn != NULLPE)
				if (format == READOUT) {
					vpushpp ((caddr_t) ps, ps_printf, x->av_pe, "(ASN syntax)...", 1);
					vunknown (x->av_pe);
					vpopp ();
				} else
					pe_print (ps,x->av_un.av_asn,format);
			break;
		case AV_PRESENTATIONADDRESS:
			if (format == EDBOUT)
				ps_printf (ps, "%s", _paddr2str(x->av_un.av_psap,NULLNA,-1));
			else
				ps_printf (ps, "%s", paddr2str(x->av_un.av_psap,NULLNA));
			break;
		case AV_DN:
			dn_print (ps,x->av_un.av_dn,format);
			if (format == EDBOUT)
				ps_print (ps,"#");
			break;
		case AV_SCHEMA:
			tree_struct_print (ps,x->av_un.av_tree,format);
			break;
		case AV_UPDATE:
			edb_info_print (ps,x->av_un.av_update,format);
			break;
		case AV_BOOLEAN:
			if ( x->av_un.av_boolean )
				ps_print (ps,"TRUE");
			else
				ps_print (ps,"FALSE");
			break;
		case AV_INTEGER:
			ps_printf (ps,"%d",x->av_un.av_integer);
			break;
		case AV_TIME:
			ps_printf (ps,"%d",x->av_un.av_time);
			break;
		case AV_OID:
			if ( format == READOUT)
				ps_printf (ps,"%s",oid2name (x->av_un.av_oid,oidformat));
			else
				ps_printf (ps,"%s",oid2name (x->av_un.av_oid,OIDPART));
			break ;
		case AV_OBJECTCLASS:
			if (x->av_un.av_objectclass == NULLOBJECTCLASS) {
				/* print the oid from the PE */
				if (x->av_pe != NULLPE) 
					ps_printf (ps,"%s",sprintoid(prim2oid(x->av_pe)));
				else 
					LLOG(log_dsap,LLOG_EXCEPTIONS,("Object class botch"));
				break;
			}
			if ( format != READOUT)
				ps_printf (ps,"%s",oc2name (x->av_un.av_objectclass,OIDPART));
			else
				ps_printf (ps,"%s",oc2name (x->av_un.av_objectclass,oidformat));
			break ;
		default:
			LLOG (log_dsap,LLOG_EXCEPTIONS,("Unknown attribute syntax %d",x->av_syntax));
			if (x->av_pe != NULLPE)
				pe_print (ps,x->av_pe,format);
			break;
	}
}

static int dflt_attr_file (at,x)
AttributeType  at;
AttributeValue x;
{
	/* make default file name */
char buffer [LINESIZE];
PS sps;
char *pathend, val, *_isodefile();
char *path = NULLCP;

	x->av_un.av_file.fs_default = TRUE;
	if ((parse_file != NULLCP) && ((pathend = rindex (parse_file,'/')) != NULLCP)) {
		val = *++pathend;
		*pathend = 0;
		path = parse_file;
	}
	sps = ps_alloc (str_open);
	if (str_setup (sps,buffer,LINESIZE,1) == NOTOK) 
		return (NOTOK);

	if (parse_rdn == NULLRDN) 
		ps_print (sps,at->at_table->oa_ot.ot_name);
	else {
		rdn_print (sps,parse_rdn,EDBOUT);
		ps_printf (sps,".%s",at->at_table->oa_ot.ot_name);
	}
	*sps->ps_ptr = 0;
	ps_free (sps);
	if (path != NULLCP)
		x->av_un.av_file.fs_name = strdup (_isodefile(path,buffer));
	else
		x->av_un.av_file.fs_name = strdup (buffer);
	if (pathend != NULLCP)
		*pathend = val;

	return (OK);
}