![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to attrv.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 attrv.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
1.1 root 1: /* attrv.c - Attribute Value routines */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/dsap/common/RCS/attrv.c,v 7.4 90/07/09 14:34:00 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/dsap/common/RCS/attrv.c,v 7.4 90/07/09 14:34:00 mrose Exp $
9: *
10: *
11: * $Log: attrv.c,v $
12: * Revision 7.4 90/07/09 14:34:00 mrose
13: * sync
14: *
15: * Revision 7.3 90/04/18 08:50:00 mrose
16: * 6.2
17: *
18: * Revision 7.2 90/03/15 11:17:26 mrose
19: * quipu-sync
20: *
21: * Revision 7.1 90/01/11 18:35:30 mrose
22: * real-sync
23: *
24: * Revision 7.0 89/11/23 21:41:44 mrose
25: * Release 6.0
26: *
27: */
28:
29: /*
30: * NOTICE
31: *
32: * Acquisition, use, and distribution of this module and related
33: * materials are subject to the restrictions of a license agreement.
34: * Consult the Preface in the User's Manual for the full terms of
35: * this agreement.
36: *
37: */
38:
39:
40: /* LINTLIBRARY */
41:
42: #include "quipu/util.h"
43: #include "quipu/entry.h"
44: #include "quipu/ds_error.h"
45: #include "quipu/malloc.h"
46: #include "cmd_srch.h"
47: #include <sys/stat.h>
48:
49: extern int oidformat;
50: extern struct PSAPaddr * psap_cpy ();
51: extern str2asn (), pe_print() ;
52: AttributeValue str2file ();
53: extern LLog * log_dsap;
54: PE asn2pe();
55: int quipu_pe_cmp();
56: char t61_flag;
57: char crypt_flag;
58: char allow_crypt = FALSE;
59: extern int file_cmp ();
60:
61: static short num_syntax = 1;
62: static sntx_table syntax_table [MAX_AV_SYNTAX] = { {
63: "ASN", /* ASN - default type */
64: (IFP)pe_cpy, /* default encode */
65: NULLIFP, /* no decoding needed */
66: NULLIFP, /* default parse */
67: NULLIFP, /* default print */
68: (IFP)pe_cpy, /* default copy */
69: quipu_pe_cmp, /* default compare */
70: pe_free, /* default free */
71: NULLCP, /* no pe_printer */
72: NULLIFP, /* NO approx matching */
73: TRUE, /* one per line */
74: } };
75:
76:
77: short add_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline)
78: char * sntx;
79: IFP enc,dec,parse,print,cpy,cmp,sfree,approx;
80: char * print_pe;
81: char multiline;
82: {
83: if (num_syntax >= MAX_AV_SYNTAX)
84: return (-1);
85:
86: syntax_table[num_syntax].s_sntx = sntx;
87: set_attribute_syntax (num_syntax,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline);
88:
89: return (num_syntax++);
90: }
91:
92: set_attribute_syntax (sntx,enc,dec,parse,print,cpy,cmp,sfree,print_pe,approx,multiline)
93: short sntx;
94: IFP enc,dec,parse,print,cpy,cmp,sfree,approx;
95: char * print_pe;
96: char multiline;
97: {
98: syntax_table[sntx].s_encode = enc;
99: syntax_table[sntx].s_decode = dec;
100: syntax_table[sntx].s_parse = parse;
101: syntax_table[sntx].s_print = print;
102: syntax_table[sntx].s_copy = cpy;
103: syntax_table[sntx].s_compare = cmp;
104: syntax_table[sntx].s_free = sfree;
105: syntax_table[sntx].s_pe_print= print_pe;
106: syntax_table[sntx].s_approx = approx;
107: syntax_table[sntx].s_multiline = multiline;
108: }
109:
110: set_av_pe_print (sntx,print_pe)
111: short sntx;
112: char * print_pe;
113: {
114: syntax_table[sntx].s_pe_print= print_pe;
115: }
116:
117: split_attr (as)
118: Attr_Sequence as;
119: {
120:
121: if (as->attr_type == NULLTABLE_ATTR)
122: return (TRUE);
123: else
124: return (syntax_table[as->attr_type->oa_syntax].s_multiline);
125: }
126:
127: IFP approxfn (x)
128: int x;
129: {
130: return (syntax_table[x].s_approx);
131: }
132:
133: char * syntax2str (sntx)
134: short sntx;
135: {
136: return (syntax_table[sntx].s_sntx);
137: }
138:
139: short str2syntax (str)
140: char * str;
141: {
142: sntx_table * ptr;
143: register int i;
144:
145: for (i=0, ptr = &syntax_table[0] ; i<num_syntax; i++,ptr++)
146: if ( lexequ (ptr->s_sntx,str) == 0)
147: return (i);
148:
149: return (0);
150: }
151:
152: sntx_table * get_syntax_table (x)
153: short x;
154: {
155: return ( &syntax_table[x]);
156: }
157:
158: AttrV_free (x)
159: register AttributeValue x;
160: {
161: AttrV_free_aux (x);
162: free ((char *) x);
163: }
164:
165: AttrV_free_aux (x)
166: register AttributeValue x;
167: {
168: if (x == NULLAttrV)
169: return;
170:
171: if (x->av_syntax == AV_FILE) {
172: file_free ((struct file_syntax *)x->av_struct);
173: return;
174: }
175:
176: if (( x->av_syntax < AV_WRITE_FILE )
177: && (syntax_table[x->av_syntax].s_free != NULLIFP)
178: && (x->av_struct != NULL))
179: (*syntax_table[x->av_syntax].s_free) (x->av_struct);
180: }
181:
182: PE grab_pe(av)
183: AttributeValue av;
184: {
185: PE ret_pe = NULLPE;
186: PE grab_filepe ();
187:
188: if (av->av_syntax == AV_FILE)
189: ret_pe = grab_filepe (av);
190: else if (syntax_table[av->av_syntax].s_encode != NULLIFP)
191: ret_pe = (PE)((*syntax_table[av->av_syntax].s_encode) (av->av_struct));
192:
193: return (ret_pe);
194: }
195:
196: AttrV_decode(x,y)
197: register AttributeType x;
198: register AttributeValue y;
199: {
200: int y_syntax;
201:
202: if (x == NULLAttrT)
203: return (NOTOK);
204:
205: if ((y == NULLAttrV) || (y->av_syntax != 0))
206: return (OK);
207:
208: if (y->av_struct == NULL)
209: return (OK);
210:
211: y->av_syntax = x->oa_syntax;
212: if ( (y_syntax = y->av_syntax) >= AV_WRITE_FILE )
213: y_syntax = y->av_syntax - AV_WRITE_FILE;
214:
215: ATTRIBUTE_HEAP;
216:
217: if (syntax_table[y_syntax].s_decode != NULLIFP) {
218: PE oldpe = (PE)y->av_struct;
219: if ((y->av_struct = (caddr_t)((*syntax_table[y_syntax].s_decode) (oldpe))) == NULL) {
220: RESTORE_HEAP;
221: y->av_struct = (caddr_t)oldpe;
222: y->av_syntax = 0;
223: return (NOTOK);
224: }
225: pe_free (oldpe);
226: }
227:
228: if ( y->av_syntax >= AV_WRITE_FILE )
229: file_decode (y);
230:
231: RESTORE_HEAP;
232:
233: return (OK);
234: }
235:
236: static strip_header(str)
237: char ** str;
238: {
239: register char * ptr, *save, val;
240: int syntax;
241: extern char * index();
242: static CMD_TABLE cmd_syntax [] = {
243: "FILE", 1,
244: "ASN", 2,
245: "T.61", 3,
246: "CRYPT", 4,
247: 0, 0,
248: } ;
249:
250:
251: if (*str == NULLCP)
252: return (0);
253:
254: *str = SkipSpace (*str);
255: if (**str == 0)
256: return (0);
257: ptr = *str;
258:
259: t61_flag = FALSE;
260: crypt_flag = FALSE;
261:
262: if (*ptr++ == '{') {
263: /* look for syntax */
264: if (( *str = index (ptr,'}')) == 0) {
265: parse_error ("syntax close bracket missing '%s'",--ptr);
266: return (0);
267: }
268: save = *str;
269: val = **str;
270:
271: *(*str)++ = 0;
272: *str = SkipSpace (*str);
273:
274: if ((syntax = cmd_srch (ptr,cmd_syntax)) == 0) {
275: parse_error ("unknown syntax '%s'",ptr);
276: return (0);
277: }
278: *save = val;
279:
280: if ((syntax == 4) && ! allow_crypt) {
281: parse_error ("{CRYPT} not allowed",ptr);
282: return (0);
283: }
284: return (syntax);
285:
286: }
287: return (5);
288: }
289:
290: str_at2AttrV_aux (str,at,rav)
291: char * str;
292: AttributeType at;
293: AttributeValue rav;
294: {
295: if (at == NULLAttrT)
296: return (NOTOK);
297:
298: switch (strip_header (&str)) {
299: case 0: /* error */
300: return (NOTOK);
301: case 1: /* FILE */
302: return (str2file_aux (str,at,rav));
303: case 2: /* ASN */
304: (void) str2AttrV_aux (str,0,rav);
305: return (AttrV_decode (at,rav));
306: case 3: /* T.61 */
307: t61_flag = TRUE;
308: return (str2AttrV_aux (SkipSpace(str),at->oa_syntax,rav));
309: case 4:
310: crypt_flag = TRUE;
311: /* fall */
312: case 5:
313: return (str2AttrV_aux (str,at->oa_syntax,rav));
314: }
315: return (NOTOK);
316: }
317:
318:
319: AttributeValue str_at2AttrV (str,at)
320: char * str;
321: AttributeType at;
322: {
323: AttributeValue av;
324:
325: if (at == NULLAttrT)
326: return (NULLAttrV);
327:
328: switch (strip_header(&str)) {
329: case 0: /* error */
330: return (NULLAttrV);
331: case 1: /* FILE */
332: return (str2file (str,at));
333: case 2: /* ASN */
334: av = str2AttrV (str,0);
335: if (AttrV_decode (at,av) == NOTOK)
336: return (NULLAttrV);
337: return (av);
338: case 3: /* T.61 */
339: t61_flag = TRUE;
340: return (str2AttrV (str,at->oa_syntax));
341: case 4:
342: crypt_flag = TRUE;
343: /* fall */
344: case 5:
345: return (str2AttrV (str,at->oa_syntax));
346: }
347: return (NULLAttrV);
348: }
349:
350: AttributeValue str2AttrV (str,syntax)
351: register char * str;
352: short syntax;
353: {
354: AttributeValue x;
355:
356: x = AttrV_alloc();
357: if (str2AttrV_aux (str,syntax,x) == OK)
358: return (x);
359: free ((char *)x);
360: return NULLAttrV;
361: }
362:
363: str2AttrV_aux (str,syntax,x)
364: register char * str;
365: short syntax;
366: AttributeValue x;
367: {
368:
369: if (str == NULLCP)
370: return (NOTOK);
371:
372: if ((x->av_syntax = syntax) > AV_WRITE_FILE)
373: x->av_syntax = syntax - AV_WRITE_FILE;
374: x->av_struct = NULL;
375:
376: if (syntax_table[syntax].s_parse != NULLIFP) {
377: if ((x->av_struct = (caddr_t)(*syntax_table[syntax].s_parse) (str)) == NULL)
378: return (NOTOK);
379: if (t61_flag) {
380: parse_error ("invalid use of {T.61}",NULLCP);
381: return (NOTOK);
382: }
383: if (crypt_flag) {
384: parse_error ("invalid use of {CRYPT}",NULLCP);
385: return (NOTOK);
386: }
387: } else if ((x->av_struct = (caddr_t) asn2pe (str)) == NULL) {
388: parse_error ("invalid ASN attribute",NULLCP);
389: return NOTOK;
390: }
391: return (OK);
392: }
393:
394: AttributeValue AttrV_cpy (x)
395: register AttributeValue x;
396: {
397: register AttributeValue y = NULLAttrV;
398:
399: y = AttrV_alloc();
400: AttrV_cpy_aux (x,y);
401: return (y);
402: }
403:
404: AttrV_cpy_aux (x,y)
405: register AttributeValue x;
406: register AttributeValue y;
407: {
408: struct file_syntax * fileattr_cpy();
409:
410: y->av_syntax = x->av_syntax;
411:
412: if (x->av_struct == NULL) {
413: y->av_struct = NULL;
414: return;
415: }
416:
417: if (x->av_syntax == AV_FILE)
418: y->av_struct = (caddr_t) fileattr_cpy ((struct file_syntax *)x->av_struct);
419: else if (syntax_table[x->av_syntax].s_copy != NULLIFP)
420: y->av_struct = (caddr_t)(*syntax_table[x->av_syntax].s_copy) (x->av_struct);
421: else
422: y->av_struct = NULL;
423: }
424:
425:
426: rdn_cmp (a,b)
427: register RDN a,b;
428: {
429: register int i;
430:
431: for (; (a != NULLRDN) && (b != NULLRDN) ; a = a->rdn_next, b = b->rdn_next) {
432: if (a->rdn_at != b->rdn_at)
433: return ((a->rdn_at > b->rdn_at) ? 1 : -1);
434:
435: if (syntax_table[a->rdn_av.av_syntax].s_compare == NULLIFP)
436: return (2); /* can't compare */
437: else
438: if (( i = (*syntax_table[a->rdn_av.av_syntax].s_compare) (a->rdn_av.av_struct,b->rdn_av.av_struct)) != 0)
439: return i;
440: }
441:
442: if ( (a == NULLRDN) && (b == NULLRDN) ) {
443: return 0;
444: } else {
445: return ( a ? 1 : -1);
446: }
447:
448: }
449:
450: AttrV_cmp (x,y)
451: register AttributeValue x,y;
452: {
453: if (x->av_syntax != y->av_syntax)
454: return (-2);
455:
456: if (x->av_syntax == AV_FILE)
457: return (file_cmp ((struct file_syntax *)x->av_struct,(struct file_syntax *)y->av_struct));
458:
459: if (syntax_table[x->av_syntax].s_compare != NULLIFP)
460: return ((*syntax_table[x->av_syntax].s_compare) (x->av_struct,y->av_struct));
461: else
462: return (2); /* can't compare */
463: }
464:
465: IFP av_cmp_fn (syntax)
466: int syntax;
467: {
468: if ( syntax >= AV_WRITE_FILE )
469: return NULLIFP;
470:
471: if (syntax == AV_FILE)
472: return (file_cmp);
473:
474: if (syntax_table[syntax].s_compare != NULLIFP)
475: return (syntax_table[syntax].s_compare);
476: else
477: return NULLIFP;
478: }
479:
480: AttrV_print (ps,x,format)
481: register PS ps;
482: register AttributeValue x;
483: register int format;
484: {
485: extern int ps_printf ();
486:
487: if (format == RDNOUT)
488: format = READOUT;
489:
490: if (x->av_syntax == AV_FILE)
491: fileattr_print (ps,x,format);
492: else if ((format == READOUT) && (syntax_table[x->av_syntax].s_pe_print != NULLCP))
493: exec_print (ps,x,syntax_table[x->av_syntax].s_pe_print);
494: else if (syntax_table[x->av_syntax].s_print != NULLIFP) {
495: if (x->av_struct != NULL)
496: (*syntax_table[x->av_syntax].s_print) (ps,x->av_struct,format);
497: } else if (format == READOUT) {
498: vpushquipu (ps);
499: vunknown ((PE)x->av_struct);
500: vpopquipu ();
501: } else
502: pe_print (ps,(PE)x->av_struct,format);
503:
504: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.