oid.c

来自「ftam等标准协议服务器和客户端的源代码。」· C语言 代码 · 共 926 行 · 第 1/2 页

				if (left <= 20) {
				    buflen += LINESIZE;
				    if ((buffer = realloc(buffer, 
						  (unsigned)buflen)) == NULL)
					return (NULL);
				    size = strlen(buffer);
				    buf = buffer + size - 1;
				    left = buflen - size;
				}
			}
		} else
			done = FALSE;
	} while (done == FALSE);

	return (buffer);
}

static char * get_entry ()
{
register char * buf;
register char * ptr;

	/* read next line - test for macro defs */
	while (1) { /* return out */
		if ((buf = get_line ()) == NULLCP)
			return (NULLCP);

		if ((ptr = index (buf,'=')) != 0) {
			*ptr++ = 0;
			if (oc_macro_add != NULLIFP) {
				(*oc_macro_add) (buf,ptr);
			}
		} else
			return (buf);

	}


}

oid_table_attr *name2attr(nodename)
char * nodename;
{
register int i;
register char * ptr;
char * str;
register oid_table_attr * atrptr = &attrOIDTable[0];

	attr_index = 0;

	if ((ptr = rindex (nodename,DOT)) == 0) {
		struct pair *p;
		for (p = Pbuckets[PHASH (nodename)];
			p && lexequ (p -> p_name, nodename);
	     		p = p -> p_chain) 
				; /* NO-OP */

		if ((p != NULL) && (p->p_type == ATTR)) {
			attr_index = ((oid_table_attr *) p->p_value) - atrptr;
			return ( (oid_table_attr *) p->p_value);
		} else 
			return (NULLTABLE_ATTR);

	} else {
		if ((str = get_oid (nodename)) == NULLCP) {
			LLOG (log_dsap,LLOG_FATAL,("invalid oid '%s'",nodename));
			return (NULLTABLE_ATTR);
		}
		if (isdigit (*++ptr)) {
			for (i=0;i<attrNumEntries;i++,atrptr++)
				if (lexequ (atrptr->oa_ot.ot_stroid, str) == 0) {
					attr_index = atrptr - &attrOIDTable[0];
					return (atrptr);
				}
			return (NULLTABLE_ATTR);
		} else {
			for (i=0;i<attrNumEntries;i++,atrptr++)
				if (lexequ (atrptr->oa_ot.ot_name, ptr) == 0)
					if (strncmp (str,atrptr->oa_ot.ot_stroid,strlen(str)) == 0) {
						attr_index = atrptr - &attrOIDTable[0];
						return (atrptr);
					} else
						return (NULLTABLE_ATTR);
		}
	}
	return (NULLTABLE_ATTR);
	
}

set_heap (x)
AttributeType x;
{
	if (x == NULLTABLE_ATTR)
		return 0;

	return (attr_index = x - &attrOIDTable[0]);
		
}

oid_table_attr *oid2attr(oid)
OID oid;
{
register int i;
register oid_table_attr * ptr = &attrOIDTable[0];

	for (i=0;i<attrNumEntries;i++,ptr++) {
		if (oid_cmp (ptr->oa_ot.ot_oid, oid) == 0)
			return (ptr);
		else if (oid_cmp (ptr->oa_ot.ot_aliasoid, oid) == 0)
			return (ptr);
		
	}

	return (NULLTABLE_ATTR);
}

objectclass *name2oc(nodename)
register char * nodename;
{
register int i;
register char * ptr;
char * str;
register objectclass * oc = & ocOIDTable[0];

	if ((ptr = rindex (nodename,DOT)) == 0) {
		struct pair *p;
		for (p = Pbuckets[PHASH (nodename)];
			p && lexequ (p -> p_name, nodename);
	     		p = p -> p_chain) 
				; /* NO-OP */

		if ((p != NULL) && (p->p_type == OC))
			return ( (objectclass *) p->p_value);
		else 
			return (NULLOBJECTCLASS);
	} else {
		str = get_oid (nodename);
		if (isdigit (*++ptr)) {
			for (i=0;i<ocNumEntries;i++,oc++)
				if (lexequ (oc->oc_ot.ot_stroid, str) == 0)
				return (oc);
			return (NULLOBJECTCLASS);
		} else {
			for (i=0;i<ocNumEntries;i++,oc++)
				if (lexequ (oc->oc_ot.ot_name, ptr) == 0)
					if (strncmp (str,oc->oc_ot.ot_stroid,strlen(str)) == 0)
						return (oc);
					else
						return (NULLOBJECTCLASS);

		}
	}

	return (NULLOBJECTCLASS);
}


objectclass *oid2oc(oid)
OID oid;
{
register int i;
register objectclass * oc = &ocOIDTable[0];

	for (i=0;i<ocNumEntries;i++,oc++) {
		if (oid_cmp (oc->oc_ot.ot_oid, oid) == 0)
			return (oc);
		else if (oid_cmp (oc->oc_ot.ot_aliasoid, oid) == 0)
			return (oc);
	}

	return (NULLOBJECTCLASS);
}


static char * full_gen (ot)
oid_table * ot;
{
static char * buffer;
register char * ptr;
register char * soid;
register char * str;

        if (buffer == NULLCP)
	      buffer = smalloc (LINESIZE);

	ptr = buffer;

	buffer [0] = '\0';
	str = sprintoid (ot->ot_oid);

	soid   = str;

	while (*str != '\0')
		if ( *str == DOT)  {
			*str = '\0';
			ptr = soid2gen (soid);
			if (ptr == NULLCP) {
				*str++ = DOT;
				continue;
			}
			(void) strcat (buffer,".");
			(void) strcat (buffer,ptr);
			*str++ = DOT;
		} else
			str++;
	
	(void) strcat (buffer,".");
	(void) strcat (buffer,ot->ot_name);
	return (&buffer[1]);
}

static char * part_gen (ot)
oid_table * ot;
{
static char * buffer = NULLCP;
register char * ptr;
register char * soid;
register char * str;
char * last;

        if (buffer == NULLCP)
	      buffer = smalloc (LINESIZE);

	ptr = buffer;

	if (index (ot->ot_name,DOT) == NULLCP)
		return (ot->ot_name);

	str = sprintoid (ot->ot_oid);

	soid = str;
	last = str;

	while (*str != '\0')
		if ( *str == DOT)  {
			*str = '\0';
			ptr = soid2gen (soid);
			if (ptr == NULLCP) {
				*str++ = DOT;
				break;
			} else
				(void) strcpy (buffer,ptr);
			last = str;
			*str++ = DOT;
			
		} else
			str++;

	(void) strcat (buffer,last);
	return (buffer);
}

#ifndef attr2name_aux
char *attr2name_aux (oa)
register oid_table_attr *oa;
{
	if ( oa != NULLTABLE_ATTR)
		return (oa->oa_ot.ot_name);
	else {
		LLOG (log_dsap,LLOG_EXCEPTIONS,("NULL table entry"));
		return (NULLCP);
	}
}
#endif

char *attr2name(oa,format)
register oid_table_attr *oa;
int format;
{
int x;

	if ( oa != NULLTABLE_ATTR)
		switch (format) {
		case OIDFULL:
			return (full_gen (&oa->oa_ot));
		case OIDNUM:
			return (oa->oa_ot.ot_stroid);
		default:
			/* look for long name */
			for (x=0; x<Palias_next; x++)
				if (lexequ (Palias[x].a_full,oa->oa_ot.ot_name) == 0)
					return (Palias[x].a_alias);
			return (part_gen (&oa->oa_ot));
		}
	else {
		LLOG (log_dsap,LLOG_EXCEPTIONS,("NULL table entry"));
		return (NULLCP);
	}
}


char *oc2name(oc,format)
register objectclass *oc;
int format;
{
	if ( oc != NULLOBJECTCLASS)
		switch (format) {
		case OIDFULL:
			return (full_gen (&oc->oc_ot));
		case OIDNUM:
			return (oc->oc_ot.ot_stroid);
		default:
			return (part_gen (&oc->oc_ot));
		}
	else
		return (NULLCP);
}

char *oid2name(oid,format)
OID oid;
int format;
{
oid_table_attr * at;
objectclass * oc;
register int i;
register oid_table* ptr = &OIDTable[0];
char * sptr;

	/* try attribute first */
	if (( at = oid2attr (oid)) != NULLTABLE_ATTR)
		return (attr2name(at,format)) ;

	/* try objectclass */
	if (( oc = oid2oc (oid)) != NULLOBJECTCLASS)
		return (oc2name(oc,format)) ;

	/* try gen tables */
	for (i=0; i<NumEntries;i++,ptr++) {
           if ((oid_cmp (ptr->ot_oid, oid) == 0) ||
       		oid_cmp (ptr->ot_aliasoid, oid) == 0) {
		switch (format) {
		case OIDFULL:
			return (full_gen (ptr));
		case OIDNUM:
			return (ptr->ot_stroid);
		default:
			return (part_gen (ptr));
		}
	   }
	}

	if ((sptr = oid2ode_aux (oid,0)) == NULLCP)
		parse_error ("Bad OID '%s'",sprintoid (oid));

	return (sptr);

}

OID name2oid (str)
register char * str;
{
register struct pair *p;
OID ptr;

	if (*str == 0)
		return NULLOID;

	for (p = Pbuckets[PHASH (str)];
		p && lexequ (p -> p_name, str);
     		p = p -> p_chain) 
			; /* NO-OP */

	if (p != NULL)
		switch (p -> p_type) {
		    case GEN: {
			oid_table * ot;
			ot = (oid_table *) p->p_value;
			return (oid_cpy(ot->ot_oid));
		    }
		    case ATTR: {
			oid_table_attr * at;
			at = (oid_table_attr *) p->p_value;
			return (oid_cpy(at->oa_ot.ot_oid)) ;
		    }
		    case OC: {
			objectclass * oc;
			oc = (objectclass *) p->p_value;
			return (oid_cpy(oc->oc_ot.ot_oid)) ;
		    }
		    default:
			if ( (ptr=ode2oid (str)) == NULLOID)
				return (oid_cpy(str2oid(str)));
			return (oid_cpy(ptr));
		}
	else {
 		/* try general oid lookup */
 		char * x;
 		if ((x=get_oid(str)) != NULLCP)
 			return (oid_cpy(str2oid(x)));
 		
		/* try isobjects */
		if ( (ptr=ode2oid (str)) == NULLOID) {
			if ((ptr=str2oid(str)) == NULLOID) {
				parse_error ("unknown OID '%s'",str);
				return NULLOID;
			}
			return (oid_cpy(ptr));
		}
		return (oid_cpy(ptr));
	}

}

PE oid2pe (o)
OID o;
{ 
/* needed cos of a macro */
	return (oid2prim (o));		
}

oidprint (ps,o,format)
PS ps;
OID o;
int format;
{
extern int oidformat;

	if (format == READOUT)
		ps_printf (ps,"%s",oid2name(o,oidformat));
	else
		ps_printf (ps,"%s",oid2name(o,OIDPART));
}

OID dup_prim2oid (pe)
PE pe;
{ 	
OID oid;

        if (! test_prim_pe (pe,PE_CLASS_UNIV,PE_PRIM_OID))
		return (NULLOID);

	if (( oid = prim2oid(pe)) == NULLOID)
		return (NULLOID);
	
	return (oid_cpy(oid));
}

void	free_oid_buckets()
{
int i;
struct pair *p, *np;
 
	for (i=0;i<PBUCKETS;i++) 
		for (p = Pbuckets[i]; p != (struct pair *)NULL ; p = np) {
			np = p -> p_chain;
			free (p->p_name);
			free ((char *)p);
		}
  
}


oid_syntax ()
{
	(void) add_attribute_syntax ("oid",
		(IFP) oid2pe,	(IFP) dup_prim2oid,
		(IFP) name2oid,	oidprint,
		(IFP) oid_cpy,	oid_cmp,
		oid_free,	NULLCP,
		NULLIFP,	FALSE );
}