projects / unix-history / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Start development on 386BSD 0.0
[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / contrib / isode / pepsy / dec.c
CommitLineData
459ebbd7
C		 1/* dec.c */
2
3#ifndef lint
4static char *rcsid = "$Header: /f/osi/pepsy/RCS/dec.c,v 7.12 91/02/22 09:48:41 mrose Interim $";
5#endif
6
7/*
8 * $Header: /f/osi/pepsy/RCS/dec.c,v 7.12 91/02/22 09:48:41 mrose Interim $
9 *
10 *
11 * $Log: dec.c,v $
12 * Revision 7.12 91/02/22 09:48:41 mrose
13 * Interim 6.8
14 *
15 * Revision 7.11 90/12/23 17:24:17 mrose
16 * patches
17 *
18 * Revision 7.10 90/12/11 10:33:08 mrose
19 * sync
20 *
21 * Revision 7.9 90/11/20 15:27:05 mrose
22 * update
23 *
24 * Revision 7.8 90/11/11 10:53:33 mrose
25 * update
26 *
27 * Revision 7.7 90/11/04 19:18:12 mrose
28 * update
29 *
30 * Revision 7.6 90/10/23 20:42:52 mrose
31 * update
32 *
33 * Revision 7.5 90/10/17 14:39:26 mrose
34 * update
35 *
36 * Revision 7.4 90/08/18 00:44:05 mrose
37 * touch-up
38 *
39 * Revision 7.3 90/08/08 14:14:13 mrose
40 * update
41 *
42 * Revision 7.2 90/07/27 08:48:54 mrose
43 * update
44 *
45 * Revision 7.1 90/07/09 14:52:18 mrose
46 * sync
47 *
48 * Revision 7.0 90/07/01 19:54:13 mrose
49 * *** empty log message ***
50 *
51 */
52
53/*
54 * NOTICE
55 *
56 * Acquisition, use, and distribution of this module and related
57 * materials are subject to the restrictions of a license agreement.
58 * Consult the Preface in the User's Manual for the full terms of
59 * this agreement.
60 *
61 */
62
63
64/* LINTLIBRARY */
65
66#include <stdio.h>
67#include "pepsy-driver.h"
68#include "psap.h"
69#include "pepsy.h"
70#include "tailor.h"
71
72extern int pepsylose ();
73
74extern tpe *next_tpe(), *fdflt_b();
75
76#define NEXT_TPE(p) (p = next_tpe(p))
77#define CHKTAG(mod, p, pe) ismatch(p, mod, pe->pe_class, pe->pe_id)
78
79
80static char oomsg[] = "Out of memory";
81#define oom(a,b) pepsylose ((a), (b), NULLPE, oomsg)
82
83static char inpmsg[] = "Illegal Null Pointer";
84#define inpm(a,b) pepsylose ((a), (b), NULLPE, inpmsg)
85
86static PE setpresent();
87
88#define F_CI 0x100 /* called internally */
89
90/* Have we got an optional object which we have allocated space for */
91#define ALLOC_MEM(p, parm) (p->pe_type == SOBJECT \
92 && p[-1].pe_type == MEMALLOC)
93
94/*
95 * decode the specified type of the specified module into the given
96 * pe
97 */
98dec_f(typ, mod, pe, explicit, len, buf, parm)
99/* ARGSUSED */
100int typ; /* which type it is */
101modtyp *mod; /* Module it is from */
102PE pe;
103int explicit;
104int *len;
105char **buf;
106char **parm;
107{
108 tpe *p;
109 int iflag; /* are we called internally ? */
110
111 if (typ < 0 || typ >= mod->md_nentries) {
112 return (pepsylose (mod, NULLTPE, NULLPE, "dec_f: Illegal typ %d", typ));
113 }
114
115 p = mod->md_dtab[typ];
116 if (p->pe_type != PE_START) {
117 return (pepsylose (mod, NULLTPE, NULLPE, "dec_f: missing PE_START"));
118 }
119 p++;
120 iflag = explicit & F_CI;
121 explicit &= ~F_CI;
122 if (!iflag)
123 *parm = NULLCP; /* initialise this for the MALLOCs that follow */
124
125 if (pr_obj(explicit, pe, parm, p, mod) == NOTOK)
126 goto bad;
127
128 return (OK);
129bad:
130 return (NOTOK);
131}
132
133/*
134 * Parse an object. The top level of an object does not have any
135 * offset field which makes it different to pr_type routine which
136 * must assume that it has an offset.
137 */
138static int
139pr_obj(expl, pe, parm, p, mod)
140int expl; /* do we look at the tag */
141PE pe;
142char **parm;
143tpe *p;
144modtyp *mod; /* Module it is from */
145{
146 int cnt = 0;
147
148
149 DLOG (psap_log, LLOG_DEBUG, ("1st Decoding the type %d", p->pe_type));
150
151 while (p->pe_type != PE_END) {
152
153 if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
154 if (DEFAULT(p))
155 return pepsylose (mod, p, pe,
156 "pr_obj:Default not implemented");
157 else if (OPTIONAL(p)) {
158 if (ALLOC_MEM(p, parm))
159 fix_mem(parm, p);
160 goto next;
161 } else
162 return pepsylose (mod, p, pe, "pr_obj:missing mandatory parameter");
163 }
164 DLOG (psap_log, LLOG_DEBUG, ("2nd Decoding the type %d", p->pe_type));
165
166 switch (p->pe_type) {
167 case PE_END:
168 case PE_START:
169 return pepsylose (mod, p, pe, "pr_obj:illegal END/START");
170
171 /*
172 * This allows Functions to be called at the very end of the
173 * decoding -- With the decoded data - I hope - very messy
174 */
175 case UCODE:
176 if (mod->md_ducode == NULLIFP
177 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
178 goto bad;
179 break;
180
181
182 default:
183 if (pr_type(expl, pe, parm, p, mod) == NOTOK)
184 goto bad;
185 break;
186 }
187 if (ISDTYPE(p) && cnt > 0)
188 return pepsylose (mod, p, NULLPE, "pr_obj:compound type found");
189next:
190 if (NEXT_TPE(p) == NULLTPE)
191 goto bad;
192 }
193
194 return (OK);
195
196bad:
197 return (NOTOK);
198}
199
200/*
201 * Parse a single type. If a basic type parse it, if a compound type
202 * call the appropriate parsing routine
203 */
204static int
205pr_type(expl, pe, parm, p, mod)
206int expl; /* do we look at the tag */
207PE pe;
208char **parm;
209tpe *p;
210modtyp *mod; /* Module it is from */
211{
212 int cnt = 0;
213 int len;
214 OID oid;
215 char *nparm;
216 /* there is no such pointer as &(*parm + p->pe_ucode) (ucode non zero) so
217 * we fudge it by making a temporary one. As no memory needs to be
218 * allocated through it this should work
219 */
220
221
222 DLOG (psap_log, LLOG_DEBUG, ("pr_type:type %d", p->pe_type));
223
224 while (p->pe_type != PE_END) {
225
226 if (ISDTYPE(p) && expl && CHKTAG(mod, p, pe) == 0) {
227 if (DEFAULT(p)) {
228 if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
229 goto bad;
230 return (NO_DATA_USED);
231 } else if (OPTIONAL(p)) {
232 if (ALLOC_MEM(p, parm))
233 fix_mem(parm, p);
234 return (NO_DATA_USED);
235 } else
236 return pepsylose (mod, p, pe,
237 "pr_type:missing mandatory parameter");
238 }
239 DLOG (psap_log, LLOG_DEBUG, ("pr_type: type %d", p->pe_type));
240
241 switch (p->pe_type) {
242 case PE_END:
243 case PE_START:
244 return pepsylose (mod, p, pe, "pr_type:illegal END/START");
245
246 case BOPTIONAL:
247 if (CHKTAG(mod, p + 1, pe) == 0) {
248 if (ALLOC_MEM(p, parm))
249 fix_mem(parm, p);
250 if (IF_USELECT(p)) {
251 if (p -> pe_ucode >= 0 &&
252 (mod -> md_ducode == NULLIFP ||
253 (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
254 goto bad;
255 }
256 else CLR_OPT_PRESENT(p, parm);
257 return (NO_DATA_USED);
258 }
259 if (IF_USELECT(p)) {
260 if (p -> pe_ucode >= 0 &&
261 (mod -> md_ducode == NULLIFP ||
262 (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
263 goto bad;
264 }
265 else
266 SET_OPT_PRESENT(p, parm);
267 p++;
268 continue;
269
270 case FREE_ONLY: /* the next entry(s) only for freeing routines
271 * so skip this and next entry
272 */
273 break;
274
275 case FFN_CALL: /* call function to free - skip this here */
276 break;
277
278 case UCODE:
279 if (mod->md_ducode == NULLIFP
280 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
281 goto bad;
282 break;
283
284 case ETAG:
285 switch (p->pe_ucode) {
286 default:
287 p++;
288 if (pr_etype(pe->pe_cons, parm, p, mod) == NOTOK)
289 return (NOTOK);
290 }
291 break;
292
293 case MEMALLOC:
294 if (*parm)
295 break; /* already allocated */
296 if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag)) == NULL)
297 return oom(mod, p);
298 break;
299
300 /* The difference between here and the en_type makes me think
301 * that this is never called for SEQ_START ????
302 */
303 case SSEQ_START:
304 if (p->pe_ucode > 0) {
305 if (*parm == NULLCP)
306 return inpm(mod, p);
307 nparm = *parm + p->pe_ucode;
308 if (pr_seq(pe, &nparm, p, mod) == NOTOK)
309 goto bad;
310 } else if (pr_seq(pe, parm, p, mod) == NOTOK)
311 goto bad;
312 break;
313
314 case SEQ_START:
315 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
316 goto bad;
317 break;
318
319 case SSEQOF_START:
320 if (p->pe_ucode > 0) {
321 if (*parm == NULLCP)
322 return inpm(mod, p);
323 nparm = *parm + p->pe_ucode;
324 if (pr_seqof(pe, &nparm, p, mod) == NOTOK)
325 goto bad;
326 } else if (pr_seqof(pe, parm, p, mod) == NOTOK)
327 goto bad;
328 break;
329
330 case SEQOF_START:
331 if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
332 goto bad;
333 break;
334
335 case SSET_START:
336 if (p->pe_ucode > 0) {
337 if (*parm == NULLCP)
338 return inpm(mod, p);
339 nparm = *parm + p->pe_ucode;
340 if (pr_set(pe, &nparm, p, mod) == NOTOK)
341 goto bad;
342 } else if (pr_set(pe, parm, p, mod) == NOTOK)
343 goto bad;
344 break;
345
346 case SET_START:
347 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
348 goto bad;
349 break;
350
351 case SSETOF_START:
352 if (p->pe_ucode > 0) {
353 if (*parm == NULLCP)
354 return inpm(mod, p);
355 nparm = *parm + p->pe_ucode;
356 if (pr_setof(pe, &nparm, p, mod) == NOTOK)
357 goto bad;
358 } else if (pr_setof(pe, parm, p, mod) == NOTOK)
359 goto bad;
360 break;
361
362 case SETOF_START:
363 if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
364 goto bad;
365 break;
366
367 case IMP_OBJ:
368 p++;
369 if (p->pe_type == EXTOBJ) {
370 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
371 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
372 goto bad;
373 } else if (p->pe_type == SEXTOBJ) {
374 if (p->pe_ucode > 0) {
375 if (*parm == NULLCP)
376 return inpm(mod, p);
377 nparm = *parm + p->pe_ucode;
378 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
379 (char **) 0, (char **) &nparm) == NOTOK)
380 goto bad;
381 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
382 (char **) 0, (char **) parm) == NOTOK)
383 goto bad;
384 } else {
385 if (p->pe_type == SOBJECT) {
386 if (p->pe_ucode > 0) {
387 if (*parm == NULLCP)
388 return inpm(mod, p);
389 nparm = *parm + p->pe_ucode;
390 if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
391 == NOTOK)
392 goto bad;
393 } else if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
394 == NOTOK)
395 goto bad;
396 } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
397 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
398 goto bad;
399 }
400 break;
401
402 case SOBJECT:
403 if (p->pe_ucode > 0) {
404 if (*parm == NULLCP)
405 return inpm(mod, p);
406 nparm = *parm + p->pe_ucode;
407 if (pr_obj(expl, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
408 goto bad;
409 } else if (pr_obj(expl, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
410 goto bad;
411 break;
412
413 case OBJECT:
414
415 if (pr_obj(expl, pe, (char **) (*parm + p->pe_ucode),
416 mod->md_dtab[p->pe_tag] + 1, mod)==NOTOK)
417 goto bad;
418 break;
419
420 case SCHOICE_START:
421 if (p->pe_ucode > 0) {
422 if (*parm == NULLCP)
423 return inpm(mod, p);
424 nparm = *parm + p->pe_ucode;
425 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
426 goto bad;
427 } else if (pr_choice(pe, parm, p, mod) == NOTOK)
428 goto bad;
429 break;
430
431 case CHOICE_START:
432 if (pr_choice(pe, parm, p, mod) == NOTOK)
433 goto bad;
434 break;
435
436 case SEXTOBJ:
437 if (p->pe_ucode > 0) {
438 if (*parm == NULLCP)
439 return inpm(mod, p);
440 if (p[1].pe_type != EXTMOD)
441 return pepsylose (mod, p, pe, "pr_type: missing EXTMOD");
442 nparm = *parm + p->pe_ucode;
443 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
444 (char **) 0, &nparm) == NOTOK)
445 goto bad;
446 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
447 (char **) 0, parm) == NOTOK)
448 goto bad;
449 break;
450
451 case EXTOBJ:
452 if (p[1].pe_type != EXTMOD)
453 return pepsylose (mod, p, pe, "pr_type: missing EXTMOD");
454 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *)0,
455 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
456 goto bad;
457 break;
458
459 case INTEGER:
460 if (pe != NULLPE) {
461 DLOG (psap_log, LLOG_DEBUG, ("pr_type:integer %d",
462 prim2num(pe)));
463 if (((*(integer *) (*parm + p->pe_ucode)) = prim2num(pe))
464 == NOTOK && pe->pe_errno != PE_ERR_NONE)
465 return pepsylose (mod, p, pe, "pr_type:bad integer %s",
466 pe_error(pe->pe_errno));
467 }
468 break;
469
470#ifdef PEPSY_REALS
471 case REALTYPE:
472 if (pe != NULLPE) {
473 DLOG (psap_log, LLOG_DEBUG, ("pr_type:Real %g",
474 prim2real(pe)));
475
476 if (((*(double *) (*parm + p->pe_ucode)) = prim2real(pe))
477 == NOTOK && pe->pe_errno != PE_ERR_NONE)
478 return pepsylose (mod, p, pe, "pr_type:bad real %s",
479 pe_error(pe->pe_errno));
480 }
481 break;
482
483#endif
484
485 case BOOLEAN:
486 if (pe != NULLPE) {
487 int i;
488
489 DLOG (psap_log, LLOG_DEBUG, ("boolean %d",
490 prim2flag(pe)));
491 if ((i = prim2flag (pe)) == NOTOK)
492 return pepsylose (mod, p, pe, "pr_type:bad integer %s",
493 pe_error(pe->pe_errno));
494 *(char *) (*parm + p->pe_ucode) = i & 0xff;
495 }
496 break;
497
498 case T_NULL:
499 break;
500
501 case SANY:
502 if (pe != NULLPE) {
503 ((*(PE *) (parm + p->pe_ucode)) = pe)->pe_refcnt++;
504 if (pe->pe_errno != PE_ERR_NONE)
505 return pepsylose (mod, p, pe, "pr_type:bad ANY %s",
506 pe_error(pe->pe_errno));
507 }
508 break;
509
510 case ANY:
511 if (pe != NULLPE) {
512 (*(PE *) (*parm + p->pe_ucode) = pe)->pe_refcnt++;
513 if (pe->pe_errno != PE_ERR_NONE)
514 return pepsylose(mod, p, pe, "pr_type:bad ANY %s",
515 pe_error(pe->pe_errno));
516 }
517 break;
518
519 case SOCTETSTRING:
520 if (pe != NULLPE) {
521 if ((*((struct qbuf **) (parm + p->pe_ucode)) = prim2qb(pe)) ==
522 (struct qbuf *) NULL && pe->pe_errno != PE_ERR_NONE)
523 return pepsylose(mod, p, pe, "pr_type:bad octet string %s",
524 pe_error(pe->pe_errno));
525 }
526 break;
527
528 case OCTETSTRING:
529 if (pe != NULLPE) {
530 if ((*((struct qbuf **) (*parm + p->pe_ucode))
531 = prim2qb(pe)) == (struct qbuf *) NULL
532 && pe->pe_errno != PE_ERR_NONE)
533 return pepsylose (mod, p, pe,
534 "pr_type:bad octet string %s",
535 pe_error(pe->pe_errno));
536 }
537 break;
538
539 case T_STRING:
540 if ((*((char **) (*parm + p->pe_ucode)) = prim2str(pe, &len))
541 == NULLCP && pe->pe_errno != PE_ERR_NONE)
542 return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
543 pe_error(pe->pe_errno));
544 /* undocumented feature of prim2str that it adds a NULL char
545 * to the end of the string
546 */
547 break;
548
549 case BITSTR_PTR:
550 if (p[1].pe_type != BITSTR_LEN)
551 return pepsylose (mod, &p[1], NULLPE,
552 "pr_type: missing BITSTR_PTR");
553
554 pe = prim2bit(pe);
555 if ((*((char **) (*parm + p->pe_ucode)) =
556 bitstr2strb(pe, (int *)(*parm + (p + 1)->pe_ucode)))
557 == NULLCP && pe->pe_errno != PE_ERR_NONE)
558 return pepsylose (mod, p, pe, "pr_type:bad bit string %s",
559 pe_error(pe->pe_errno));
560 break;
561
562
563 case OCTET_PTR:
564 if (p[1].pe_type != OCTET_LEN)
565 return pepsylose (mod, &p[1], NULLPE,
566 "pr_type: missing OCTET_PTR");
567 if ((*((char **) (*parm + p->pe_ucode)) =
568 prim2str(pe, (int *)(*parm + (p + 1)->pe_ucode)))
569 == NULLCP && pe->pe_errno != PE_ERR_NONE)
570 return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
571 pe_error(pe->pe_errno));
572 break;
573
574
575 case SBITSTRING:
576 if (pe != NULLPE) {
577 if ((*((PE *) (parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
578 return pepsylose (mod, p, pe, "pr_type:out of memory");
579 }
580 break;
581
582 case BITSTRING:
583 if (pe != NULLPE) {
584 if ((*((PE *) (*parm + p->pe_ucode)) =
585 prim2bit(pe_cpy(pe))) == NULLPE)
586 return pepsylose(mod, p, pe, "pr_type:out of memory");
587 }
588 break;
589
590 case SOBJID:
591 /*
592 * This is messy because ISODE's library routine uses a
593 * static. Don't know why they do
594 */
595 if ((oid = prim2oid(pe + p->pe_ucode)) == NULLOID
596 || (*(OID *) parm = oid_cpy(oid)) == NULLOID) {
597 if (oid && oid->oid_elements) {
598 free((char *) oid->oid_elements);
599 oid->oid_elements = NULL;
600 }
601 return pepsylose (mod, p, pe,
602 "pr_type:Object Identifier: out of memory");
603 }
604 if (oid && oid->oid_elements) {
605 free((char *) oid->oid_elements);
606 oid->oid_elements = NULL;
607 }
608 break;
609
610 case OBJID:
611 if ((oid = prim2oid(pe)) == NULLOID
612 || (*(OID *) (*parm + p->pe_ucode) = oid_cpy(oid)) == NULLOID) {
613 if (oid && oid->oid_elements) {
614 free((char *) oid->oid_elements);
615 oid->oid_elements = NULL;
616 }
617 return pepsylose (mod, p, pe,
618 "pr_type:Object Identifier: out of memory");
619 }
620 if (oid && oid->oid_elements) {
621 free((char *) oid->oid_elements);
622 oid->oid_elements = NULL;
623 }
624 break;
625
626 case FN_CALL:
627 if ((FN_PTR(mod, p))(parm, pe) == NOTOK)
628 return pepsylose (mod, p, NULLPE,
629 "pr_type:FN_CALL:call failed");
630 break;
631
632 default:
633 return pepsylose (mod, p, pe, "pr_type: type not implemented");
634 }
635 if (ISDTYPE(p) && cnt > 0)
636 return pepsylose (mod, p, pe, "pr_type:compound type found");
637
638 if (ISDTYPE(p) && pe != NULLPE)
639 return (OK);
640 if (NEXT_TPE(p) == NULLTPE)
641 goto bad;
642 }
643
644 return (OK);
645
646bad:
647 return (NOTOK);
648}
649
650/*
651 * Parse a sequence, calling appropriate routines to parse each sub
652 * type
653 */
654static int
655pr_seq(head, parm, p, mod)
656PE head;
657char **parm;
658tpe *p;
659modtyp *mod; /* Module it is from */
660{
661 PE pe;
662 int *popt = NULL; /* Pointer to optional field */
663 int optcnt = 0; /* Number of optionals bits so far */
664 char *nparm;
665
666 if (p->pe_type != SEQ_START && p->pe_type != SSEQ_START)
667 return pepsylose (mod, p, head, "pr_seq: missing SEQ_START");
668 p++;
669
670 if (p->pe_type == DFLT_B)
671 p++;
672
673 pe = first_member(head);
674 while (p->pe_type != PE_END) {
675 DLOG (psap_log, LLOG_DEBUG, ("pr_seq:type %d", p->pe_type));
676
677 if (ISDTYPE(p) && OPTIONAL(p)) {
678 switch (p->pe_type) {
679 case INTEGER:
680 case REALTYPE:
681 case BOOLEAN:
682 case T_NULL:
683 if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
684 optcnt++;
685 goto next;
686 }
687 SETBIT(*popt, optcnt++);
688 break;
689
690
691 default:
692 if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
693 if (ALLOC_MEM(p, parm))
694 fix_mem(parm, p);
695 goto next;
696 }
697 break;
698 }
699 } else if (ISDTYPE(p) && (pe == NULLPE || CHKTAG(mod, p, pe) == 0)) {
700 if (DEFAULT(p)) {
701 if(setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
702 goto bad;
703 goto next;
704 } else
705 return pepsylose (mod, p, pe,
706 "pr_seq:missing mandatory parameter");
707 }
708 switch (p->pe_type) {
709 case OPTL:
710 popt = (int *) (*parm + p->pe_ucode);
711 break;
712
713 case FREE_ONLY: /* the next entry(s) only for freeing routines
714 * so skip this and next entry
715 */
716 break;
717
718 case FFN_CALL: /* call function to free - skip this here */
719 break;
720
721 case UCODE:
722 if (mod->md_ducode == NULLIFP
723 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
724 goto bad;
725 break;
726
727 case BOPTIONAL:
728 if (pe == NULLPE || CHKTAG(mod, p + 1, pe) == 0) {
729 if (ALLOC_MEM(p, parm))
730 fix_mem(parm, p);
731 if (IF_USELECT(p)) {
732 if (p -> pe_ucode >= 0 &&
733 (mod -> md_ducode == NULLIFP ||
734 (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
735 goto bad;
736 }
737 else CLR_OPT_PRESENT(p, parm);
738 goto next;
739 }
740 if (IF_USELECT(p)) {
741 if (p -> pe_ucode >= 0 &&
742 (mod -> md_ducode == NULLIFP ||
743 (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
744 goto bad;
745 }
746 else SET_OPT_PRESENT(p, parm);
747 p++;
748 continue;
749
750 case ETAG:
751 if (pr_type(1, pe, parm, p, mod) == NOTOK)
752 goto bad;
753 break;
754
755 case MEMALLOC:
756 if (*parm)
757 break; /* already allocated */
758 if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))==NULLCP)
759 return oom(mod, p);
760 break;
761
762 case SEQ_START:
763 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
764 goto bad;
765 break;
766
767 case SEQOF_START:
768 if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
769 goto bad;
770 break;
771
772 case SET_START:
773 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
774 goto bad;
775 break;
776
777 case SETOF_START:
778 if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
779 goto bad;
780 break;
781
782 case IMP_OBJ:
783 p++;
784 if (p->pe_type == EXTOBJ) {
785 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
786 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
787 goto bad;
788 } else if (p->pe_type == SEXTOBJ) {
789 if (p->pe_ucode > 0) {
790 if (*parm == NULLCP)
791 return inpm(mod, p);
792 nparm = *parm + p->pe_ucode;
793 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
794 (char **) 0, (char **) &nparm) == NOTOK)
795 goto bad;
796 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *)0,
797 (char **) 0, (char **) parm) == NOTOK)
798 goto bad;
799 } else {
800 if (p->pe_type == SOBJECT) {
801 if (p->pe_ucode > 0) {
802 if (*parm == NULLCP)
803 return inpm(mod, p);
804 nparm = *parm + p->pe_ucode;
805 if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
806 == NOTOK)
807 goto bad;
808 } else
809 if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
810 == NOTOK)
811 goto bad;
812 } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
813 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
814 goto bad;
815 }
816 break;
817
818 case SOBJECT:
819 if (p->pe_ucode > 0) {
820 if (*parm == NULLCP)
821 return inpm(mod, p);
822 nparm = *parm + p->pe_ucode;
823 if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
824 goto bad;
825 } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
826 goto bad;
827 break;
828
829 case OBJECT:
830 if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
831 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
832 goto bad;
833 break;
834
835 case SCHOICE_START:
836 if (p->pe_ucode > 0) {
837 if (*parm == NULLCP)
838 return inpm(mod, p);
839 nparm = *parm + p->pe_ucode;
840 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
841 goto bad;
842 } else if (pr_choice(pe, parm, p, mod) == NOTOK)
843 goto bad;
844 break;
845
846 case CHOICE_START:
847 if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
848 goto bad;
849 break;
850
851 case SEXTOBJ:
852 if (p[1].pe_type != EXTMOD)
853 return pepsylose (mod, p, pe, "pr_seq: missing EXTMOD");
854 if (p->pe_ucode > 0) {
855 if (*parm == NULLCP)
856 return inpm(mod, p);
857 nparm = *parm + p->pe_ucode;
858 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
859 (char **) 0, &nparm) == NOTOK)
860 goto bad;
861 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
862 (char **) 0, parm) == NOTOK)
863 goto bad;
864 break;
865
866 case EXTOBJ:
867 if (p[1].pe_type != EXTMOD)
868 return pepsylose (mod, p, pe, "pr_seq: missing EXTMOD");
869
870 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
871 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
872 goto bad;
873 break;
874
875 default:
876 /* only called if we have a match */
877 if (pr_type(1, pe, parm, p, mod) == NOTOK)
878 goto bad;
879 break;
880 }
881
882 if (ISDTYPE(p) && pe != NULLPE)
883 pe = next_member(head, pe);
884next:
885 if (NEXT_TPE(p) == NULLTPE)
886 goto bad;
887 }
888
889 return (OK);
890
891bad:
892 return (NOTOK);
893}
894
895
896/*
897 * Parse a set, calling appropriate routines to parse each sub type
898 */
899static int
900pr_set(head, parm, p, mod)
901PE head;
902char **parm;
903tpe *p;
904modtyp *mod; /* Module it is from */
905{
906 PE pe;
907 int *popt = NULL; /* Pointer to optional field */
908 int optcnt = 0; /* Number of optionals bits so far */
909 char *nparm;
910
911 if (p->pe_type != SET_START && p->pe_type != SSET_START)
912 return pepsylose (mod, p, NULLPE, "pr_seq: missing SET_START");
913 p++;
914
915 if (p->pe_type == DFLT_B)
916 p++;
917
918 while (p->pe_type != PE_END) {
919 DLOG (psap_log, LLOG_DEBUG, ("pr_set type %d", p->pe_type));
920
921 if (ISDTYPE(p) && OPTIONAL(p)) {
922 switch (p->pe_type) {
923 case INTEGER:
924 case REALTYPE:
925 case BOOLEAN:
926 case T_NULL:
927 if ((pe = setpresent(head, p, mod)) == NULLPE) {
928 optcnt++;
929 goto next;
930 }
931 SETBIT(*popt, optcnt++);
932 break;
933
934
935 default:
936 if ((pe = setpresent(head, p, mod)) == NULLPE) {
937 if (ALLOC_MEM(p, parm))
938 fix_mem(parm, p);
939 goto next;
940 }
941 break;
942 }
943 } else if (ISDTYPE(p) && (pe = setpresent(head, p, mod)) == NULLPE) {
944 if (DEFAULT(p)) {
945 if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
946 goto bad;
947 goto next;
948 } else
949 return pepsylose (mod, p, pe,
950 "pr_set:missing mandatory parameter");
951 }
952 switch (p->pe_type) {
953 case OPTL:
954 popt = (int *) (*parm + p->pe_ucode);
955 break;
956
957 case FREE_ONLY: /* the next entry(s) only for freeing routines
958 * so skip this and next entry
959 */
960 break;
961
962 case FFN_CALL: /* call function to free - skip this here */
963 break;
964
965 case UCODE:
966 if (mod->md_ducode == NULLIFP
967 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
968 goto bad;
969 break;
970
971 case BOPTIONAL:
972 if ((pe = setpresent(head, p + 1, mod)) == NULLPE) {
973 if (ALLOC_MEM(p, parm))
974 fix_mem(parm, p);
975 if (IF_USELECT(p)) {
976 if (p -> pe_ucode >= 0 &&
977 (mod -> md_ducode == NULLIFP ||
978 (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
979 goto bad;
980 }
981 else CLR_OPT_PRESENT(p, parm);
982 goto next;
983 }
984 if (IF_USELECT(p)) {
985 if (p -> pe_ucode >= 0 &&
986 (mod -> md_ducode == NULLIFP ||
987 (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
988 goto bad;
989 }
990 else SET_OPT_PRESENT(p, parm);
991 p++;
992 continue;
993
994 case ETAG:
995 if (pr_type(1, pe, parm, p, mod) == NOTOK)
996 goto bad;
997 break;
998
999 case MEMALLOC:
1000 if (*parm)
1001 break; /* already allocated */
1002 if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))==NULLCP)
1003 return oom(mod, p);
1004 break;
1005
1006 case SEQ_START:
1007 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1008 goto bad;
1009 break;
1010
1011 case SEQOF_START:
1012 if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1013 goto bad;
1014 break;
1015
1016 case SET_START:
1017 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1018 goto bad;
1019 break;
1020
1021 case SETOF_START:
1022 if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1023 goto bad;
1024 break;
1025
1026 case IMP_OBJ:
1027 p++;
1028 if (p->pe_type == EXTOBJ) {
1029 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1030 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1031 goto bad;
1032 } else if (p->pe_type == SEXTOBJ) {
1033 if (p->pe_ucode > 0) {
1034 if (*parm == NULLCP)
1035 return inpm(mod, p);
1036 nparm = *parm + p->pe_ucode;
1037 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1038 (char **) 0, (char **) &nparm) == NOTOK)
1039 goto bad;
1040 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1041 (char **) 0, (char **) parm) == NOTOK)
1042 goto bad;
1043 } else {
1044 if (p->pe_type == SOBJECT) {
1045 if (p->pe_ucode > 0) {
1046 if (*parm == NULLCP)
1047 return inpm(mod, p);
1048 nparm = *parm + p->pe_ucode;
1049 if (pr_obj(0, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)
1050 == NOTOK)
1051 goto bad;
1052 } else if (pr_obj(0, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)
1053 == NOTOK)
1054 goto bad;
1055 } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
1056 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1057 goto bad;
1058 }
1059 break;
1060
1061 case SOBJECT:
1062 if (p->pe_ucode > 0) {
1063 if (*parm == NULLCP)
1064 return inpm(mod, p);
1065 nparm = *parm + p->pe_ucode;
1066 if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod)== NOTOK)
1067 goto bad;
1068 } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod)== NOTOK)
1069 goto bad;
1070 break;
1071
1072 case OBJECT:
1073 if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
1074 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1075 goto bad;
1076 break;
1077
1078 case SCHOICE_START:
1079 if (p->pe_ucode > 0) {
1080 if (*parm == NULLCP)
1081 return inpm(mod, p);
1082 nparm = *parm + p->pe_ucode;
1083 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
1084 goto bad;
1085 } else if (pr_choice(pe, parm, p, mod) == NOTOK)
1086 goto bad;
1087 break;
1088
1089 case CHOICE_START:
1090 if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1091 goto bad;
1092 break;
1093
1094 case SEXTOBJ:
1095 if (p[1].pe_type != EXTMOD)
1096 return pepsylose (mod, p, pe, "pr_set: missing EXTMOD");
1097 if (p->pe_ucode > 0) {
1098 if (*parm == NULLCP)
1099 return inpm(mod, p);
1100 nparm = *parm + p->pe_ucode;
1101 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1102 (char **) 0, &nparm) == NOTOK)
1103 goto bad;
1104 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1105 (char **) 0, parm) == NOTOK)
1106 goto bad;
1107 break;
1108
1109 case EXTOBJ:
1110 if (p[1].pe_type != EXTMOD)
1111 return pepsylose (mod, p, pe, "pr_set: missing EXTMOD");
1112
1113 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1114 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1115 goto bad;
1116 break;
1117
1118 default:
1119 if (pr_type(1, pe, parm, p, mod) == NOTOK)
1120 goto bad;
1121 break;
1122 }
1123
1124next:
1125 if (NEXT_TPE(p) == NULLTPE)
1126 goto bad;
1127 }
1128
1129 return (OK);
1130
1131bad:
1132 return (NOTOK);
1133
1134}
1135
1136
1137/*
1138 * Parse a sequence of calling appropriate routines to parse each sub
1139 * type
1140 */
1141static int
1142pr_seqof(head, parm, p, mod)
1143PE head;
1144char **parm;
1145tpe *p;
1146modtyp *mod; /* Module it is from */
1147{
1148 PE pe;
1149 tpe *start; /* first entry in list */
1150 int dflt = 0;
1151 char *nparm;
1152
1153 if (p->pe_type != SEQOF_START && p->pe_type != SSEQOF_START)
1154 return pepsylose (mod, p, head, "pr_seqof:missing SEQOF_START");
1155
1156 p++;
1157
1158 if (p->pe_type == DFLT_B)
1159 p++;
1160
1161 start = p;
1162
1163 pe = first_member(head);
1164 while (pe != NULLPE) {
1165 while (p->pe_type != PE_END) {
1166
1167 DLOG (psap_log, LLOG_DEBUG, ("pr_seqof type %d", p->pe_type));
1168
1169 if (ISDTYPE(p) && CHKTAG(mod, p, pe) == 0) {
1170 if (DEFAULT(p)) {
1171 if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
1172 goto bad;
1173 goto next;
1174 } else if (OPTIONAL(p)) {
1175 if (ALLOC_MEM(p, parm))
1176 fix_mem(parm, p);
1177 goto next;
1178 } else
1179 return pepsylose (mod, p, pe,
1180 "pr_seqof:missing mandatory parameter");
1181 }
1182 switch (p->pe_type) {
1183 case FREE_ONLY: /* the next entry(s) only for freeing routines
1184 * so skip this and next entry
1185 */
1186 break;
1187
1188 case FFN_CALL: /* call function to free - skip this here */
1189 break;
1190
1191 case UCODE:
1192 if (mod->md_ducode == NULLIFP
1193 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
1194 goto bad;
1195 break;
1196
1197 case BOPTIONAL:
1198 if (pe == NULLPE || CHKTAG(mod, p + 1, pe) == 0) {
1199 if (ALLOC_MEM(p, parm))
1200 fix_mem(parm, p);
1201 if (IF_USELECT(p)) {
1202 if (p -> pe_ucode >= 0 &&
1203 (mod -> md_ducode == NULLIFP ||
1204 (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
1205 goto bad;
1206 }
1207 else CLR_OPT_PRESENT(p, parm);
1208 goto next;
1209 }
1210 if (IF_USELECT(p)) {
1211 if (p -> pe_ucode >= 0 &&
1212 (mod -> md_ducode == NULLIFP ||
1213 (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
1214 goto bad;
1215 }
1216 else SET_OPT_PRESENT(p, parm);
1217 p++;
1218 continue;
1219
1220 case ETAG:
1221 if (pr_type(1, pe, parm, p, mod) == NOTOK)
1222 goto bad;
1223 break;
1224
1225 case MEMALLOC:
1226 if (*parm)
1227 break; /* already allocated */
1228 if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag))
1229 == NULLCP)
1230 return oom(mod, p);
1231 break;
1232
1233 case SCTRL:
1234 parm = (char **) ((char *) *parm + p->pe_ucode);
1235 break;
1236
1237 case SEQ_START:
1238 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
1239 goto bad;
1240 break;
1241
1242 case SEQOF_START:
1243 if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p,mod)==NOTOK)
1244 goto bad;
1245 break;
1246
1247 case SET_START:
1248 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
1249 goto bad;
1250 break;
1251
1252 case SETOF_START:
1253 if (pr_setof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
1254 goto bad;
1255 break;
1256
1257 case SOBJECT:
1258 if (p->pe_ucode > 0) {
1259 if (*parm == NULLCP)
1260 return inpm(mod, p);
1261 nparm = *parm + p->pe_ucode;
1262 if (pr_obj(1,pe, &nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1263 goto bad;
1264 } else if (pr_obj(1,pe, parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1265 goto bad;
1266 break;
1267
1268 case OBJECT:
1269 if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
1270 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1271 goto bad;
1272 break;
1273
1274 case SCHOICE_START:
1275 if (*parm == NULLCP)
1276 return inpm(mod, p);
1277 nparm = *parm + p->pe_ucode;
1278 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
1279 goto bad;
1280 break;
1281
1282 case CHOICE_START:
1283 if (pr_choice(pe, (char **)(*parm + p->pe_ucode), p,mod)==NOTOK)
1284 goto bad;
1285 break;
1286
1287 case SEXTOBJ:
1288 if (p[1].pe_type != EXTMOD)
1289 return pepsylose (mod, p, pe, "pr_seqof: missing EXTMOD");
1290 if (p->pe_ucode > 0) {
1291 if (*parm == NULLCP)
1292 return inpm(mod, p);
1293 nparm = *parm + p->pe_ucode;
1294 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1295 (char **) 0, &nparm) == NOTOK)
1296 goto bad;
1297 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1298 (char **) 0, parm) == NOTOK)
1299 goto bad;
1300 break;
1301
1302 case EXTOBJ:
1303 if (p[1].pe_type != EXTMOD)
1304 return pepsylose (mod, p, pe, "pr_seqof: missing EXTMOD");
1305
1306 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1307 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1308 goto bad;
1309 break;
1310
1311 default:
1312 if (pr_type(1, pe, parm, p, mod) == NOTOK)
1313 goto bad;
1314 break;
1315 }
1316
1317 if (ISDTYPE(p) && dflt == 0)
1318 pe = next_member(head, pe);
1319 next:
1320 if (NEXT_TPE(p) == NULLTPE)
1321 goto bad;
1322 }
1323 parm = (char **) (*parm + p->pe_ucode);
1324 p = start;
1325 }
1326
1327 return (OK);
1328
1329bad:
1330 return (NOTOK);
1331}
1332
1333/*
1334 * Parse a setof, calling appropriate routines to parse each sub type
1335 */
1336static int
1337pr_setof(head, parm, p, mod)
1338PE head;
1339char **parm;
1340tpe *p;
1341modtyp *mod; /* Module it is from */
1342{
1343 PE pe;
1344 tpe *start;
1345 char *nparm;
1346
1347 if (p->pe_type != SETOF_START && p->pe_type != SSETOF_START)
1348 return pepsylose(mod, p, head, "pr_setof: missing SETOF_START");
1349 p++;
1350
1351 if (p->pe_type == DFLT_B)
1352 p++;
1353
1354 start = p;
1355 pe = first_member(head);
1356
1357 for (pe = first_member(head); pe; pe = next_member(head, pe)) {
1358 while (p->pe_type != PE_END) {
1359 DLOG (psap_log, LLOG_DEBUG, ("pr_setof type %d", p->pe_type));
1360
1361 if (pe == NULLPE || CHKTAG(mod, p, pe) == 0) {
1362 if (DEFAULT(p)) {
1363 if (setdval(p, FDFLT_B(p), parm, mod) == NOTOK)
1364 goto bad;
1365 goto next;
1366 } else
1367 return pepsylose (mod, p, pe,
1368 "pr_setof:missing mandatory parameter");
1369 }
1370
1371 switch (p->pe_type) {
1372 case FREE_ONLY: /* the next entry(s) only for freeing routines
1373 * so skip this and next entry
1374 */
1375 break;
1376
1377 case FFN_CALL: /* call function to free - skip this here */
1378 break;
1379
1380 case UCODE:
1381 if (mod->md_ducode == NULLIFP
1382 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
1383 goto bad;
1384 break;
1385
1386 case BOPTIONAL:
1387 if ((pe = setpresent(head, p + 1, mod)) == NULLPE) {
1388 if (ALLOC_MEM(p, parm))
1389 fix_mem(parm, p);
1390 if (IF_USELECT(p)) {
1391 if (p -> pe_ucode >= 0 &&
1392 (mod -> md_ducode == NULLIFP ||
1393 (*mod->md_ducode)(parm, pe, p, 0) == NOTOK))
1394 goto bad;
1395 }
1396 else CLR_OPT_PRESENT(p, parm);
1397 goto next;
1398 }
1399 if (IF_USELECT(p)) {
1400 if (p -> pe_ucode >= 0 &&
1401 (mod -> md_ducode == NULLIFP ||
1402 (*mod->md_ducode)(parm, pe, p, 1) == NOTOK))
1403 goto bad;
1404 }
1405 else SET_OPT_PRESENT(p, parm);
1406 p++;
1407 continue;
1408
1409 case ETAG:
1410 if (pr_type(1, pe->pe_cons, parm, p, mod) == NOTOK)
1411 goto bad;
1412 break;
1413
1414 case MEMALLOC:
1415 if (*parm)
1416 break; /* already allocated */
1417 if ((*(parm) = (char *) calloc(1, (unsigned )p->pe_tag))
1418 == NULLCP)
1419 return oom(mod, p);
1420 break;
1421
1422 case SCTRL:
1423 parm = (char **) (*parm + p->pe_ucode);
1424 break;
1425
1426 case SEQ_START:
1427 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
1428 goto bad;
1429 break;
1430
1431 case SEQOF_START:
1432 if (pr_seqof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
1433 goto bad;
1434 break;
1435
1436 case SET_START:
1437 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) ==NOTOK)
1438 goto bad;
1439 break;
1440
1441 case SETOF_START:
1442 if (pr_setof(pe, (char **)(*parm + p->pe_ucode), p, mod)==NOTOK)
1443 goto bad;
1444 break;
1445
1446 case SOBJECT:
1447 if (p->pe_ucode > 0) {
1448 if (*parm == NULLCP)
1449 return inpm(mod, p);
1450 nparm = *parm + p->pe_ucode;
1451 if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1452 goto bad;
1453 } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1454 goto bad;
1455 break;
1456
1457 case OBJECT:
1458 if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
1459 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1460 goto bad;
1461 break;
1462
1463 case SCHOICE_START:
1464 if (p->pe_ucode > 0) {
1465 if (*parm == NULLCP)
1466 return inpm(mod, p);
1467 nparm = *parm + p->pe_ucode;
1468 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
1469 goto bad;
1470 } else if (pr_choice(pe, parm, p, mod) == NOTOK)
1471 goto bad;
1472 break;
1473
1474 case CHOICE_START:
1475 if (pr_choice(pe, (char **)(*parm + p->pe_ucode), p,mod)==NOTOK)
1476 goto bad;
1477 break;
1478
1479 case SEXTOBJ:
1480 if (p[1].pe_type != EXTMOD)
1481 return pepsylose (mod, p, pe, "pr_setof: missing EXTMOD");
1482 if (p->pe_ucode > 0) {
1483 if (*parm == NULLCP)
1484 return inpm(mod, p);
1485 nparm = *parm + p->pe_ucode;
1486 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
1487 (int *) 0, (char **) 0, &nparm) == NOTOK)
1488 goto bad;
1489 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
1490 (int *) 0, (char **) 0, parm) == NOTOK)
1491 goto bad;
1492 break;
1493
1494 case EXTOBJ:
1495 if (p[1].pe_type != EXTMOD)
1496 return pepsylose (mod, p, pe, "pr_setof: missing EXTMOD");
1497 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI,
1498 (int *) 0, (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1499 goto bad;
1500 break;
1501
1502 default:
1503 if (pr_type(1, pe, parm, p, mod) == NOTOK)
1504 goto bad;
1505 break;
1506 }
1507
1508 next:
1509 if (NEXT_TPE(p) == NULLTPE)
1510 goto bad;
1511 }
1512 parm = (char **) (*parm + p->pe_ucode);
1513 p = start;
1514 }
1515
1516 return (OK);
1517
1518bad:
1519 return (NOTOK);
1520}
1521
1522/*
1523 * parse a choice field. This means find which choice is taken
1524 */
1525static int
1526pr_choice(head, parm, p, mod)
1527PE head;
1528char **parm;
1529tpe *p;
1530modtyp *mod; /* Module it is from */
1531{
1532 int *poffset;
1533 int cnt;
1534 tpe *savep = NULLTPE;
1535
1536 if (p->pe_type != CHOICE_START && p->pe_type != SCHOICE_START)
1537 return pepsylose (mod, p, head, "pr_choice:missing CHOICE_START");
1538
1539 p++;
1540
1541 if (p->pe_type == DFLT_B)
1542 p++;
1543
1544 if (p->pe_type == MEMALLOC) {
1545 if (*parm == NULLCP) {
1546 /* not already allocated */
1547 if ((*(parm) = (char *) calloc(1,(unsigned )p->pe_tag))==NULLCP)
1548 return oom(mod, p);
1549 }
1550 p++;
1551 }
1552 if (p->pe_type == SCTRL) {
1553 if (IF_USELECT(p)) {
1554 savep = p;
1555 } else if ((poffset = (int *) (*parm + p->pe_ucode)) == NULL)
1556 goto bad;
1557 p++;
1558 }
1559 for (cnt = 1; p->pe_type != PE_END; NEXT_TPE(p)) {
1560 if (ISDTYPE(p)) {
1561 if (ismatch(p, mod, head->pe_class, head->pe_id)) {
1562 if (pr_etype(head, parm, p, mod) == NOTOK)
1563 goto bad;
1564 if (savep) {
1565 if (savep -> pe_ucode >= 0 &&
1566 (mod -> md_ducode == NULLIFP ||
1567 (*mod -> md_ducode)(parm, head, savep, cnt) == NOTOK))
1568 goto bad;
1569 }
1570 else
1571 *poffset = cnt;
1572 NEXT_TPE(p);
1573 if (p->pe_type == UCODE) {
1574 if (mod->md_ducode == NULLIFP
1575 || (*mod->md_ducode) (parm, head, p, 0) == NOTOK)
1576 return (NOTOK);
1577 }
1578 return (OK);
1579 }
1580 cnt++;
1581 }
1582 }
1583 (void) pepsylose(mod, p, head, "pr_choice: no choice taken");
1584bad:
1585 return (NOTOK);
1586}
1587
1588/*
1589 * Parse a single type for explicit tag If a basic type parse it, if
1590 * a compound type call the appropriate parsing routine
1591 */
1592static int
1593pr_etype(pe, parm, p, mod)
1594PE pe;
1595char **parm;
1596tpe *p;
1597modtyp *mod; /* Module it is from */
1598{
1599 int cnt;
1600 char *nparm;
1601
1602 switch (p->pe_type) {
1603 case PE_END:
1604 case PE_START:
1605 return pepsylose (mod, p, pe, "pr_etype:illegal END/START");
1606
1607 case FREE_ONLY: /* the next entry(s) only for freeing routines
1608 * so skip this and next entry
1609 */
1610 break;
1611
1612 case FFN_CALL: /* call function to free - skip this here */
1613 break;
1614
1615 case UCODE:
1616 if (mod->md_ducode == NULLIFP
1617 || (*mod->md_ducode) (parm, pe, p, 0) == NOTOK)
1618 goto bad;
1619 break;
1620
1621 case BOPTIONAL:
1622 return pepsylose (mod, p, pe, "pr_etype:illegal BOPTIONAL");
1623
1624 case ETAG:
1625 switch (p->pe_ucode) {
1626
1627 default:
1628 p++;
1629 if (pr_etype(pe->pe_cons, parm, p, mod) == NOTOK)
1630 goto bad;
1631 }
1632 break;
1633
1634 case MEMALLOC:
1635 if (*parm)
1636 break; /* already allocated */
1637 if ((*(parm) = (char *) calloc(1, (unsigned ) p->pe_tag)) == NULLCP)
1638 return oom(mod, p);
1639 break;
1640
1641 case SEQ_START:
1642 if (pr_seq(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1643 goto bad;
1644 break;
1645
1646 case SSEQOF_START:
1647 if (p->pe_ucode > 0) {
1648 if (*parm == NULLCP)
1649 return inpm(mod, p);
1650 nparm = *parm + p->pe_ucode;
1651 if (pr_seqof(pe, &nparm, p, mod) == NOTOK)
1652 goto bad;
1653 } else if (pr_seqof(pe, parm, p, mod) == NOTOK)
1654 goto bad;
1655 break;
1656
1657 case SEQOF_START:
1658 if (pr_seqof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1659 goto bad;
1660 break;
1661
1662 case SSEQ_START:
1663 if (p->pe_ucode > 0) {
1664 if (*parm == NULLCP)
1665 return inpm(mod, p);
1666 nparm = *parm + p->pe_ucode;
1667 if (pr_seq(pe, &nparm, p, mod) == NOTOK)
1668 goto bad;
1669 } else if (pr_seq(pe, parm, p, mod) == NOTOK)
1670 goto bad;
1671 break;
1672
1673 case SET_START:
1674 if (pr_set(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1675 goto bad;
1676 break;
1677
1678 case SSET_START:
1679 if (p->pe_ucode > 0) {
1680 if (*parm == NULLCP)
1681 return inpm(mod, p);
1682 nparm = *parm + p->pe_ucode;
1683 if (pr_set(pe, &nparm, p, mod) == NOTOK)
1684 goto bad;
1685 } else if (pr_set(pe, parm, p, mod) == NOTOK)
1686 goto bad;
1687 break;
1688
1689 case SETOF_START:
1690 if (pr_setof(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1691 goto bad;
1692 break;
1693
1694 case SSETOF_START:
1695 if (p->pe_ucode > 0) {
1696 if (*parm == NULLCP)
1697 return inpm(mod, p);
1698 nparm = *parm + p->pe_ucode;
1699 if (pr_setof(pe, &nparm, p, mod) == NOTOK)
1700 goto bad;
1701 } else if (pr_setof(pe, parm, p, mod) == NOTOK)
1702 goto bad;
1703 break;
1704
1705 case IMP_OBJ:
1706 p++;
1707 if (p->pe_type == EXTOBJ) {
1708 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1709 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1710 goto bad;
1711 } else if (p->pe_type == SEXTOBJ) {
1712 if (p->pe_ucode > 0) {
1713 if (*parm == NULLCP)
1714 return inpm(mod, p);
1715 nparm = *parm + p->pe_ucode;
1716 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1717 (char **) 0, (char **) &nparm) == NOTOK)
1718 goto bad;
1719 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 0|F_CI, (int *) 0,
1720 (char **) 0, (char **) parm) == NOTOK)
1721 goto bad;
1722 } else {
1723 if (p->pe_type == SOBJECT) {
1724 if (p->pe_ucode > 0) {
1725 if (*parm == NULLCP)
1726 return inpm(mod, p);
1727 nparm = *parm + p->pe_ucode;
1728 if (pr_obj(0, pe, (char **)&nparm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1729 goto bad;
1730 } else if (pr_obj(0, pe, (char **)parm, mod->md_dtab[p->pe_tag]+1, mod)==NOTOK)
1731 goto bad;
1732 } else if (pr_obj(0, pe, (char **) (*parm + p->pe_ucode),
1733 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1734 goto bad;
1735 }
1736 break;
1737
1738 case SOBJECT:
1739 if (p->pe_ucode > 0) {
1740 if (*parm == NULLCP)
1741 return inpm(mod, p);
1742 nparm = *parm + p->pe_ucode;
1743 if (pr_obj(1, pe, &nparm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1744 goto bad;
1745 } else if (pr_obj(1, pe, parm, mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1746 goto bad;
1747 break;
1748
1749 case OBJECT:
1750 if (pr_obj(1, pe, (char **) (*parm + p->pe_ucode),
1751 mod->md_dtab[p->pe_tag] + 1, mod) == NOTOK)
1752 goto bad;
1753 break;
1754
1755 case SCHOICE_START:
1756 if (p->pe_ucode > 0) {
1757 if (*parm == NULLCP)
1758 return inpm(mod, p);
1759 nparm = *parm + p->pe_ucode;
1760 if (pr_choice(pe, &nparm, p, mod) == NOTOK)
1761 goto bad;
1762 } else if (pr_choice(pe, parm, p, mod) == NOTOK)
1763 goto bad;
1764 break;
1765
1766 case CHOICE_START:
1767 if (pr_choice(pe, (char **) (*parm + p->pe_ucode), p, mod) == NOTOK)
1768 goto bad;
1769 break;
1770
1771 case SEXTOBJ:
1772 if (p[1].pe_type != EXTMOD)
1773 return pepsylose (mod, p, pe, "pr_etype: missing EXTMOD");
1774 if (p->pe_ucode > 0) {
1775 if (*parm == NULLCP)
1776 return inpm(mod, p);
1777 nparm = *parm + p->pe_ucode;
1778 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1779 (char **) 0, &nparm) == NOTOK)
1780 goto bad;
1781 } else if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1782 (char **) 0, parm) == NOTOK)
1783 goto bad;
1784 break;
1785
1786 case EXTOBJ:
1787 if (p[1].pe_type != EXTMOD)
1788 return pepsylose (mod, p, pe, "pr_etype: missing EXTMOD");
1789
1790 if (dec_f(p->pe_tag, EXT2MOD(mod, (p + 1)), pe, 1|F_CI, (int *) 0,
1791 (char **) 0, (char **) (*parm + p->pe_ucode)) == NOTOK)
1792 goto bad;
1793 break;
1794
1795 case INTEGER:
1796 if (pe != NULLPE) {
1797 DLOG (psap_log, LLOG_DEBUG, ("pr_etype:integer %d", prim2num(pe)));
1798
1799 if (((*(integer *)(*parm + p->pe_ucode)) = prim2num(pe)) == NOTOK &&
1800 pe->pe_errno != PE_ERR_NONE)
1801 return pepsylose (mod, p, pe, "pr_etype:bad integer %s",
1802 pe_error(pe->pe_errno));
1803 }
1804 break;
1805
1806#ifdef PEPSY_REALS
1807 case REALTYPE:
1808 if (pe != NULLPE) {
1809 DLOG (psap_log, LLOG_DEBUG, ("pr_etype:Real %g", prim2real(pe)));
1810
1811 if (((*(double *) (*parm + p->pe_ucode)) = prim2real(pe))
1812 == NOTOK && pe->pe_errno != PE_ERR_NONE)
1813 return pepsylose (mod, p, pe, "pr_etype:bad real %s",
1814 pe_error(pe->pe_errno));
1815 }
1816 break;
1817
1818#endif
1819
1820 case BOOLEAN:
1821 if (pe != NULLPE) {
1822 int i;
1823
1824 DLOG(psap_log, LLOG_DEBUG, ("pr_etype:boolean %d", prim2flag(pe)));
1825
1826 if ((i = prim2flag (pe)) == NOTOK)
1827 return pepsylose (mod, p, pe, "pr_etype:bad integer %s",
1828 pe_error(pe->pe_errno));
1829 (*(char *) (*parm + p->pe_ucode)) = i & 0xff;
1830 }
1831 break;
1832
1833 case T_NULL:
1834 break;
1835
1836 case ANY:
1837 if (pe != NULLPE) {
1838 (*(PE *) (*parm + p->pe_ucode) = pe)->pe_refcnt++;
1839 if (pe->pe_errno != PE_ERR_NONE)
1840 return pepsylose (mod, p, pe, "pr_etype:bad ANY %s",
1841 pe_error(pe->pe_errno));
1842 }
1843 break;
1844
1845 case SANY:
1846 if (pe != NULLPE) {
1847 (*(PE *) (parm + p->pe_ucode) = pe) -> pe_refcnt++;
1848 if (pe->pe_errno != PE_ERR_NONE)
1849 return pepsylose (mod, p, pe, "pr_etype:bad ANY %s",
1850 pe_error(pe->pe_errno));
1851 }
1852 break;
1853
1854 case SOCTETSTRING:
1855 if (pe != NULLPE) {
1856 if ((*((struct qbuf **) (parm + p->pe_ucode))
1857 = prim2qb(pe)) == (struct qbuf *) NULL
1858 && pe->pe_errno != PE_ERR_NONE)
1859 return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
1860 pe_error(pe->pe_errno));
1861 }
1862 break;
1863
1864 case OCTETSTRING:
1865 if (pe != NULLPE) {
1866 if ((*((struct qbuf **) (*parm + p->pe_ucode))
1867 = prim2qb(pe)) == (struct qbuf *) NULL
1868 && pe->pe_errno != PE_ERR_NONE)
1869 return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
1870 pe_error(pe->pe_errno));
1871 }
1872 break;
1873
1874 case T_STRING:
1875 if ((*((char **) (*parm + p->pe_ucode)) = prim2str(pe, &cnt))
1876 == NULLCP && pe->pe_errno != PE_ERR_NONE)
1877 return pepsylose (mod, p, pe, "pr_type:bad octet string %s",
1878 pe_error(pe->pe_errno));
1879 /* undocumented feature of prim2str that it adds a NULL char
1880 * to the end of the string
1881 */
1882 break;
1883
1884 case OCTET_PTR:
1885 if (p[1].pe_type != OCTET_LEN)
1886 return pepsylose (mod, &p[1], NULLPE,"pr_etype: missing OCTET_PTR");
1887 if ((*((char **) (*parm + p->pe_ucode)) =
1888 prim2str(pe, (int *)(*parm + (p + 1)->pe_ucode)))
1889 == NULLCP && pe->pe_errno != PE_ERR_NONE)
1890 return pepsylose (mod, p, pe, "pr_etype:bad octet string %s",
1891 pe_error(pe->pe_errno));
1892 break;
1893
1894 case BITSTR_PTR:
1895 if (p[1].pe_type != BITSTR_LEN)
1896 return pepsylose (mod, &p[1], NULLPE,
1897 "pr_etype: missing BITSTR_PTR");
1898 pe = prim2bit(pe);
1899 if ((*((char **) (*parm + p->pe_ucode)) =
1900 bitstr2strb(pe, (int *)(*parm + (p + 1)->pe_ucode)))
1901 == NULLCP && pe->pe_errno != PE_ERR_NONE)
1902 return pepsylose (mod, p, pe, "pr_etype:bad bit string %s",
1903 pe_error(pe->pe_errno));
1904 break;
1905
1906 case SBITSTRING:
1907 if (pe != NULLPE) {
1908 if (((*(PE *) (parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
1909 return pepsylose (mod, p, pe, "pr_etype:out of memory");
1910 }
1911 break;
1912
1913 case BITSTRING:
1914 if (pe != NULLPE) {
1915 if ((*((PE *) (*parm + p->pe_ucode)) = prim2bit(pe_cpy(pe))) == NULLPE)
1916 return pepsylose (mod, p, pe, "pr_etype:out of memory");
1917 }
1918 break;
1919
1920 case SOBJID:
1921 if ((*(OID *) (parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID)
1922 return pepsylose (mod, p, pe, "pr_etype:OID: out of memory");
1923 break;
1924
1925 case OBJID:
1926 if ((*(OID *) (*parm + p->pe_ucode) = oid_cpy(prim2oid(pe))) == NULLOID)
1927 return pepsylose (mod, p, pe, "en_etype:OID: out of memory");
1928 break;
1929
1930 case FN_CALL:
1931 if ((FN_PTR(mod, p))(parm, pe) == NOTOK)
1932 return pepsylose (mod, p, NULLPE, "pr_etype:FN_CALL:call failed");
1933 break;
1934
1935 default:
1936 return pepsylose(mod, p, pe,
1937 "pr_etype: %d not implemented", p->pe_type);
1938 }
1939
1940 return (OK);
1941bad:
1942 return (NOTOK);
1943}
1944
1945
1946/*
1947 * determine if the given field is present in the data This is simple
1948 * if the field is a simple type with an obvious tag but in the case
1949 * of an object or a CHOICE type the tag is not obvious. If the
1950 * object is a CHOICE there are more than one possible tag that could
1951 * match and in this case we must try to match each one of them.
1952 */
1953static PE
1954setpresent(head, p, mod)
1955PE head;
1956tpe *p;
1957modtyp *mod;
1958{
1959 PE pe;
1960 modtyp *nmod;
1961
1962 while (!ISDTYPE(p) && p->pe_type != PE_END) {
1963 p++;
1964 }
1965 if (!ISDTYPE(p) || p->pe_type == PE_END)
1966 return (NULLPE);
1967
1968 switch (p->pe_type) {
1969 case EXTOBJ:
1970 case SEXTOBJ:
1971 /* Needs to be changed for optional and default */
1972 nmod = EXT2MOD(mod, (p + 1));
1973 return (setpresent(head, p = nmod->md_dtab[p->pe_tag] + 1, nmod));
1974
1975 case OBJECT:
1976 case SOBJECT:
1977 /* Needs to be changed for optional and default */
1978 return (setpresent(head, p = mod->md_dtab[p->pe_tag] + 1, mod));
1979
1980 case SCHOICE_START:
1981 case CHOICE_START:
1982 for (p++; p && p->pe_type != PE_END; p = NEXT_TPE(p)) {
1983 if (!ISDTYPE(p))
1984 continue;
1985 if ((pe = setpresent(head, p, mod)))
1986 return (pe);
1987 }
1988 return (NULLPE);
1989
1990 default:
1991 return (set_find(head, CLASS(p), TAG(p)));
1992 }
1993}
1994
1995/*
1996 * set the default value to that value in the structure
1997 */
1998static int
1999setdval(typ, dflt, parm, mod)
2000tpe *typ, *dflt;
2001char **parm;
2002modtyp *mod;
2003{
2004 char *p;
2005 integer i;
2006 int no; /* number of octets */
2007 char *nparm;
2008
2009again:
2010 switch (typ->pe_type) {
2011 case MEMALLOC:
2012 if (*parm)
2013 break; /* already allocated */
2014
2015 if ((*(parm) = (char *) calloc(1, (unsigned ) typ->pe_tag)) == NULL) {
2016 (void) pepsylose (mod, typ, NULLPE,
2017 "setdval:calloc failed on %d", typ->pe_tag);
2018 return NOTOK;
2019 }
2020 /* fall through and do the same stuff as for ETAG */
2021
2022 case ETAG:
2023 typ++;
2024 goto again;
2025
2026 case INTEGER:
2027 *(integer *) (*parm + typ->pe_ucode) = IVAL(mod, dflt);
2028 break;
2029
2030#ifdef PEPSY_REALS
2031 case REALTYPE:
2032 *(double *) (*parm + typ->pe_ucode) = RVAL(mod, dflt);
2033 break;
2034#endif
2035
2036 case BOOLEAN:
2037 *(char *) (*parm + typ->pe_ucode) = IVAL(mod, dflt);
2038 break;
2039
2040 case T_NULL:
2041 /* Only one value */
2042 break;
2043
2044 case SBITSTRING:
2045 *(PE *) (parm + typ->pe_ucode) = strb2bitstr(PVAL(mod, dflt), (int )IVAL(mod, dflt), 0, 0);
2046 break;
2047
2048 case BITSTRING:
2049 *(PE *) (*parm + typ->pe_ucode) =
2050 strb2bitstr(PVAL(mod, dflt), (int )IVAL(mod, dflt), 0, 0);
2051 break;
2052
2053 case SOCTETSTRING:
2054 *(struct qbuf **) (parm + typ->pe_ucode) = str2qb(PVAL(mod, dflt),
2055 (int )IVAL(mod, dflt), 1);
2056 break;
2057
2058 case OCTETSTRING:
2059 *(struct qbuf **) (*parm + typ->pe_ucode) =
2060 str2qb(PVAL(mod, dflt), (int )IVAL(mod, dflt), 1);
2061 break;
2062
2063 case T_STRING:
2064 *(char **) (*parm + typ->pe_ucode) = strdup(PVAL(mod, dflt));
2065 break;
2066
2067 case OCTET_PTR:
2068 if (typ[1].pe_type != OCTET_LEN)
2069 return pepsylose (mod, typ, NULLPE, "setdval:missing OCTET_LEN");
2070 i = IVAL(mod, dflt);
2071 p = smalloc((int )i + 1);
2072 bcopy(PVAL(mod, dflt), p, (int )i);
2073 p[i] = '\0';
2074 *(char **) (*parm + typ->pe_ucode) = p;
2075 *(int *) (*parm + (typ + 1)->pe_ucode) = i;
2076 break;
2077
2078 case BITSTR_PTR:
2079 if (typ[1].pe_type != BITSTR_LEN)
2080 return pepsylose (mod, typ, NULLPE, "setdval:missing BITSTR_LEN");
2081 i = IVAL(mod, dflt);
2082 no = (i + 7)/8; /* round up */
2083 p = smalloc(no + 1);
2084 bcopy(PVAL(mod, dflt), p, no);
2085 p[no] = '\0';
2086 *(char **) (*parm + typ->pe_ucode) = p;
2087 *(int *) (*parm + (typ + 1)->pe_ucode) = i;
2088 break;
2089
2090 case OBJECT:
2091 if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt,
2092 (char **) (*parm + typ->pe_ucode), mod) == NOTOK)
2093 return NOTOK;
2094 break;
2095
2096 case SOBJECT:
2097 if (typ->pe_ucode > 0) {
2098 nparm = *parm + typ->pe_ucode;
2099 if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, &nparm, mod) == NOTOK)
2100 return NOTOK;
2101 } else if (setdval(mod->md_dtab[typ->pe_tag] + 1, dflt, parm, mod) == NOTOK)
2102 return NOTOK;
2103 break;
2104
2105 case IMP_OBJ:
2106 typ++;
2107
2108 case ANY:
2109 case SANY:
2110 case SEXTOBJ:
2111 case EXTOBJ:
2112 case OBJID:
2113 case SOBJID:
2114 case SEQ_START:
2115 case SET_START:
2116 case -1: /* Just use the pepy method of null
2117 * pointers */
2118 /*
2119 * This is the posy/pepy hack way of doing things at the
2120 * moment
2121 */
2122 *(char **) (*parm + typ->pe_ucode) = NULL;
2123 break;
2124
2125 case FN_CALL:
2126 if ((FN_PTR(mod, typ))(parm, NULLPE) == NOTOK)
2127 return pepsylose (mod, typ, NULLPE,
2128 "setdval:FN_CALL:call failed");
2129 break;
2130
2131 default:
2132 /*
2133 * dmp_tpe("setdval: type not implemented", typ, mod); - need
2134 * mod
2135 */
2136 (void) pepsylose(mod, typ, NULLPE,
2137 "setdval: %d not implemented", typ->pe_type);
2138 return NOTOK;
2139 }
2140 return OK;
2141}
2142/*
2143 * fix up the allocation of memory. We have allocated memory for an
2144 * optional object that is not present. ISODE routines get upset if
2145 * this is present because it then believes the object is present and
2146 * tries to process it ...
2147 */
2148static int
2149fix_mem(parm, p)
2150char **parm;
2151tpe *p;
2152{
2153 if (p->pe_type != SOBJECT || p[-1].pe_type != MEMALLOC
2154 || p[1].pe_type != PE_END)
2155 SLOG (psap_log, LLOG_EXCEPTIONS, NULLCP, ("fix_mem:inconsistency"));
2156 if (*parm)
2157 free(*parm);
2158 *parm = NULL;
2159}
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.