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