![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to oid.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common|
Return to oid.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
1.1 root 1: /* oid.c - Object Identifier routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/dsap/common/RCS/oid.c,v 7.3 90/07/09 14:34:50 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/dsap/common/RCS/oid.c,v 7.3 90/07/09 14:34:50 mrose Exp $
9: *
10: *
11: * $Log: oid.c,v $
12: * Revision 7.3 90/07/09 14:34:50 mrose
13: * sync
14: *
15: * Revision 7.2 90/04/18 08:50:05 mrose
16: * 6.2
17: *
18: * Revision 7.1 89/12/19 16:19:25 mrose
19: * sync
20: *
21: * Revision 7.0 89/11/23 21:42:32 mrose
22: * Release 6.0
23: *
24: */
25:
26: /*
27: * NOTICE
28: *
29: * Acquisition, use, and distribution of this module and related
30: * materials are subject to the restrictions of a license agreement.
31: * Consult the Preface in the User's Manual for the full terms of
32: * this agreement.
33: *
34: */
35:
36:
37: /* LINTLIBRARY */
38:
39: #include "quipu/util.h"
40: #include "quipu/entry.h"
41: #include "cmd_srch.h"
42: #include "tailor.h"
43:
44: extern char chrcnv [];
45:
46: extern LLog * log_dsap;
47:
48: FILE * f_table;
49:
50: static char * get_entry ();
51: static add_entry ();
52: char * get_oid();
53: static char * name2gen ();
54: add_entry_aux ();
55:
56: oid_table OIDTable [TABLESIZE];
57: oid_table_attr attrOIDTable [TABLESIZE];
58: objectclass ocOIDTable [TABLESIZE];
59:
60:
61: int NumEntries = 0;
62: int attrNumEntries = 0;
63: int ocNumEntries = 0;
64:
65: unsigned attr_index = 0;
66:
67: #define GEN 1
68: #define ATTR 2
69: #define OC 3
70:
71:
72: #define PBUCKETS 128
73: #define PHASH(nm) \
74: (((nm)[1]) ? (((chrcnv[((nm)[0])] - chrcnv[((nm)[1])]) & 0x1f) + ((chrcnv[(nm)[2]]) & 0x5f)) \
75: : (chrcnv[(nm)[0]]) & 0x7f)
76:
77: struct pair {
78: char *p_name;
79: caddr_t p_value;
80: int p_type;
81: struct pair *p_chain;
82: };
83:
84: struct aliases {
85: char * a_full;
86: char * a_alias;
87: };
88:
89: static struct aliases Palias[LOTS];
90: static int Palias_next = 0;
91: static struct pair *Pbuckets[PBUCKETS];
92:
93: IFP oc_load = NULLIFP;
94: IFP oc_macro_add = NULLIFP;
95:
96: load_oid_table (table)
97: char * table;
98: {
99: register char * name;
100: char filename [FILNSIZE];
101: register char * extension;
102: char *isodetable;
103:
104: if (NumEntries != 0)
105: return; /* already loaded */
106:
107: isodetable = isodefile(table, 0);
108:
109: (void) strcpy (filename,isodetable);
110: extension = &filename[strlen(isodetable)];
111:
112: (void) strcpy (extension,".gen");
113: if (( f_table = fopen (filename,"r")) == (FILE *) NULL) {
114: LLOG (log_dsap,LLOG_FATAL,("file %s",filename));
115: fatal (-91,"Can't open oidtable.gen");
116: }
117:
118: while (1) { /* break out */
119: if ( (name = get_entry ()) == NULLCP)
120: break;
121: add_entry (name,GEN);
122: }
123: (void) fclose (f_table);
124:
125: (void) strcpy (extension,".at");
126: if (( f_table = fopen (filename,"r")) == (FILE *) NULL) {
127: LLOG (log_dsap,LLOG_FATAL,("file %s",filename));
128: fatal (-92,"Can't open oidtable.at");
129: }
130:
131: while (1) { /* break out */
132: if ( (name = get_entry ()) == NULLCP)
133: break;
134: add_entry (name,ATTR);
135: }
136: (void) fclose (f_table);
137:
138: (void) strcpy (extension,".oc");
139: if (( f_table = fopen (filename,"r")) == (FILE *) NULL) {
140: LLOG (log_dsap,LLOG_FATAL,("file %s",filename));
141: fatal (-93,"Can't open oidtable.oc");
142: }
143:
144: while (1) { /* break out */
145: if ( (name = get_entry ()) == NULLCP)
146: break;
147: add_entry (name,OC);
148: }
149: (void) fclose (f_table);
150:
151: }
152:
153: add_entry_aux (a,b,c,d)
154: char * a;
155: caddr_t b;
156: int c;
157: char * d;
158: {
159: int i;
160: register struct pair *p;
161:
162: if ((p = (struct pair *) calloc (1, sizeof *p)) == NULL) {
163: SLOG (log_dsap, LLOG_EXCEPTIONS, NULLCP,
164: ("calloc of alias structure failed"));
165: return;
166: }
167:
168: p -> p_name = a;
169: p -> p_value = b;
170: p -> p_type = c;
171: p -> p_chain = Pbuckets[i = PHASH (p -> p_name)];
172: Pbuckets[i] = p;
173:
174: if (d != NULLCP) {
175: if ((p = (struct pair *) calloc (1, sizeof *p)) == NULL) {
176: SLOG (log_dsap, LLOG_EXCEPTIONS, NULLCP,
177: ("calloc of alias (2) structure failed"));
178: return;
179: }
180:
181: Palias[Palias_next].a_full = a;
182: Palias[Palias_next++].a_alias = d;
183:
184: p -> p_name = d;
185: p -> p_value = b;
186: p -> p_type = c;
187: p -> p_chain = Pbuckets[i = PHASH (p -> p_name)];
188: Pbuckets[i] = p;
189: }
190:
191: }
192:
193:
194: static add_entry (newname,towho)
195: char * newname;
196: int towho;
197: {
198: register char *nptr, *ptr, *sep;
199: OID oid;
200: oid_table * Current;
201: char * alias = NULLCP;
202:
203: if ((nptr = index (newname,SEPERATOR)) == 0) {
204: LLOG (log_dsap,LLOG_FATAL,("oid missing in %s",newname));
205: return;
206: }
207: *nptr = 0;
208: if ((sep = index (newname,COMMA)) != 0) {
209: *sep++ = 0;
210: alias = strdup(newname);
211: newname = sep;
212: }
213:
214: switch (towho) {
215: case GEN:
216: Current = &OIDTable[NumEntries];
217: (void) strcpy (Current->ot_name, newname);
218: add_entry_aux (Current->ot_name,(caddr_t)&OIDTable[NumEntries],GEN,alias);
219: break;
220: case ATTR:
221: Current = &attrOIDTable[attrNumEntries].oa_ot;
222: (void) strcpy (Current->ot_name, newname);
223: add_entry_aux (Current->ot_name,(caddr_t)&attrOIDTable[attrNumEntries],ATTR,alias);
224: break;
225: case OC:
226: Current = &ocOIDTable[ocNumEntries].oc_ot;
227: (void) strcpy (Current->ot_name, newname);
228: add_entry_aux (Current->ot_name,(caddr_t)&ocOIDTable[ocNumEntries],OC,alias);
229: break;
230: }
231: *nptr = SEPERATOR;
232: nptr++;
233:
234: if ((sep = index (nptr,SEPERATOR)) != 0)
235: *sep++ = 0;
236:
237: ptr = get_oid (nptr);
238: if (ptr == NULLCP) {
239: LLOG (log_dsap,LLOG_FATAL,("invalid oid '%s'",nptr));
240: return;
241: }
242: (void) strcpy (Current->ot_stroid,ptr);
243:
244: oid = str2oid (Current->ot_stroid);
245: if (oid == NULLOID)
246: Current->ot_oid = NULLOID;
247: /* only reason for failure is generic oid of length 1 */
248: else
249: Current->ot_oid = oid_cpy (oid);
250:
251: /* now do special work for at and oc types */
252: switch (towho) {
253: case GEN:
254: NumEntries++; /* nothing else to do */
255: break;
256: case ATTR:
257: if (sep == 0)
258: LLOG (log_dsap,LLOG_FATAL,("syntax missing in %s",newname));
259: else {
260: if (( ptr = index (sep,SEPERATOR)) != NULLCP) {
261: *ptr++ = 0;
262: if (lexequ (ptr,"FILE") != 0)
263: LLOG (log_dsap,LLOG_FATAL,("FILE syntax expected, '%s' found",ptr));
264: else {
265: attrOIDTable[attrNumEntries].oa_syntax = str2syntax(sep);
266: attrOIDTable[attrNumEntries].oa_syntax += AV_WRITE_FILE;
267: attrNumEntries++;
268: }
269: } else {
270: attrOIDTable[attrNumEntries].oa_syntax = str2syntax(sep);
271: attrNumEntries++;
272: }
273: }
274: break;
275: case OC:
276: if (oc_load != NULLIFP) {
277: if ((*oc_load)(sep,ptr) == OK)
278: ocNumEntries++;
279: }
280: else
281: ocNumEntries++;
282: }
283: return;
284: }
285:
286: char * get_oid (str)
287: char * str;
288: {
289: static char buffer [BUFSIZE];
290: register char * ptr = buffer;
291: register char * dotptr;
292: register char * soid;
293: char deref = FALSE;
294:
295: if ( ! isdigit(*str))
296: if ((dotptr = index (str,DOT)) == 0)
297: return (name2gen(str));
298:
299: while (*str != 0) {
300: if ( (! isdigit (*str)) && (*str != DOT) ) {
301: if ((dotptr = index (str,DOT)) == 0) {
302: *--ptr = 0;
303: return (buffer);
304: }
305: *dotptr = 0;
306: *ptr = 0;
307: if ((soid = name2gen(str)) == NULLCP) {
308: *dotptr = DOT;
309: return (NULLCP);
310: }
311: *dotptr = DOT;
312: str = dotptr;
313: if (deref) {
314: if ((dotptr = rindex (soid,DOT)) == 0)
315: return (NULLCP); /* invalid */
316: if ((strncmp (soid,buffer,strlen(buffer))) != 0)
317: return (NULLCP); /* inconsistent */
318: }
319: deref = TRUE;
320: (void) strcpy (buffer,soid);
321: ptr = buffer + strlen (soid);
322: }
323: else
324: *ptr++ = *str++;
325: }
326:
327: *ptr = 0;
328: return (buffer);
329: }
330:
331: static char * name2gen (nodename)
332: char * nodename;
333: {
334: register int i;
335: register oid_table * tblptr = &OIDTable[0];
336:
337: for (i=0;i<NumEntries;i++,tblptr++) {
338: if (lexequ (tblptr->ot_name, nodename) == 0)
339: return (tblptr->ot_stroid);
340: }
341:
342: return (NULLCP);
343: }
344:
345: static char * soid2gen (soid)
346: char * soid;
347: {
348: register int i;
349: register oid_table * tblptr = &OIDTable[0];
350: for (i=0;i<NumEntries;i++,tblptr++) {
351: if (strcmp (tblptr->ot_stroid, soid) == 0)
352: return (tblptr->ot_name);
353: }
354:
355: return (NULLCP);
356: }
357:
358: static char * get_line ()
359: {
360: static char buffer [LINESIZE];
361: register char * buf = buffer;
362: register char * ptr = buffer;
363: register int done;
364:
365: /* read line, ignore comments, join lines in '/' found */
366:
367: do {
368: done = TRUE;
369: if (fgets (buf,LINESIZE,f_table) == NULLCP)
370: return (NULLCP);
371:
372: StripSpace (buf);
373: if (*buf != 0) {
374: ptr += strlen(buf) - 1;
375: if (*ptr == '\\') {
376: buf = ptr;
377: done = FALSE;
378: }
379: } else
380: done = FALSE;
381: } while (done == FALSE);
382:
383: return (buffer);
384: }
385:
386: static char * get_entry ()
387: {
388: register char * buf;
389: register char * ptr;
390:
391: /* read next line - test for macro defs */
392: while (1) { /* return out */
393: if ((buf = get_line ()) == NULLCP)
394: return (NULLCP);
395:
396: if ((ptr = index (buf,'=')) != 0) {
397: *ptr++ = 0;
398: if (oc_macro_add != NULLIFP) {
399: (*oc_macro_add) (buf,ptr);
400: }
401: } else
402: return (buf);
403:
404: }
405:
406:
407: }
408:
409: oid_table_attr *name2attr(nodename)
410: char * nodename;
411: {
412: register int i;
413: register char * ptr;
414: char * str;
415: register oid_table_attr * atrptr = &attrOIDTable[0];
416:
417: attr_index = 0;
418:
419: if ((ptr = rindex (nodename,DOT)) == 0) {
420: struct pair *p;
421: for (p = Pbuckets[PHASH (nodename)];
422: p && lexequ (p -> p_name, nodename);
423: p = p -> p_chain)
424: ; /* NO-OP */
425:
426: if ((p != NULL) && (p->p_type == ATTR)) {
427: attr_index = ((oid_table_attr *) p->p_value) - atrptr;
428: return ( (oid_table_attr *) p->p_value);
429: } else
430: return (NULLTABLE_ATTR);
431:
432: } else {
433: if ((str = get_oid (nodename)) == NULLCP) {
434: LLOG (log_dsap,LLOG_FATAL,("invalid oid '%s'",nodename));
435: return (NULLTABLE_ATTR);
436: }
437: if (isdigit (*++ptr)) {
438: for (i=0;i<attrNumEntries;i++,atrptr++)
439: if (lexequ (atrptr->oa_ot.ot_stroid, str) == 0) {
440: attr_index = atrptr - &attrOIDTable[0];
441: return (atrptr);
442: }
443: return (NULLTABLE_ATTR);
444: } else {
445: for (i=0;i<attrNumEntries;i++,atrptr++)
446: if (lexequ (atrptr->oa_ot.ot_name, ptr) == 0)
447: if (strncmp (str,atrptr->oa_ot.ot_stroid,strlen(str)) == 0) {
448: attr_index = atrptr - &attrOIDTable[0];
449: return (atrptr);
450: } else
451: return (NULLTABLE_ATTR);
452: }
453: }
454: return (NULLTABLE_ATTR);
455:
456: }
457:
458: set_heap (x)
459: AttributeType x;
460: {
461: if (x == NULLTABLE_ATTR)
462: return 0;
463:
464: return (attr_index = x - &attrOIDTable[0]);
465:
466: }
467:
468: oid_table_attr *oid2attr(oid)
469: OID oid;
470: {
471: register int i;
472: register oid_table_attr * ptr = &attrOIDTable[0];
473:
474: for (i=0;i<attrNumEntries;i++,ptr++) {
475: if (oid_cmp (ptr->oa_ot.ot_oid, oid) == 0)
476: return (ptr);
477: }
478:
479: return (NULLTABLE_ATTR);
480: }
481:
482: objectclass *name2oc(nodename)
483: register char * nodename;
484: {
485: register int i;
486: register char * ptr;
487: char * str;
488: register objectclass * oc = & ocOIDTable[0];
489:
490: if ((ptr = rindex (nodename,DOT)) == 0) {
491: struct pair *p;
492: for (p = Pbuckets[PHASH (nodename)];
493: p && lexequ (p -> p_name, nodename);
494: p = p -> p_chain)
495: ; /* NO-OP */
496:
497: if ((p != NULL) && (p->p_type == OC))
498: return ( (objectclass *) p->p_value);
499: else
500: return (NULLOBJECTCLASS);
501: } else {
502: str = get_oid (nodename);
503: if (isdigit (*++ptr)) {
504: for (i=0;i<ocNumEntries;i++,oc++)
505: if (lexequ (oc->oc_ot.ot_stroid, str) == 0)
506: return (oc);
507: return (NULLOBJECTCLASS);
508: } else {
509: for (i=0;i<ocNumEntries;i++,oc++)
510: if (lexequ (oc->oc_ot.ot_name, ptr) == 0)
511: if (strncmp (str,oc->oc_ot.ot_stroid,strlen(str)) == 0)
512: return (oc);
513: else
514: return (NULLOBJECTCLASS);
515:
516: }
517: }
518:
519: return (NULLOBJECTCLASS);
520: }
521:
522:
523: objectclass *oid2oc(oid)
524: OID oid;
525: {
526: register int i;
527: register objectclass * oc = &ocOIDTable[0];
528:
529: for (i=0;i<ocNumEntries;i++,oc++) {
530: if (oid_cmp (oc->oc_ot.ot_oid, oid) == 0)
531: return (oc);
532: }
533:
534: return (NULLOBJECTCLASS);
535: }
536:
537:
538: static char * full_gen (ot)
539: oid_table * ot;
540: {
541: static char buffer [BUFSIZ];
542: register char * ptr = buffer;
543: register char * soid;
544: register char * str;
545:
546: buffer [0] = '\0';
547: str = sprintoid (ot->ot_oid);
548:
549: soid = str;
550:
551: while (*str != '\0')
552: if ( *str == DOT) {
553: *str = '\0';
554: ptr = soid2gen (soid);
555: if (ptr == NULLCP) {
556: *str++ = DOT;
557: continue;
558: }
559: (void) strcat (buffer,".");
560: (void) strcat (buffer,ptr);
561: *str++ = DOT;
562: } else
563: str++;
564:
565: (void) strcat (buffer,".");
566: (void) strcat (buffer,ot->ot_name);
567: return (&buffer[1]);
568: }
569:
570: static char * part_gen (ot)
571: oid_table * ot;
572: {
573: static char buffer [BUFSIZ];
574: register char * ptr = buffer;
575: register char * soid;
576: register char * str;
577: char * last;
578:
579: if (index (ot->ot_name,DOT) == NULLCP)
580: return (ot->ot_name);
581:
582: str = sprintoid (ot->ot_oid);
583:
584: soid = str;
585: last = str;
586:
587: while (*str != '\0')
588: if ( *str == DOT) {
589: *str = '\0';
590: ptr = soid2gen (soid);
591: if (ptr == NULLCP) {
592: *str++ = DOT;
593: break;
594: } else
595: (void) strcpy (buffer,ptr);
596: last = str;
597: *str++ = DOT;
598:
599: } else
600: str++;
601:
602: (void) strcat (buffer,last);
603: return (buffer);
604: }
605:
606: char *attr2name_aux (oa)
607: register oid_table_attr *oa;
608: {
609: if ( oa != NULLTABLE_ATTR)
610: return (oa->oa_ot.ot_name);
611: else {
612: LLOG (log_dsap,LLOG_EXCEPTIONS,("NULL table entry"));
613: return (NULLCP);
614: }
615: }
616:
617: char *attr2name(oa,format)
618: register oid_table_attr *oa;
619: int format;
620: {
621: int x;
622:
623: if ( oa != NULLTABLE_ATTR)
624: switch (format) {
625: case OIDFULL:
626: return (full_gen (&oa->oa_ot));
627: case OIDNUM:
628: return (oa->oa_ot.ot_stroid);
629: default:
630: /* look for long name */
631: for (x=0; x<Palias_next; x++)
632: if (lexequ (Palias[x].a_full,oa->oa_ot.ot_name) == 0)
633: return (Palias[x].a_alias);
634: return (part_gen (&oa->oa_ot));
635: }
636: else {
637: LLOG (log_dsap,LLOG_EXCEPTIONS,("NULL table entry"));
638: return (NULLCP);
639: }
640: }
641:
642:
643: char *oc2name(oc,format)
644: register objectclass *oc;
645: int format;
646: {
647: if ( oc != NULLOBJECTCLASS)
648: switch (format) {
649: case OIDFULL:
650: return (full_gen (&oc->oc_ot));
651: case OIDNUM:
652: return (oc->oc_ot.ot_stroid);
653: default:
654: return (part_gen (&oc->oc_ot));
655: }
656: else
657: return (NULLCP);
658: }
659:
660: char *oid2name(oid,format)
661: OID oid;
662: int format;
663: {
664: oid_table_attr * at;
665: objectclass * oc;
666: register int i;
667: register oid_table* ptr = &OIDTable[0];
668: char * sptr;
669:
670: /* try attribute first */
671: if (( at = oid2attr (oid)) != NULLTABLE_ATTR)
672: return (attr2name(at,format)) ;
673:
674: /* try objectclass */
675: if (( oc = oid2oc (oid)) != NULLOBJECTCLASS)
676: return (oc2name(oc,format)) ;
677:
678: /* try gen tables */
679: for (i=0; i<NumEntries;i++,ptr++) {
680: if (oid_cmp (ptr->ot_oid, oid) == 0) {
681: switch (format) {
682: case OIDFULL:
683: return (full_gen (ptr));
684: case OIDNUM:
685: return (ptr->ot_stroid);
686: default:
687: return (part_gen (ptr));
688: }
689: }
690: }
691:
692: if ((sptr = oid2ode_aux (oid,0)) == NULLCP)
693: parse_error ("Bad OID '%s'",sprintoid (oid));
694:
695: return (sptr);
696:
697: }
698:
699: OID name2oid (str)
700: register char * str;
701: {
702: register struct pair *p;
703: OID ptr;
704:
705: for (p = Pbuckets[PHASH (str)];
706: p && lexequ (p -> p_name, str);
707: p = p -> p_chain)
708: ; /* NO-OP */
709:
710: if (p != NULL)
711: switch (p -> p_type) {
712: case GEN: {
713: oid_table * ot;
714: ot = (oid_table *) p->p_value;
715: return (oid_cpy(ot->ot_oid));
716: }
717: case ATTR: {
718: oid_table_attr * at;
719: at = (oid_table_attr *) p->p_value;
720: return (oid_cpy(at->oa_ot.ot_oid)) ;
721: }
722: case OC: {
723: objectclass * oc;
724: oc = (objectclass *) p->p_value;
725: return (oid_cpy(oc->oc_ot.ot_oid)) ;
726: }
727: default:
728: if ( (ptr=ode2oid (str)) == NULLOID)
729: return (oid_cpy(str2oid(str)));
730: return (oid_cpy(ptr));
731: }
732: else {
733: /* try general oid lookup */
734: char * x;
735: if ((x=get_oid(str)) != NULLCP)
736: return (oid_cpy(str2oid(x)));
737:
738: /* try isobjects */
739: if ( (ptr=ode2oid (str)) == NULLOID) {
740: if ((ptr=str2oid(str)) == NULLOID) {
741: parse_error ("unknown OID '%s'",str);
742: return NULLOID;
743: }
744: return (oid_cpy(ptr));
745: }
746: return (oid_cpy(ptr));
747: }
748:
749: }
750:
751: PE oid2pe (o)
752: OID o;
753: {
754: /* needed cos of a macro */
755: return (oid2prim (o));
756: }
757:
758: oidprint (ps,o,format)
759: PS ps;
760: OID o;
761: int format;
762: {
763: extern int oidformat;
764:
765: if (format == READOUT)
766: ps_printf (ps,"%s",oid2name(o,oidformat));
767: else
768: ps_printf (ps,"%s",oid2name(o,OIDPART));
769: }
770:
771: OID dup_prim2oid (pe)
772: PE pe;
773: {
774: OID oid;
775:
776: if (! test_prim_pe (pe,PE_CLASS_UNIV,PE_PRIM_OID))
777: return (NULLOID);
778:
779: if (( oid = prim2oid(pe)) == NULLOID)
780: return (NULLOID);
781:
782: return (oid_cpy(oid));
783: }
784:
785: oid_syntax ()
786: {
787: (void) add_attribute_syntax ("oid",
788: (IFP) oid2pe, (IFP) dup_prim2oid,
789: (IFP) name2oid, oidprint,
790: (IFP) oid_cpy, oid_cmp,
791: oid_free, NULLCP,
792: NULLIFP, FALSE );
793: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.