![[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.