![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.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 util.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / pepsy |
1.1 root 1: /* util.c */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/pepsy/RCS/util.c,v 7.1 90/07/09 14:53:23 mrose Exp $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/pepsy/RCS/util.c,v 7.1 90/07/09 14:53:23 mrose Exp $
9: *
10: *
11: * $Log: util.c,v $
12: * Revision 7.1 90/07/09 14:53:23 mrose
13: * sync
14: *
15: * Revision 7.0 90/07/01 19:54:33 mrose
16: * *** empty log message ***
17: *
18: */
19:
20: /*
21: * NOTICE
22: *
23: * Acquisition, use, and distribution of this module and related
24: * materials are subject to the restrictions of a license agreement.
25: * Consult the Preface in the User's Manual for the full terms of
26: * this agreement.
27: *
28: */
29:
30:
31: #include <stdio.h>
32: #include "psap.h"
33: #include "pepsy.h"
34: #include <varargs.h>
35: #include "tailor.h"
36:
37: #ifndef PEPYPARM
38: #define PEPYPARM char *
39: #endif
40:
41: static char *pr_petype ();
42:
43: #ifdef lint
44: int pepsylose (module, p, pe, str)
45: modtyp *module;
46: tpe *p;
47: char *str;
48: PE pe;
49: {
50: return pepsylose (type, module, pe, str);
51: }
52:
53: #else
54: int pepsylose (va_alist)
55: va_dcl
56: {
57: va_list ap;
58: int type;
59: modtyp *module;
60: tpe *p;
61: char *cp;
62: PE pe;
63: char buffer[BUFSIZ];
64:
65: va_start (ap);
66:
67: module = va_arg (ap, modtyp *);
68: p = va_arg (ap, tpe *);
69: pe = va_arg (ap, PE);
70:
71: _asprintf (buffer, NULLCP, ap);
72: (void) sprintf (PY_pepy, "%s: module %s",
73: buffer, module ? module -> md_name : "<none>");
74: if (p) {
75: cp = PY_pepy + strlen (PY_pepy);
76: (void) sprintf (cp, " %s/class=%s/id=%d",
77: pr_petype (p -> pe_type),
78: pe_classlist[p -> pe_flags & FL_CLASS],
79: p -> pe_tag);
80: }
81: if (pe) {
82: cp = PY_pepy + strlen (PY_pepy);
83: (void) sprintf (cp, " got %s/%d", pe_classlist[pe -> pe_class],
84: pe -> pe_id);
85: }
86:
87: SLOG (psap_log, LLOG_EXCEPTIONS, NULLCP, ("%s", PY_pepy));
88:
89: va_end (ap);
90: return NOTOK;
91: }
92: #endif
93:
94: /*
95: * Useful little routines
96: */
97: /*
98: * print out the message and if the arguement is greater than 0
99: * terminate
100: */
101: ferr(n, mesg)
102: char *mesg;
103: {
104: (void) printf(mesg);
105: if (n > 0)
106: exit(n);
107: }
108: /*
109: * print out the message and number and if the arguement is greater
110: * than 0 terminate
111: */
112: ferrd(n, mesg, d)
113: char *mesg;
114: int d;
115: {
116: (void) printf(mesg, d);
117: if (n > 0)
118: exit(n);
119: }
120:
121: /*
122: * 0 = Encoding table, 1 = Decoding table, 2 = Printing table
123: */
124: #define TYP_ENC 0
125: #define TYP_DEC 1
126: #define TYP_PRINT 2
127: #define TYP_LAST 2
128:
129: dmp_tpe(s, p, mod)
130: char *s;
131: modtyp *mod; /* Module it is from */
132: tpe *p;
133: {
134: int typ, i, j;
135: tpe **par, **prev;
136: char *name;
137:
138: (void) printf("%s: (%s)", s, mod->md_name);
139: /*
140: * Calculate what table it is in - we assume they are in order of
141: * increasing address
142: */
143:
144: par = NULL;
145: for (typ = 0; typ <= TYP_LAST; typ++) {
146: switch (typ) {
147: case TYP_ENC:
148: if (mod->md_etab != NULL && mod->md_etab[0] < p) {
149: par = mod->md_etab;
150: name = "Encoding:";
151: }
152: break;
153:
154: case TYP_DEC:
155: if (mod->md_dtab != NULL && mod->md_dtab[0] < p) {
156: par = mod->md_dtab;
157: name = "Decoding:";
158: }
159: break;
160:
161: case TYP_PRINT:
162: if (mod->md_ptab != NULL && mod->md_ptab[0] < (ptpe *) p) {
163: (ptpe **) par = mod->md_ptab;
164: name = "Printing:";
165: }
166: break;
167:
168: default:
169: (void) pepsylose (mod, p, NULLPE, "dmp_tpe:typ = %d internal error\n",
170: typ);
171: return;
172: }
173: }
174: if (par == NULL) {
175: (void) printf("can't find entry 0x%x\n", p);
176: return;
177: }
178: prev = par;
179: for (i = mod->md_nentries; i > 0; i--) {
180: if (*par > p)
181: break;
182: par++;
183: }
184: if (par == prev)
185: (void) pepsylose (mod, p, NULLPE,
186: "dmp_tpe:par == prev == 0x%x internal error\n", (int) par);
187: par--;
188: j = p - *par;
189:
190: (void) printf("%s type %d + %d ", name, par - prev, j);
191: pr_entry(p);
192: }
193: #define NENTRY(x) ((sizeof (x)/sizeof (x[0])))
194: /*
195: * Print out a tpe entry
196: */
197: static char *ntypes[] = { "PE_START", "PE_END", "illegal 1", "illegal 2",
198: "XOBJECT", "illegal 4", "illegal 5", "UCODE", "MALLOC", "SCTRL", "CH_ACT",},
199:
200: *otypes[] = { "ANY", "INTEGER", "BOOLEAN", "OBJECT",
201: "BITSTRING", "OCTETSTRING", "SET_START", "SEQ_START", "SEQOF_START",
202: "SETOF_START", "CHOICE_START", "UNKNOWN", "T_NULL", "T_OID",
203: "ETAG", "IMP_OBJ",};
204:
205: static char *pr_petype (type)
206: int type;
207: {
208: static char nbuf[30];
209:
210: if (type >= PE_START && type < NENTRY(ntypes) - 1)
211: return ntypes[type + 1];
212: else if (type >= TYPE_DATA && type < NENTRY(otypes) + TYPE_DATA)
213: return otypes[type - TYPE_DATA];
214: (void) sprintf (nbuf, "%d", type);
215: return nbuf;
216: }
217:
218: pr_entry(p)
219: tpe *p;
220: {
221: printf ("%s, ", pr_petype (p -> pe_type));
222: (void) printf("%d, %d, %d}\n", p->pe_ucode, p->pe_tag, p->pe_flags);
223: }
224:
225: p_pr_entry(p)
226: ptpe *p;
227: {
228: if (p->pe_type >= PE_START && p->pe_type < NENTRY(ntypes) - 1)
229: (void) printf("{%s, ", ntypes[p->pe_type + 1]);
230: else if (p->pe_type >= TYPE_DATA && p->pe_type < NENTRY(otypes) + TYPE_DATA)
231: (void) printf("{%s, ", otypes[p->pe_type - TYPE_DATA]);
232: else
233: (void) printf("{%d, ", p->pe_type);
234:
235: (void) printf("%d, %d, %d}\n", p->pe_ucode, p->pe_tag, p->pe_flags);
236: }
237:
238:
239: #if 0
240: pr_pe(pe)
241: PE pe;
242: {
243: print_pe(pe, 1);
244: }
245: #endif
246: /*
247: * null function for what evr purposes
248: */
249: f_null()
250: {
251: }
252:
253: /*
254: * compare a given number of bits pointed to by the two character
255: * pointers return 0 if they are the same non zero otherwise
256: */
257: bitscmp(p1, p2, len)
258: register char *p1, *p2;
259: int len;
260: {
261: register int i;
262: register unsigned int mask;
263:
264: if (len >= 8 && bcmp(p1, p2, len / 8))
265: return (1);
266:
267: if (len % 8 == 0)
268: return (0);
269: /* Check those last few bits */
270: i = len / 8;
271: mask = (0xff00 >> len % 8) & 0xff;
272: if ((p1[i] & mask) != (p2[i] & mask))
273: return (1);
274:
275: return (0);
276: }
277:
278: #define MIN(a, b) (a < b ? a : b)
279: /*
280: * compare an octet string and a qb and return 0 if they are the same
281: * and non zero otherwise
282: */
283: ostrcmp(p, len, qb)
284: register char *p;
285: register int len;
286: register struct qbuf *qb;
287: {
288: register struct qbuf *qp;
289:
290: if (len < 0 || qb == NULL || p == NULL)
291: return (1);
292: qp = qb;
293: do {
294: if (qp->qb_data != NULL) {
295: if (qp->qb_len < 0)
296: ferrd(1, "ostrcmp:qb_len %d < 0", qp->qb_len);
297: if (qp->qb_len > len)
298: return (1);
299: if (bcmp(qp->qb_data, p, qp->qb_len))
300: return (1);
301: if ((len -= qp->qb_len) == 0)
302: return (0);
303: p += qp->qb_len;
304: }
305: qp = qp->qb_forw;
306: } while (qp != qb);
307:
308: return (len);
309: }
310:
311: /*
312: * Is data present for the optional item? 1 for yes 0 for no
313: */
314: hasdata(parm, p, mod, popt, optcnt)
315: PEPYPARM parm;
316: tpe *p;
317: modtyp *mod; /* Module it is from */
318: int *popt, optcnt;
319: {
320: switch (p->pe_type) {
321: case INTEGER:
322: case REALTYPE:
323: case BOOLEAN:
324: case T_NULL:
325: if (DEFAULT(p)) {
326: /* Default's don't have bit map */
327: if (p[1].pe_type == DFLT_B && same(p, p + 1, parm, mod)
328: || p[-1].pe_type == DFLT_F && same(p, p - 1, parm, mod))
329: goto next;
330: break;
331: }
332: if (!TESTBIT(*popt, optcnt++))
333: goto next; /* Missing so skip */
334: break;
335:
336: case ETAG:
337: if (!hasdata(parm, p + 1, mod, popt, optcnt))
338: goto next;
339: break;
340:
341: case IMP_OBJ:
342: if (p[1].pe_type == SOBJECT && parm == NULL
343: || *((char **) (parm + p[1].pe_ucode)) == NULL)
344: goto next;
345: break;
346:
347: default:
348: if (*((char **) (parm + p->pe_ucode)) == NULL)
349: goto next;
350: break;
351: }
352: return (1);
353:
354: next:
355: return (0);
356: }
357:
358: /*
359: * determine if the default value is the same as the value in the
360: * structure and if so return greater than zero (meaning don't encode this
361: * item). On error return NOTOK
362: */
363: same(typ, dflt, parm, mod)
364: tpe *typ, *dflt;
365: char *parm;
366: modtyp *mod; /* Module it is from */
367: {
368: int val;
369: char *p1;
370: PE pe;
371: struct qbuf *qb;
372:
373: switch (typ->pe_type) {
374: case INTEGER:
375: val = IVAL(mod, dflt) == *(int *) (parm + typ->pe_ucode);
376: break;
377:
378: #ifdef PEPSY_REALS
379: case REALTYPE:
380: val = RVAL(mod, dflt) == *(double *) (parm + typ->pe_ucode);
381: break;
382: #endif
383:
384: case BOOLEAN:
385: val = IVAL(mod, dflt) == *(char *) (parm + typ->pe_ucode);
386: break;
387:
388: case T_NULL:
389: val = 1; /* Only one value */
390: break;
391:
392: case SBITSTRING:
393: if ((pe = (PE) parm) == NULL) {
394: val = 1;
395: break;
396: }
397: goto bstring;
398:
399: case BITSTRING:
400: if ((pe = *(PE *) (parm + typ->pe_ucode)) == NULL) {
401: val = 1;
402: break;
403: }
404: bstring:
405: if ((p1 = bitstr2strb(pe, &val)) == NULL) {
406: (void) pepsylose (mod, typ, pe, "same:bad bitstring\n");
407: return (NOTOK);
408: /* Should really abort encoding here but how can we comunicate this
409: * to the routine that calls us?
410: */
411: }
412: if (val != IVAL(mod, dflt) || bitscmp(PVAL(mod, dflt), p1, val))
413: val = 0;
414: else
415: val = 1;
416: free(p1);
417: break;
418:
419: case SOCTETSTRING:
420: if ((qb = (struct qbuf *) parm) == NULL) {
421: val = 1;
422: break;
423: }
424: goto ostring;
425:
426: case OCTETSTRING:
427: if ((qb = *(struct qbuf **) (parm + typ->pe_ucode)) == NULL) {
428: val = 1;
429: break;
430: }
431: ostring:
432: if (ostrcmp(PVAL(mod, dflt), IVAL(mod, dflt), qb))
433: val = 0;
434: else
435: val = 1;
436: break;
437:
438: case OBJECT:
439: if (*(char **) (parm + typ->pe_ucode) == NULL) {
440: val = 1; /* to conform with pepy's way of
441: * doing default */
442: break;
443: }
444: val = same(mod->md_etab[typ->pe_tag] + 1, dflt,
445: *(char **) (parm + typ->pe_ucode), mod);
446: break;
447:
448: case SOBJECT:
449: if ((char *) parm == NULL) {
450: val = 1; /* to conform with pepy's way of
451: * doing default */
452: break;
453: }
454: val = same(mod->md_etab[typ->pe_tag] + 1, dflt, parm, mod);
455: break;
456:
457: case IMP_OBJ:
458: typ++; /* fall through */
459:
460: case ANY:
461: case SANY:
462: case SEXTOBJ:
463: case EXTOBJ:
464: case OBJID:
465: case SOBJID:
466: case SEQ_START:
467: case SET_START:
468: case -1: /* Just use the pepy method of null
469: * pointers */
470: /*
471: * This is the posy/pepy hack way of doing things at the
472: * moment
473: */
474: val = *(char **) (parm + typ->pe_ucode) == NULL;
475: break;
476:
477: default:
478: (void) pepsylose (mod, typ, NULLPE, "same: %d not implemented\n",
479: typ->pe_type);
480: return (NOTOK);
481: }
482:
483: return (val);
484: }
485:
486: /*
487: * Calculate the next tpe entry in the sequence. Count a sequence as
488: * one element
489: */
490: tpe *
491: next_tpe(p)
492: tpe *p;
493: {
494: int level;
495:
496:
497:
498: level = 0;
499: if (p->pe_type == PE_END) {
500: (void) pepsylose (NULLMODTYP, p, NULLPE,
501: "next_tpe:internal error: unexpected PE_END found");
502: return (p);
503: }
504: do {
505: again:
506: switch (p->pe_type) {
507: case SEQ_START:
508: case SEQOF_START:
509: case SET_START:
510: case SETOF_START:
511: case CHOICE_START:
512: level++;
513: break;
514:
515: case UCODE:
516: case MALLOC:
517: case SCTRL:
518: case CH_ACT:
519: case INTEGER:
520: case REALTYPE:
521: case BOOLEAN:
522: case SANY:
523: case ANY:
524: case T_NULL:
525: case OBJECT:
526: case SOBJECT:
527: case BITSTRING:
528: case SBITSTRING:
529: case OCTETSTRING:
530: case SOCTETSTRING:
531: case OBJID:
532: case SOBJID:
533: case OPTL:
534: case EXTMOD:
535: case DFLT_B:
536: break;
537:
538: case IMP_OBJ:
539: case ETAG:
540: case EXTOBJ:
541: case SEXTOBJ:
542: case DFLT_F:
543: p++;
544: goto again;
545:
546: case PE_END:
547: level--;
548: break;
549:
550: default:
551: ferrd(1, "next_tpe: unknown type %d\n", p->pe_type);
552: }
553: p++;
554: } while (level > 0 || p->pe_type == DFLT_B);
555:
556: return (p);
557: }
558:
559: /*
560: * Is there a match at for this tag and class pair. Return 1 if yes 0
561: * if no We will search through contained objects and through choices
562: */
563: ismatch(p, mod, cl, tag)
564: tpe *p;
565: modtyp *mod; /* Module it is from */
566: unsigned int cl, tag;
567: {
568: while (!ISDTYPE(p))
569: p++;
570:
571: switch (p->pe_type) {
572: case SOBJECT:
573: case OBJECT:
574: /* Needs to be changed for optional and default */
575: return (ismatch(p = mod->md_dtab[p->pe_tag] + 1, mod, cl, tag));
576:
577: case SEXTOBJ:
578: case EXTOBJ:
579: if (p[1].pe_type != EXTMOD) {
580: dmp_tpe("ismatch: missing EXTMOD", p, mod);
581: ferr(1, "ismatch:internal error\n");
582: }
583: return (ismatch(EXT2MOD(mod, (p + 1))->md_dtab[p->pe_tag] + 1,
584: EXT2MOD(mod, (p + 1)), cl, tag));
585:
586: case CHOICE_START:
587: for (p++; p->pe_type != PE_END; p = next_tpe (p)) {
588: if (!ISDTYPE(p))
589: continue;
590: if (ismatch(p, mod, cl, tag))
591: return (1);
592: }
593: return (0);
594:
595: case SANY:
596: return (1);
597:
598: case ANY:
599: if (STAG(p) == -1)
600: return (1);
601: /* else fall through - not sure if this is needed */
602:
603: default:
604: return (tag == TAG(p) && cl == CLASS(p));
605: }
606: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.