![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dec.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 / rosap / test|
Return to dec.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / rosap / test |
1.1 root 1: /* dec.c */
2:
3: #ifndef lint
4: static char *rcsid = "$Header$";
5: #endif
6:
7: /*
8: * $Header$
9: *
10: *
11: * $Log$
12: */
13:
14: /*
15: * NOTICE
16: *
17: * Acquisition, use, and distribution of this module and related
18: * materials are subject to the restrictions of a license agreement.
19: * Consult the Preface in the User's Manual for the full terms of
20: * this agreement.
21: *
22: */
23:
24:
25: /*
26: * These routines are the driving routines for parsing encoding and printing
27: * data
28: */
29: #include <stdio.h>
30: #include "../h/psap.h"
31: #include "pep.h"
32: #include "pepdefs.h"
33:
34: #define PEPYPARM char **
35: #ifndef PEPYPARM
36: #define PEPYPARM char **
37: #endif
38: extern PEPYPARM NullParm;
39:
40:
41:
42: extern PE pr_seq(), pr_seqof(), pr_set(), pr_setof(), pr_type();
43: extern PE en_seq(), en_seqof(), en_set(), en_setof(), en_type();
44: extern PE pr_choice(), en_choice(), en_etype(), pr_etype(), pr_obj();
45: extern PE setpresent();
46:
47: extern tpe *next_tpe();
48: extern int _pverbose;
49:
50: #define NEXT_TPE(p) p = next_tpe(p)
51: #define CHKTAG(mod, p, pe) ismatch(p, mod, pe->pe_class, pe->pe_id)
52:
53: /* Have we got an optional object which we have allocated sapce for */
54: #define ALLOC_MEM(p, parm) (p->pe_type == SOBJECT \
55: && p[-1].pe_type == MALLOC)
56:
57: /*SUPPRESS 36*/ /* for Saber C */
58:
59: /*
60: * decode the specified type of the specified module into the given pe
61: */
62: dec_f(typ, mod, pe, explicit, len, buf, parm)
63: /*ARGSUSED*/
64: int typ; /* which type it is */
65: modtyp *mod; /* Module it is from */
66: PE pe;
67: int explicit;
68: int *len;
69: char **buf;
70: PEPYPARM parm;
71: {
72: tpe *p;
73:
74: if (typ < 0 || typ >= mod->md_nentries)
75: ferrd(1, "dec_f:Illegal typ %d\n", typ);
76:
77: p = mod->md_dtab[typ];
78: if (p->pe_type != PE_START)
79: ferr(1, "dec_f: missing PE_START\n");
80: p++;
81: if ((pe = pr_obj(explicit, pe, parm, p, mod)) == NULLPE)
82: return (NOTOK);
83:
84: return (OK);
85: }
86:
87: /*
88: * Parse an object. The top level of an object does not have any offset field
89: * which makes it different to pr_type routine which must assume that it
90: * has an offset.
91: */
92: PE
93: pr_obj(expl, pe, parm, p, mod)
94: int expl; /* do we look at the tag */
95: PE pe;
96: PEPYPARM parm;
97: tpe *p;
98: modtyp *mod; /* Module it is from */
99: {
100: int cnt = 0;
101:
102:
103: if (_pverbose > 6) {
104: printf(dfp, "1st Decoding the type %d \n",p->pe_type);
105: }
106: while (p->pe_type != PE_END) {
107:
108: if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
109: if (DEFAULT(p))
110: ferr(1, "pr_obj:Default not implemented\n");
111: else if (OPTIONAL(p)) {
112: if (ALLOC_MEM(p, parm))
113: fix_mem(parm, p);
114: goto next;
115: } else {
116: dmp_tpe("pr_obj:missing mandatory parameter", p, mod);
117: return (NULLPE);
118: }
119: }
120:
121: if (_pverbose > 6) {
122: printf("2nd Decoding the type %d \n",p->pe_type);
123: }
124:
125: switch (p->pe_type) {
126: case PE_END:
127: case PE_START:
128: return (NULLPE);
129:
130: case UCODE:
131: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
132: return (NULLPE);
133: break;
134:
135: case ETAG:
136: switch (p->pe_ucode) {
137: default:
138: p++;
139: if (pr_obj(1, pe->pe_cons, parm, p, mod) == NULLPE)
140: return (NULLPE);
141: }
142: break;
143:
144: case MALLOC:
145: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL)
146: return NULLPE;
147: break;
148:
149: case SEQ_START:
150: if ((pe = pr_seq(pe, parm, p, mod)) == NULLPE)
151: return (NULLPE);
152: break;
153:
154: case SEQOF_START:
155: if ((pe = pr_seqof(pe, parm, p, mod)) == NULLPE)
156: return (NULLPE);
157: break;
158:
159: case SET_START:
160: if ((pe = pr_set(pe, parm, p, mod)) == NULLPE)
161: return (NULLPE);
162: break;
163:
164: case SETOF_START:
165: if ((pe = pr_setof(pe, parm, p, mod)) == NULLPE)
166: return (NULLPE);
167: break;
168:
169: case IMP_OBJ:
170: p++;
171: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
172: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
173: (char **) 0, parm);
174: } else {
175: if (p->pe_type == SOBJECT) {
176: if ((pe = pr_obj(0, pe, parm,
177: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
178: return (NULLPE);
179: } else
180: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode,
181: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
182: return (NULLPE);
183: }
184: break;
185:
186: case SOBJECT:
187: case OBJECT:
188: if ((pe = pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
189: return (NULLPE);
190: break;
191:
192: case CHOICE_START:
193: if ((pe = pr_choice(pe, parm, p, mod)) == NULLPE)
194: return (NULLPE);
195: break;
196:
197: case SEXTOBJ:
198: case EXTOBJ:
199: if (p[1].pe_type != EXTMOD) {
200: dmp_tpe("pr_type: missing EXTMOD", p, mod);
201: ferr(1, "pr_type:internal error\n");
202: }
203: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
204: (char **) 0, parm);
205: break;
206:
207: default:
208: if ((pe = pr_type(expl, pe, parm, p, mod)) == NULLPE)
209: return (NULLPE);
210: break;
211: }
212: if (ISDTYPE(p) && cnt > 0)
213: ferr(1, "pr_obj:compound type found\n");
214: if (ISDTYPE(p) && pe != NULLPE)
215: return (pe);
216: next:
217: NEXT_TPE(p);
218: }
219:
220: return (pe);
221: }
222: /*
223: * Parse a single type.
224: * If a basic type parse it, if a compound type call the appropriate
225: * parsing routine
226: */
227: PE
228: pr_type(expl, pe, parm, p, mod)
229: int expl; /* do we look at the tag */
230: PE pe;
231: PEPYPARM parm;
232: tpe *p;
233: modtyp *mod; /* Module it is from */
234: {
235: int cnt = 0;
236: OID oid;
237:
238:
239: if (_pverbose > 6) {
240: printf("pr_type:type %d \n",p->pe_type);
241: }
242: while (p->pe_type != PE_END) {
243: /*
244: print_pe (pe, 1);
245: */
246:
247: if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
248: if (DEFAULT(p)) {
249: setdval(p, p + 1, parm, mod);
250: goto next;
251: } else if (OPTIONAL(p)) {
252: if (ALLOC_MEM(p, parm))
253: fix_mem(parm, p);
254: goto next;
255: } else {
256: dmp_tpe("pr_type:missing mandatory parameter", p, mod);
257: return (NULLPE);
258: }
259: }
260:
261: if (_pverbose > 6) {
262: printf("2nd prtype: type %d \n",p->pe_type);
263: }
264:
265: switch (p->pe_type) {
266: case PE_END:
267: case PE_START:
268: return (NULLPE);
269:
270: case UCODE:
271: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
272: return (NULLPE);
273: break;
274:
275: case ETAG:
276: switch (p->pe_ucode) {
277: default:
278: p++;
279: if (pr_etype(pe->pe_cons, parm, p, mod) == NULLPE)
280: return (NULLPE);
281: }
282: break;
283:
284: case MALLOC:
285: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL)
286: return NULLPE;
287: break;
288:
289: case SEQ_START:
290: if ((pe = pr_seq(pe, parm, p, mod)) == NULLPE)
291: return (NULLPE);
292: break;
293:
294: case SEQOF_START:
295: if ((pe = pr_seqof(pe, parm, p, mod)) == NULLPE)
296: return (NULLPE);
297: break;
298:
299: case SET_START:
300: if ((pe = pr_set(pe, parm, p, mod)) == NULLPE)
301: return (NULLPE);
302: break;
303:
304: case SETOF_START:
305: if ((pe = pr_setof(pe, parm, p, mod)) == NULLPE)
306: return (NULLPE);
307: break;
308:
309: case IMP_OBJ:
310: p++;
311: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
312: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
313: (char **) 0, parm);
314: } else {
315: if (p->pe_type == SOBJECT) {
316: if ((pe = pr_obj(0, pe, parm,
317: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
318: return (NULLPE);
319: } else
320: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode,
321: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
322: return (NULLPE);
323: }
324: break;
325:
326: case SOBJECT:
327: case OBJECT:
328: if ((pe = pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
329: return (NULLPE);
330: break;
331:
332: case CHOICE_START:
333: if ((pe = pr_choice(pe, parm, p, mod)) == NULLPE)
334: return (NULLPE);
335: break;
336:
337: case SEXTOBJ:
338: case EXTOBJ:
339: if (p[1].pe_type != EXTMOD) {
340: dmp_tpe("pr_type: missing EXTMOD", p, mod);
341: ferr(1, "pr_type:internal error\n");
342: }
343: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
344: (char **) 0, parm);
345: break;
346:
347: case INTEGER:
348: if (pe != NULLPE) {
349: if (_pverbose > 6) {
350: printf("integer value is %d\n",prim2num(pe));
351: }
352: if (((*(int *)(*parm + p->pe_ucode)) = prim2num(pe))
353: == NOTOK && pe->pe_errno != PE_ERR_NONE) {
354: printf("pr_type:bad integer %s",
355: pe_error(pe->pe_errno));
356: return (NULLPE);
357: }
358: }
359: break;
360:
361: case BOOLEAN:
362: if (pe != NULLPE) {
363: if (_pverbose > 6) {
364: printf("boolean value is %d\n",prim2flag(pe));
365: }
366: if (((* (char *)(*parm + p->pe_ucode)) = prim2flag(pe))==NOTOK && pe->pe_errno != PE_ERR_NONE) {
367: printf("pr_type:bad integer %s",
368: pe_error(pe->pe_errno));
369: return (NULLPE);
370: }
371: }
372: break;
373:
374: case T_NULL:
375: break;
376:
377: case SCONS_ANY:
378: case SANY:
379: if (pe != NULLPE) {
380: ((* (PE *) parm) = pe)->pe_refcnt++;
381: if (pe->pe_errno != PE_ERR_NONE) {
382: printf("pr_type:bad integer %s",
383: pe_error(pe->pe_errno));
384: return (NULLPE);
385: }
386: }
387: break;
388:
389:
390: case CONS_ANY:
391: case ANY:
392: if (pe != NULLPE) {
393: (* (PE *) (*parm + p->pe_ucode) = pe) ->pe_refcnt++;
394: if (pe->pe_errno != PE_ERR_NONE) {
395: printf("pr_type:bad integer %s",
396: pe_error(pe->pe_errno));
397: return (NULLPE);
398: }
399: }
400: break;
401:
402: case SOCTETSTRING:
403: if (pe != NULLPE) {
404: if ((*((struct qbuf **) parm) = prim2qb(pe)) ==
405: (struct qbuf *) NULL && pe->pe_errno != PE_ERR_NONE) {
406: printf("pr_type:bad octet string %s",
407: pe_error(pe->pe_errno));
408: return (NULLPE);
409: }
410: }
411: break;
412:
413: case OCTETSTRING:
414: if (pe != NULLPE) {
415: if ((*((struct qbuf **) (*parm + p->pe_ucode))
416: = prim2qb(pe)) == (struct qbuf *) NULL
417: && pe->pe_errno != PE_ERR_NONE) {
418: printf("pr_type:bad octet string %s",
419: pe_error(pe->pe_errno));
420: return (NULLPE);
421: }
422: }
423: break;
424:
425: case SBITSTRING:
426: if (pe != NULLPE) {
427: /*
428: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe))== NULLPE)
429: I think this is a bug in ISODE's routines prim2bit
430: does the wrong thing
431: */
432: if ((*((PE *)parm)=prim2bit(pe_cpy(pe))) == NULLPE) {
433: printf("pr_type:out of memory");
434: return (NULLPE);
435: }
436: }
437: break;
438:
439: case BITSTRING:
440: if (pe != NULLPE) {
441: /*
442: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe))== NULLPE)
443: I think this is a bug in ISODE's routines prim2bit
444: does the wrong thing
445: */
446: if ((*((PE *)(*parm + p->pe_ucode))=prim2bit(pe_cpy(pe))) == NULLPE) {
447: printf("pr_type:out of memory");
448: return (NULLPE);
449: }
450: }
451: break;
452:
453: case SOBJID:
454: /* This is messy because ISODE's library routine uses a static. Don't
455: * know why they do
456: */
457: if ((oid = prim2oid(pe)) == NULLOID
458: || (*(OID *)parm = oid_cpy(oid)) == NULLOID) {
459: printf("pr_type:Object Identifier: out of memory");
460: if (oid && oid->oid_elements) {
461: free(oid->oid_elements);
462: oid->oid_elements = NULL;
463: }
464: return (NULLPE);
465: }
466: if (oid && oid->oid_elements) {
467: free(oid->oid_elements);
468: oid->oid_elements = NULL;
469: }
470: break;
471:
472: case OBJID:
473: if ((oid = prim2oid(pe)) == NULLOID
474: || (*(OID *)(*parm + p->pe_ucode) = oid_cpy(oid)) == NULLOID) {
475: printf("pr_type:Object Identifier: out of memory");
476: if (oid && oid->oid_elements) {
477: free(oid->oid_elements);
478: oid->oid_elements = NULL;
479: }
480: return (NULLPE);
481: }
482: if (oid && oid->oid_elements) {
483: free(oid->oid_elements);
484: oid->oid_elements = NULL;
485: }
486: break;
487:
488: default:
489: dmp_tpe("pr_type: type not implemented", p, mod);
490: ferrd(1, "pr_type: %d not implemented\n", p->pe_type);
491: break;
492: }
493: if (ISDTYPE(p) && cnt > 0)
494: ferr(1, "pr_type:compound type found\n");
495: if (ISDTYPE(p) && pe != NULLPE)
496: return (pe);
497: next:
498: NEXT_TPE(p);
499: }
500:
501: return (pe);
502: }
503:
504: /*
505: * Parse a sequence, calling appropriate routines to parse each sub type
506: */
507: PE
508: pr_seq(head, parm, p, mod)
509: PE head;
510: PEPYPARM parm;
511: tpe *p;
512: modtyp *mod; /* Module it is from */
513: {
514: PE pe;
515: int *popt = NULL; /* Pointer to optional field */
516: int optcnt = 0; /* Number of optionals bits so far */
517:
518: if (p->pe_type != SEQ_START)
519: ferr(1, "pr_seq: missing SEQ_START\n");
520: p++;
521:
522: if (p->pe_type == DFLT_B)
523: p++;
524:
525: pe = first_member(head);
526: while (p->pe_type != PE_END) {
527: if (_pverbose > 6) {
528: printf("pr_seq:type %d\n",p->pe_type);
529: }
530:
531:
532: if (ISDTYPE(p) && OPTIONAL(p)) {
533: switch (p->pe_type) {
534: case INTEGER:
535: case BOOLEAN:
536: case T_NULL:
537: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
538: optcnt++;
539: goto next;
540: }
541: SETBIT(*popt, optcnt++);
542: break;
543:
544: #if 0
545: case ANY:
546: case CONS_ANY:
547: case SANY:
548: case SCONS_ANY:
549: dmp_tpe("pr_seq:optional/default ANY", p, mod);
550: ferr(1, "unable to distinguish tags");
551: #endif
552:
553: default:
554: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
555: if (ALLOC_MEM(p, parm))
556: fix_mem(parm, p);
557: goto next;
558: }
559: break;
560: }
561: } else if (ISDTYPE(p) && (pe == NULLPE || CHKTAG(mod, p, pe) == 0)) {
562: if (DEFAULT(p)) {
563: setdval(p, p + 1, parm, mod);
564: goto next;
565: } else {
566: dmp_tpe("pr_seq:missing mandatory parameter", p, mod);
567: return (NULLPE);
568: }
569: }
570:
571: switch (p->pe_type) {
572: case OPTL:
573: popt = (int *) (*parm + p->pe_ucode);
574: break;
575:
576: case UCODE:
577: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
578: return (NULLPE);
579: break;
580:
581: case ETAG:
582: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
583: return NULLPE;
584: break;
585:
586: case MALLOC:
587: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL)
588: return NULLPE;
589: break;
590:
591: case SEQ_START:
592: if ((pe = pr_seq(pe, (char **)(*parm + p->pe_ucode), p, mod))
593: == NULLPE)
594: return (NULLPE);
595: break;
596:
597: case SEQOF_START:
598: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
599: return (NULLPE);
600: break;
601:
602: case SET_START:
603: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
604: return (NULLPE);
605: break;
606:
607: case SETOF_START:
608: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
609: return (NULLPE);
610: break;
611:
612: case IMP_OBJ:
613: p++;
614: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
615: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
616: (char **) 0, *parm + p->pe_ucode);
617: } else {
618: if (p->pe_type == SOBJECT) {
619: if ((pe = pr_obj(0, pe, parm,
620: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
621: return (NULLPE);
622: } else
623: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode,
624: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
625: return (NULLPE);
626: }
627: break;
628:
629: case SOBJECT:
630: if ((pe = pr_obj(1, pe, parm,
631: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
632: return (NULLPE);
633: break;
634:
635: case OBJECT:
636: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode,
637: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
638: return (NULLPE);
639: break;
640:
641: case CHOICE_START:
642: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
643: return (NULLPE);
644: break;
645:
646: case SEXTOBJ:
647: if (p[1].pe_type != EXTMOD) {
648: dmp_tpe("pr_seq: missing EXTMOD", p, mod);
649: ferr(1, "pr_seq:internal error\n");
650: }
651: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
652: (char **) 0, parm);
653: break;
654:
655: case EXTOBJ:
656: if (p[1].pe_type != EXTMOD) {
657: dmp_tpe("pr_seq: missing EXTMOD", p, mod);
658: ferr(1, "pr_seq:internal error\n");
659: }
660: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
661: (char **) 0, *parm + p->pe_ucode);
662: break;
663:
664: default:
665: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
666: return (NULLPE);
667: break;
668: /*
669: ferrd(1, "pr_seq: unknown type %d\n", p->pe_type);
670: */
671: }
672:
673: if (ISDTYPE(p) && pe != NULLPE)
674: pe = next_member(head, pe);
675: next:
676: NEXT_TPE(p);
677: }
678:
679: return (head);
680:
681: }
682:
683:
684: /*
685: * Parse a set, calling appropriate routines to parse each sub type
686: */
687: PE
688: pr_set(head, parm, p, mod)
689: PE head;
690: PEPYPARM parm;
691: tpe *p;
692: modtyp *mod; /* Module it is from */
693: {
694: PE pe;
695: int *popt = NULL; /* Pointer to optional field */
696: int optcnt = 0; /* Number of optionals bits so far */
697:
698: if (p->pe_type != SET_START)
699: ferr(1, "pr_seq: missing SET_START\n");
700: p++;
701:
702: if (p->pe_type == DFLT_B)
703: p++;
704:
705: while (p->pe_type != PE_END) {
706:
707: if (_pverbose > 6) {
708: printf("dec_set with the type %d\n",p->pe_type);
709: }
710:
711: if (ISDTYPE(p) && OPTIONAL(p)) {
712: switch (p->pe_type) {
713: case INTEGER:
714: case BOOLEAN:
715: case T_NULL:
716: if ((pe = setpresent(head, p, mod)) == NULLPE) {
717: optcnt++;
718: goto next;
719: }
720: SETBIT(*popt, optcnt++);
721: break;
722:
723: #if 0
724: case ANY:
725: case CONS_ANY:
726: case SANY:
727: case SCONS_ANY:
728: dmp_tpe("pr_set:optional/default ANY\n", p, mod);
729: ferr(1, "unable to distinguish tags");
730: #endif
731:
732: default:
733: if ((pe = setpresent(head, p, mod)) == NULLPE) {
734: if (ALLOC_MEM(p, parm))
735: fix_mem(parm, p);
736: goto next;
737: }
738: break;
739: }
740: } else if (ISDTYPE(p) && (pe = setpresent(head, p, mod)) == NULLPE) {
741: if (DEFAULT(p)) {
742: setdval(p, p + 1, parm, mod);
743: goto next;
744: } else {
745: dmp_tpe("pr_set:missing mandatory parameter", p, mod);
746: return (NULLPE);
747: }
748: }
749:
750: switch (p->pe_type) {
751: case OPTL:
752: popt = (int *) (*parm + p->pe_ucode);
753: break;
754:
755: case UCODE:
756: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
757: return (NULLPE);
758: break;
759:
760: case ETAG:
761: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
762: return NULLPE;
763: break;
764:
765: case MALLOC:
766: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL)
767: return NULLPE;
768: break;
769:
770: case SEQ_START:
771: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
772: return (NULLPE);
773: break;
774:
775: case SEQOF_START:
776: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
777: return (NULLPE);
778: break;
779:
780: case SET_START:
781: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
782: return (NULLPE);
783: break;
784:
785: case SETOF_START:
786: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
787: return (NULLPE);
788: break;
789:
790: case IMP_OBJ:
791: p++;
792: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
793: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
794: (char **) 0, *parm + p->pe_ucode);
795: } else {
796: if (p->pe_type == SOBJECT) {
797: if ((pe = pr_obj(0, pe, parm,
798: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
799: return (NULLPE);
800: } else
801: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode,
802: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
803: return (NULLPE);
804: }
805: break;
806:
807: case SOBJECT:
808: if ((pe = pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1,
809: mod)) == NULLPE)
810: return (NULLPE);
811: break;
812:
813: case OBJECT:
814: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode,
815: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
816: return (NULLPE);
817: break;
818:
819: case CHOICE_START:
820: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
821: return (NULLPE);
822: break;
823:
824: case SEXTOBJ:
825: if (p[1].pe_type != EXTMOD) {
826: dmp_tpe("pr_set: missing EXTMOD", p, mod);
827: ferr(1, "pr_set:internal error\n");
828: }
829: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
830: (char **) 0, parm);
831: break;
832:
833: case EXTOBJ:
834: if (p[1].pe_type != EXTMOD) {
835: dmp_tpe("pr_set: missing EXTMOD", p, mod);
836: ferr(1, "pr_set:internal error\n");
837: }
838: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
839: (char **) 0, *parm + p->pe_ucode);
840: break;
841:
842: default:
843: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
844: return (NULLPE);
845: break;
846: /*
847: ferrd(1, "pr_set: unknown type %d\n", p->pe_type);
848: */
849: }
850:
851: next:
852: NEXT_TPE(p);
853: }
854:
855: return (head);
856:
857: }
858:
859:
860: /*
861: * Parse a sequence of calling appropriate routines to parse each sub type
862: */
863: PE
864: pr_seqof(head, parm, p, mod)
865: PE head;
866: PEPYPARM parm;
867: tpe *p;
868: modtyp *mod; /* Module it is from */
869: {
870: PE pe;
871: tpe *start; /* first entry in list */
872: int dflt = 0;
873:
874: if (p->pe_type != SEQOF_START) {
875: dmp_tpe("pr_seqof:missing SEQOF_START", p, mod);
876: ferr(1, "pr_seqof: missing SEQOF_START\n");
877: }
878: p++;
879:
880: if (p->pe_type == DFLT_B)
881: p++;
882:
883: start = p;
884:
885: pe = first_member(head);
886: while (pe != NULLPE) {
887: while (p->pe_type != PE_END) {
888:
889: if (_pverbose > 6) {
890: printf("dec_seqof with the type %d\n",p->pe_type);
891: }
892:
893: if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) {
894: if (DEFAULT(p)) {
895: setdval(p, p + 1, parm, mod);
896: goto next;
897: } else if (OPTIONAL(p)) {
898: if (ALLOC_MEM(p, parm))
899: fix_mem(parm, p);
900: goto next;
901: } else {
902: dmp_tpe( "pr_seqof:missing mandatory parameter", p,
903: mod);
904: return (NULLPE);
905: }
906: }
907:
908: switch (p->pe_type) {
909: case UCODE:
910: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
911: return (NULLPE);
912: break;
913:
914: case ETAG:
915: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
916: return NULLPE;
917: break;
918:
919: case MALLOC:
920: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL)
921: return NULLPE;
922: break;
923:
924: case SCTRL:
925: parm = (char **) ((char *)*parm + p->pe_ucode);
926: break;
927:
928: case SEQ_START:
929: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
930: return (NULLPE);
931: break;
932:
933: case SEQOF_START:
934: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
935: return (NULLPE);
936: break;
937:
938: case SET_START:
939: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
940: return (NULLPE);
941: break;
942:
943: case SETOF_START:
944: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
945: return (NULLPE);
946: break;
947:
948: case SOBJECT:
949: if ((pe = pr_obj(1, pe, parm,
950: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
951: return (NULLPE);
952: break;
953:
954: case OBJECT:
955: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode,
956: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
957: return (NULLPE);
958: break;
959:
960: case CHOICE_START:
961: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
962: return (NULLPE);
963: break;
964:
965: case SEXTOBJ:
966: if (p[1].pe_type != EXTMOD) {
967: dmp_tpe("pr_seqof: missing EXTMOD", p, mod);
968: ferr(1, "pr_seqof:internal error\n");
969: }
970: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
971: (char **) 0, parm);
972: break;
973:
974: case EXTOBJ:
975: if (p[1].pe_type != EXTMOD) {
976: dmp_tpe("pr_seqof: missing EXTMOD", p, mod);
977: ferr(1, "pr_seqof:internal error\n");
978: }
979: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
980: (char **) 0, *parm + p->pe_ucode);
981: break;
982:
983: default:
984: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
985: return (NULLPE);
986: break;
987: }
988:
989: if (ISDTYPE(p) && dflt == 0)
990: pe = next_member(head, pe);
991: next:
992: NEXT_TPE(p);
993: }
994: parm = (char **)(*parm + p->pe_ucode);
995: p = start;
996: }
997:
998: return (head);
999:
1000: }
1001:
1002: /*
1003: * Parse a setof, calling appropriate routines to parse each sub type
1004: */
1005: PE
1006: pr_setof(head, parm, p, mod)
1007: PE head;
1008: PEPYPARM parm;
1009: tpe *p;
1010: modtyp *mod; /* Module it is from */
1011: {
1012: PE pe;
1013: int dflt;
1014: tpe *start;
1015:
1016: if (p->pe_type != SETOF_START)
1017: ferr(1, "pr_setof: missing SETOF_START\n");
1018: p++;
1019:
1020: if (p->pe_type == DFLT_B)
1021: p++;
1022:
1023: start = p;
1024: pe = first_member(head);
1025:
1026: for (pe = first_member(head); pe; pe = next_member(head, pe)) {
1027: while (p->pe_type != PE_END) {
1028: if (_pverbose > 6) {
1029: printf("dec_seqof with the type %d\n", p->pe_type);
1030: }
1031:
1032: if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
1033: if (DEFAULT(p)) {
1034: setdval(p, p + 1, parm, mod);
1035: goto next;
1036: } else {
1037: dmp_tpe( "pr_setof:missing mandatory parameter",
1038: p, mod);
1039: return (NULLPE);
1040: }
1041: }
1042: else
1043: dflt = 0;
1044:
1045: switch (p->pe_type) {
1046: case UCODE:
1047: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
1048: return (NULLPE);
1049: break;
1050:
1051: case ETAG:
1052: if ((pe = pr_type(1, pe->pe_cons, parm, p, mod)) == NULLPE)
1053: return NULLPE;
1054: break;
1055:
1056: case MALLOC:
1057: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL)
1058: return NULLPE;
1059: break;
1060:
1061: case SCTRL:
1062: parm = (char **) (*parm + p->pe_ucode);
1063: break;
1064:
1065: case SEQ_START:
1066: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1067: return (NULLPE);
1068: break;
1069:
1070: case SEQOF_START:
1071: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1072: return (NULLPE);
1073: break;
1074:
1075: case SET_START:
1076: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1077: return (NULLPE);
1078: break;
1079:
1080: case SETOF_START:
1081: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1082: return (NULLPE);
1083: break;
1084:
1085: case SOBJECT:
1086: if ((pe = pr_obj(1, pe, parm,
1087: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1088: return (NULLPE);
1089: break;
1090:
1091: case OBJECT:
1092: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode,
1093: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1094: return (NULLPE);
1095: break;
1096:
1097: case CHOICE_START:
1098: if ((pe = pr_choice(pe, *parm + p->pe_ucode,
1099: p, mod)) == NULLPE)
1100: return (NULLPE);
1101: break;
1102:
1103: case SEXTOBJ:
1104: if (p[1].pe_type != EXTMOD) {
1105: dmp_tpe("pr_setof: missing EXTMOD", p, mod);
1106: ferr(1, "pr_setof:internal error\n");
1107: }
1108: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1,
1109: NULL, (char **) 0, parm);
1110: break;
1111:
1112: case EXTOBJ:
1113: if (p[1].pe_type != EXTMOD) {
1114: dmp_tpe("pr_setof: missing EXTMOD", p, mod);
1115: ferr(1, "pr_setof:internal error\n");
1116: }
1117: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1,
1118: NULL, (char **) 0, *parm + p->pe_ucode);
1119: break;
1120:
1121: default:
1122: if ((pe = pr_type(1, pe, parm, p, mod)) == NULLPE)
1123: return (NULLPE);
1124: break;
1125: /*
1126: ferrd(1, "pr_setof: unknown type %d\n", p->pe_type);
1127: */
1128: }
1129:
1130: #if 0
1131: /* fixup - we only delete in this function */
1132: if (ISDTYPE(p) && dflt == 0)
1133: set_del(head, pe->pe_class, pe->pe_id);
1134: #endif
1135: next:
1136: NEXT_TPE(p);
1137: }
1138: parm = (char **)(*parm + p->pe_ucode);
1139: p = start;
1140: }
1141:
1142: return (head);
1143:
1144: }
1145:
1146: /*
1147: * parse a choice field. This means find which choice is taken
1148: */
1149: PE
1150: pr_choice(head, parm, p, mod)
1151: PE head;
1152: PEPYPARM parm;
1153: tpe *p;
1154: modtyp *mod; /* Module it is from */
1155: {
1156: int *poffset;
1157: int cnt;
1158: PE pe;
1159:
1160: if (p->pe_type != CHOICE_START) {
1161: dmp_tpe("pr_choice:missing CHOICE_START", p, mod);
1162: ferrd(1, "pr_choice:illegal table entry %d\n", p->pe_type);
1163: }
1164:
1165: p++;
1166:
1167: if (p->pe_type == DFLT_B)
1168: p++;
1169:
1170: if (p->pe_type == MALLOC) {
1171: if ((*parm = (char *) calloc(1, p->pe_tag)) == NULL)
1172: return NULLPE;
1173: p++;
1174: }
1175: if (p->pe_type == SCTRL) {
1176: if ((poffset = (int *) (*parm + p->pe_ucode)) == NULL)
1177: return NULLPE;
1178: p++;
1179: }
1180:
1181: for (cnt = 1; p->pe_type != PE_END; NEXT_TPE(p), cnt++) {
1182: if (ISDTYPE(p) && ismatch(p, mod, head->pe_class, head->pe_id)) {
1183: pe = pr_etype(head, parm, p, mod);
1184: *poffset = cnt;
1185: return (pe);
1186: }
1187: }
1188: dmp_tpe("pr_choice: no choice taken", p, mod);
1189: return (NULLPE);
1190: }
1191:
1192: /*
1193: * Calculate the next tpe entry in the sequence. Count a sequence as one element
1194: */
1195: tpe *
1196: next_tpe(p)
1197: tpe *p;
1198: {
1199: int level;
1200:
1201:
1202:
1203: level = 0;
1204: if (p->pe_type == PE_END)
1205: ferr(1, "next_tpe:PE_END");
1206: do {
1207: again:
1208: switch (p->pe_type) {
1209: case SEQ_START:
1210: case SEQOF_START:
1211: case SET_START:
1212: case SETOF_START:
1213: case CHOICE_START:
1214: level++;
1215: break;
1216:
1217: case UCODE:
1218: case MALLOC:
1219: case SCTRL:
1220: case CH_ACT:
1221: case INTEGER:
1222: case BOOLEAN:
1223: case SANY:
1224: case SCONS_ANY:
1225: case ANY:
1226: case CONS_ANY:
1227: case T_NULL:
1228: case OBJECT:
1229: case SOBJECT:
1230: case BITSTRING:
1231: case SBITSTRING:
1232: case OCTETSTRING:
1233: case SOCTETSTRING:
1234: case OBJID:
1235: case SOBJID:
1236: case OPTL:
1237: case EXTMOD:
1238: case DFLT_B:
1239: break;
1240:
1241: case IMP_OBJ:
1242: case ETAG:
1243: case EXTOBJ:
1244: case SEXTOBJ:
1245: case DFLT_F:
1246: p++;
1247: goto again;
1248:
1249: case PE_END:
1250: level--;
1251: break;
1252:
1253: default:
1254: ferrd(1, "next_tpe: unknown type %d\n", p->pe_type);
1255: }
1256: p++;
1257: } while (level > 0 || p->pe_type == DFLT_B);
1258:
1259: return (p);
1260: }
1261:
1262: /*
1263: * check that pe is non null and that the tag and class match and return
1264: * zero if the don't
1265: */
1266: chktag(mod, p, pe)
1267: modtyp *mod; /* Module it is from */
1268: tpe *p;
1269: PE pe;
1270: {
1271: int cl, tag;
1272:
1273: if (pe == NULLPE)
1274: return (0);
1275: #if 0
1276: if (p->pe_type == OBJECT && skip_next_tag) /* first time we find skip */
1277: return (1);
1278: if (skip_next_tag) { /* 2nd time reset skip */
1279: skip_next_tag = 0;
1280: return (1);
1281: }
1282: #endif
1283: if (!findcltag(p, mod, &cl, &tag))
1284: return (0);
1285: if (pe->pe_id != tag || pe->pe_class != cl)
1286: return (0);
1287:
1288: return (1);
1289: }
1290:
1291: #if 0
1292: /*
1293: test if we need to check the tag associated with the tpe entry p
1294: */
1295: legal_tag(p)
1296: tpe *p;
1297: {
1298: int ret;
1299:
1300: switch (p->pe_type) {
1301:
1302: case MALLOC:
1303: case SCTRL:
1304: case CH_ACT:
1305: case ANY:
1306: case OBJECT:
1307: case CHOICE_START:
1308: case CONS_ANY:
1309: /* case ETAG: don't think we should have this here */
1310: ret = 0;
1311: break;
1312:
1313: default:
1314: #if 0
1315: if (skip_next_tag) {
1316: skip_next_tag = 0;
1317: ret = 0;
1318: }
1319: else
1320: #endif
1321: ret = 1;
1322: break;
1323: }
1324: return ret;
1325: }
1326: #endif
1327:
1328: /*
1329: * Parse a single type for explicit tag
1330: * If a basic type parse it, if a compound type call the appropriate
1331: * parsing routine
1332: */
1333: PE
1334: pr_etype(pe, parm, p, mod)
1335: PE pe;
1336: PEPYPARM parm;
1337: tpe *p;
1338: modtyp *mod; /* Module it is from */
1339: {
1340: switch (p->pe_type) {
1341: case PE_END:
1342: case PE_START:
1343: return (NULLPE);
1344:
1345: case UCODE:
1346: if ((*mod->md_ducode)(pe, parm, p, mod) != OK)
1347: return (NULLPE);
1348: break;
1349:
1350: case ETAG:
1351: switch (p->pe_ucode) {
1352:
1353: default:
1354: p++;
1355: if (pr_etype(pe->pe_cons, parm, p, mod) == NULLPE)
1356: return (NULLPE);
1357: }
1358: break;
1359:
1360: case MALLOC:
1361: if ((*(parm) = (char *) calloc(1, p->pe_tag)) == NULL)
1362: return NULLPE;
1363: break;
1364:
1365: case SEQ_START:
1366: if ((pe = pr_seq(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1367: return (NULLPE);
1368: break;
1369:
1370: case SEQOF_START:
1371: if ((pe = pr_seqof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1372: return (NULLPE);
1373: break;
1374:
1375: case SET_START:
1376: if ((pe = pr_set(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1377: return (NULLPE);
1378: break;
1379:
1380: case SETOF_START:
1381: if ((pe = pr_setof(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1382: return (NULLPE);
1383: break;
1384:
1385: case IMP_OBJ:
1386: p++;
1387: if (p->pe_type == EXTOBJ || p->pe_type == SEXTOBJ) {
1388: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 0, NULL,
1389: (char **) 0, *parm + p->pe_ucode);
1390: } else {
1391: if (p->pe_type == SOBJECT) {
1392: if ((pe = pr_obj(0, pe, parm,
1393: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1394: return (NULLPE);
1395: } else
1396: if ((pe = pr_obj(0, pe, *parm + p->pe_ucode,
1397: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1398: return (NULLPE);
1399: }
1400: break;
1401:
1402: case SOBJECT:
1403: if ((pe = pr_obj(1, pe, parm,
1404: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1405: return (NULLPE);
1406: break;
1407:
1408: case OBJECT:
1409: if ((pe = pr_obj(1, pe, *parm + p->pe_ucode,
1410: mod->md_dtab[p->pe_tag] + 1, mod)) == NULLPE)
1411: return (NULLPE);
1412: break;
1413:
1414: case CHOICE_START:
1415: if ((pe = pr_choice(pe, *parm + p->pe_ucode, p, mod)) == NULLPE)
1416: return (NULLPE);
1417: break;
1418:
1419: case SEXTOBJ:
1420: if (p[1].pe_type != EXTMOD) {
1421: dmp_tpe("pr_etype: missing EXTMOD", p, mod);
1422: ferr(1, "pr_etype:internal error\n");
1423: }
1424: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
1425: (char **) 0, parm);
1426: break;
1427:
1428: case EXTOBJ:
1429: if (p[1].pe_type != EXTMOD) {
1430: dmp_tpe("pr_etype: missing EXTMOD", p, mod);
1431: ferr(1, "pr_etype:internal error\n");
1432: }
1433: dec_f(p->pe_tag, (modtyp *)p[1].pe_ucode, pe, 1, NULL,
1434: (char **) 0, *parm + p->pe_ucode);
1435: break;
1436:
1437: case INTEGER:
1438: if (pe != NULLPE) {
1439: if (_pverbose > 6) {
1440: printf("integer value is %d\n",prim2num(pe));
1441: }
1442: if (((*(int *)(*parm + p->pe_ucode)) = prim2num(pe))== NOTOK && pe->pe_errno != PE_ERR_NONE) {
1443: printf("pr_etype:bad integer %s",
1444: pe_error(pe->pe_errno));
1445: return (NULLPE);
1446: }
1447: }
1448: break;
1449:
1450: case BOOLEAN:
1451: if (pe != NULLPE) {
1452: if (_pverbose > 6) {
1453: printf("boolean value is %d\n",prim2flag(pe));
1454: }
1455: if (((* (char *)(*parm + p->pe_ucode)) = prim2flag(pe))==NOTOK && pe->pe_errno != PE_ERR_NONE) {
1456: printf("pr_etype:bad integer %s",
1457: pe_error(pe->pe_errno));
1458: return (NULLPE);
1459: }
1460: }
1461: break;
1462:
1463: case T_NULL:
1464: break;
1465:
1466: case ANY:
1467: case CONS_ANY:
1468: if (pe != NULLPE) {
1469: (* (PE *) (*parm + p->pe_ucode) = pe) ->pe_refcnt++;
1470: if (pe->pe_errno != PE_ERR_NONE) {
1471: printf("pr_etype:bad integer %s",
1472: pe_error(pe->pe_errno));
1473: return (NULLPE);
1474: }
1475: }
1476: break;
1477:
1478: case SANY:
1479: case SCONS_ANY:
1480: /* This could require changes when I find out what the CONS_ANY type
1481: * is really for
1482: */
1483: if (pe != NULLPE) {
1484: ((PE) (*parm ) = pe) ->pe_refcnt++;
1485: if (pe->pe_errno != PE_ERR_NONE) {
1486: printf("pr_etype:bad integer %s",
1487: pe_error(pe->pe_errno));
1488: return (NULLPE);
1489: }
1490: }
1491: break;
1492:
1493: case SOCTETSTRING:
1494: if (pe != NULLPE) {
1495: if ((*((struct qbuf **) parm)
1496: = prim2qb(pe)) == (struct qbuf *) NULL
1497: && pe->pe_errno != PE_ERR_NONE) {
1498: printf("pr_etype:bad octet string %s",
1499: pe_error(pe->pe_errno));
1500: return (NULLPE);
1501: }
1502: }
1503: break;
1504:
1505: case OCTETSTRING:
1506: if (pe != NULLPE) {
1507: if ((*((struct qbuf **) (*parm + p->pe_ucode))
1508: = prim2qb(pe)) == (struct qbuf *) NULL
1509: && pe->pe_errno != PE_ERR_NONE) {
1510: printf("pr_etype:bad octet string %s",
1511: pe_error(pe->pe_errno));
1512: return (NULLPE);
1513: }
1514: }
1515: break;
1516:
1517: case SBITSTRING:
1518: if (pe != NULLPE) {
1519: if (((*(PE *) parm) = pe_cpy(pe)) == NULLPE) {
1520: printf("pr_etype:out of memory");
1521: return (NULLPE);
1522: }
1523: }
1524: break;
1525:
1526: case BITSTRING:
1527: if (pe != NULLPE) {
1528: if ((*((PE *) (*parm + p->pe_ucode))= pe_cpy(pe)) == NULLPE) {
1529: printf("pr_etype:out of memory");
1530: return (NULLPE);
1531: }
1532: }
1533: break;
1534:
1535: case SOBJID:
1536: if ((*(OID *)parm = oid_cpy(prim2oid(pe))) == NULLOID) {
1537: printf("pr_etype:Object Identifier: out of memory");
1538: return (NULLPE);
1539: }
1540: break;
1541:
1542: case OBJID:
1543: if ((*(OID *)(*parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID) {
1544: printf("en_etype:Object Identifier: out of memory");
1545: return (NULLPE);
1546: }
1547: break;
1548:
1549: default:
1550: ferrd(1, "pr_etype: %d not implemented\n", p->pe_type);
1551: break;
1552: }
1553:
1554: return (pe);
1555: }
1556:
1557: /*
1558: * determine what the class and tag must be of the given object
1559: */
1560: findcltag(p, mod, pcl, ptag)
1561: tpe *p;
1562: modtyp *mod; /* Module it is from */
1563: int *pcl, *ptag;
1564: {
1565: if (!ISDTYPE(p))
1566: return (0);
1567: if (p->pe_type != OBJECT) {
1568: *pcl = CLASS(p);
1569: *ptag = TAG(p);
1570: return (1);
1571: }
1572: p = mod->md_dtab[p->pe_tag] + 1;
1573: while (p->pe_type != PE_END) {
1574: if (ISDTYPE(p))
1575: return (findcltag(p, mod, pcl, ptag));
1576: }
1577: dmp_tpe("findcltag:warning:object with no data in it", p, mod);
1578: return (0);
1579: }
1580:
1581: /*
1582: * Is there a match at for this tag and class pair. Return 1 if yes 0 if no
1583: * We will search through contained objects and through choices
1584: */
1585: ismatch(p, mod, cl, tag)
1586: tpe *p;
1587: modtyp *mod; /* Module it is from */
1588: unsigned int cl, tag;
1589: {
1590: while (!ISDTYPE(p))
1591: p++;
1592:
1593: switch (p->pe_type) {
1594: case SOBJECT:
1595: case OBJECT:
1596: /* Needs to be changed for optional and default */
1597: return (ismatch(p = mod->md_dtab[p->pe_tag] + 1, mod, cl, tag));
1598:
1599: case SEXTOBJ:
1600: case EXTOBJ:
1601: if (p[1].pe_type != EXTMOD) {
1602: dmp_tpe("ismatch: missing EXTMOD", p, mod);
1603: ferr(1, "ismatch:internal error\n");
1604: }
1605: return(ismatch(((modtyp *)p[1].pe_ucode)->md_dtab[p->pe_tag] + 1,
1606: (modtyp *)p[1].pe_ucode, cl, tag));
1607:
1608: case CHOICE_START:
1609: for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) {
1610: if (!ISDTYPE(p))
1611: continue;
1612: if (ismatch(p, mod, cl, tag))
1613: return (1);
1614: }
1615: return (0);
1616:
1617: case SANY:
1618: case SCONS_ANY:
1619: return (1);
1620:
1621: case ANY:
1622: case CONS_ANY:
1623: if (TAG(p) == -1)
1624: return (1);
1625: /* else fall through - not sure if this is needed */
1626:
1627: default:
1628: return (tag == TAG(p) && cl == CLASS(p));
1629: }
1630: }
1631:
1632: /*
1633: * determine if the given field is present in the data
1634: * This is simple if the field is a simple type with an obvious tag but
1635: * in the case of an object or a CHOICE type the tag is not obvious. If the
1636: * object is a CHOICE there are more than one possible tag that could match
1637: * and in this case we must try to match each one of them.
1638: */
1639: PE
1640: setpresent(head, p, mod)
1641: PE head;
1642: tpe *p;
1643: modtyp *mod;
1644: {
1645: PE pe;
1646:
1647: if (!ISDTYPE(p))
1648: return (NULLPE);
1649: switch (p->pe_type) {
1650: case OBJECT:
1651: case SOBJECT:
1652: /* Needs to be changed for optional and default */
1653: return (setpresent(head, p = mod->md_dtab[p->pe_tag] + 1, mod));
1654:
1655: case CHOICE_START:
1656: for (p++; p->pe_type != PE_END; p = NEXT_TPE(p)) {
1657: if (!ISDTYPE(p))
1658: continue;
1659: if ((pe = setpresent(head, p, mod)))
1660: return (pe);
1661: }
1662: return (NULLPE);
1663:
1664: default:
1665: return (set_find(head, CLASS(p), TAG(p)));
1666: }
1667: }
1668:
1669: /*
1670: * set the default value to that value in the structure
1671: */
1672: setdval(typ, dflt, parm, mod)
1673: tpe *typ, *dflt;
1674: char **parm;
1675: modtyp *mod;
1676: {
1677:
1678: again:
1679: switch (typ->pe_type) {
1680: case MALLOC:
1681: if ((*(parm) = (char *) calloc(1, typ->pe_tag)) == NULL)
1682: ferrd(1, "setdval:calloc failed on %d\n", typ->pe_tag);
1683: typ++;
1684: goto again;
1685:
1686: case INTEGER:
1687: *(int *)(*parm + typ->pe_ucode) = IVAL(dflt);
1688: break;
1689:
1690: case BOOLEAN:
1691: *(char *)(*parm + typ->pe_ucode) = IVAL(dflt);
1692: break;
1693:
1694: case T_NULL:
1695: /* Only one value */
1696: break;
1697:
1698: case SBITSTRING:
1699: *(PE *)parm = strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0);
1700: break;
1701:
1702: case BITSTRING:
1703: *(PE *)(*parm + typ->pe_ucode) =
1704: strb2bitstr(PVAL(dflt), IVAL(dflt), 0, 0);
1705: break;
1706:
1707: case SOCTETSTRING:
1708: *(struct qbuf **)parm = str2qb(PVAL(dflt), IVAL(dflt), 1);
1709: break;
1710:
1711: case OCTETSTRING:
1712: *(struct qbuf **)(*parm + typ->pe_ucode) =
1713: str2qb(PVAL(dflt), IVAL(dflt), 1);
1714: break;
1715:
1716: case OBJECT:
1717: setdval(mod->md_dtab[typ->pe_tag] + 1, dflt,
1718: (char **) (*parm + typ->pe_ucode), mod);
1719: break;
1720:
1721: case SOBJECT:
1722: setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, parm, mod);
1723: break;
1724:
1725: case IMP_OBJ:
1726: typ++;
1727:
1728: case SCONS_ANY:
1729: case ANY:
1730: case CONS_ANY:
1731: case SANY:
1732: case SEXTOBJ:
1733: case EXTOBJ:
1734: case OBJID:
1735: case SOBJID:
1736: case SEQ_START:
1737: case SET_START:
1738: case -1: /* Just use the pepy method of null pointers */
1739: /* This is the posy/pepy hack way of doing things at the moment */
1740: *(char **)(*parm + typ->pe_ucode) = NULL;
1741: break;
1742:
1743: default:
1744: /* dmp_tpe("setdval: type not implemented", typ, mod); - need mod*/
1745: ferrd(1, "setdval: %d not implemented\n", typ->pe_type);
1746: break;
1747: }
1748:
1749: }
1750: /*
1751: * fix up the allocation of memory. We have allocated memory for an optional
1752: * object that is not present. ISODE routines get upset if this is present
1753: * because it then believes the object is present and tries to process it ...
1754: */
1755: fix_mem(parm, p)
1756: char **parm;
1757: tpe *p;
1758: {
1759: if (p->pe_type != SOBJECT || p[-1].pe_type != MALLOC
1760: || p[1].pe_type != PE_END)
1761: ferr(1, "fix_mem:inconsistency\n");
1762: if (*parm)
1763: free(*parm);
1764: *parm = NULL;
1765: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.