![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to guide.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 / dsap / common|
Return to guide.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / dsap / common |
1.1 root 1: /* guide.c - Search Guide handling */
2:
3: #ifndef lint
4: static char *rcsid = "$Header: /f/osi/dsap/common/RCS/guide.c,v 7.0 89/11/23 21:42:17 mrose Rel $";
5: #endif
6:
7: /*
8: * $Header: /f/osi/dsap/common/RCS/guide.c,v 7.0 89/11/23 21:42:17 mrose Rel $
9: *
10: *
11: * $Log: guide.c,v $
12: * Revision 7.0 89/11/23 21:42:17 mrose
13: * Release 6.0
14: *
15: */
16:
17: /*
18: * NOTICE
19: *
20: * Acquisition, use, and distribution of this module and related
21: * materials are subject to the restrictions of a license agreement.
22: * Consult the Preface in the User's Manual for the full terms of
23: * this agreement.
24: *
25: */
26:
27: /*
28: SYNTAX:
29: Guide ::= [<objectclass> '#'] <Criteria>
30: Criteria ::= CriteriaItem | CriteriaSet | '!' Criteria
31: CrtieriaSet ::= ['('] Criteria '@' CriteriaSet [')'] |
32: ['('] Criteria '|' CriteriaSet [')']
33: CriteriaItem ::= ['('] <attributetype> '$' <matchType> [')']
34: matchType ::= "EQ" | "SUBSTR" | "GE" | "LE" | "APPROX"
35:
36: EXAMPLES:
37:
38: Person # commonName $ APPROX
39: ( organization $ EQ ) @ (commonName $ SUBSTR)
40: ( organization $ EQ ) @ ((commonName $ SUBSTR) | (commonName $ EQ))
41:
42: NOTE:
43: Use of @ for "and" as '&' get filtered out earlier!!!
44: */
45:
46: /* LINTLIBRARY */
47:
48: #include "quipu/util.h"
49: #include "quipu/attrvalue.h"
50: #include "cmd_srch.h"
51:
52: static Criteria_free (arg)
53: struct Criteria *arg;
54: {
55: struct Criteria *parm = arg;
56:
57: if (parm == NULL)
58: return;
59:
60: switch (parm -> offset) {
61: case Criteria_type:
62: if (parm -> un.type)
63: free_CriteriaItem (parm -> un.type),
64: parm -> un.type = NULL;
65: break;
66:
67: case Criteria_and:
68: case Criteria_or:
69: {
70: struct and_or_set *and_or_set;
71:
72: for (and_or_set = parm -> un.and_or; and_or_set;) {
73: struct and_or_set *f_and_or_set = and_or_set -> and_or_next;
74:
75: if (and_or_set -> and_or_comp)
76: Criteria_free (and_or_set -> and_or_comp),
77: and_or_set -> and_or_comp = NULL;
78:
79: if (and_or_set)
80: free ((char *) and_or_set);
81: and_or_set = f_and_or_set;
82: }
83:
84: parm -> un.and_or = NULL;
85: }
86: break;
87:
88: case Criteria_not:
89: if (parm -> un.not)
90: Criteria_free (parm -> un.not),
91: parm -> un.not = NULL;
92: break;
93: }
94:
95: free ((char *) arg);
96: }
97:
98: static free_CriteriaItem (arg)
99: struct CriteriaItem *arg;
100: {
101: struct CriteriaItem *parm = arg;
102:
103: if (parm == NULL)
104: return;
105:
106: free ((char *) arg);
107: }
108:
109:
110: static guidefree (arg)
111: struct Guide * arg;
112: {
113: if (arg == NULL)
114: return;
115:
116: if (arg->objectClass)
117: oid_free (arg->objectClass);
118:
119: Criteria_free (arg->criteria);
120:
121: free ((char *)arg);
122: }
123:
124: static struct CriteriaItem * CriteriaItem_cpy (arg)
125: struct CriteriaItem *arg;
126: {
127: struct CriteriaItem *parm = arg;
128: struct CriteriaItem *res;
129:
130: if (parm == NULL)
131: return NULL;
132:
133: res = (struct CriteriaItem *) smalloc (sizeof(struct CriteriaItem));
134:
135: res->offset = parm->offset;
136: res->attrib = AttrT_cpy (parm->attrib);
137:
138: return (res);
139: }
140:
141:
142: static struct Criteria * Criteria_cpy (a)
143: struct Criteria * a;
144: {
145: struct Criteria *b;
146:
147: if (a == NULL)
148: return NULL;
149:
150: b = (struct Criteria *) smalloc (sizeof(struct Criteria));
151: b-> offset = a->offset;
152:
153: switch (a -> offset) {
154: case Criteria_type:
155: b->un.type = CriteriaItem_cpy (a->un.type);
156: break;
157:
158: case Criteria_and:
159: case Criteria_or:
160: {
161: struct and_or_set *and_or_set;
162: struct and_or_set *ao_res = (struct and_or_set *)NULL;
163: struct and_or_set *ao_tmp;
164:
165: ao_tmp = ao_res; /* OK lint ? */
166:
167: for (and_or_set = a -> un.and_or; and_or_set; and_or_set = and_or_set->and_or_next) {
168: struct and_or_set *tmp;
169:
170: tmp = (struct and_or_set *) smalloc (sizeof(struct and_or_set));
171: tmp->and_or_comp = Criteria_cpy(and_or_set->and_or_comp);
172: tmp->and_or_next = (struct and_or_set *)NULL;
173: if (ao_res == ((struct and_or_set *)NULL))
174: ao_res = tmp;
175: else
176: ao_tmp->and_or_next = tmp;
177: ao_tmp = tmp;
178: }
179:
180: b->un.and_or = ao_res;
181: }
182: break;
183:
184: case Criteria_not:
185: b->un.not = Criteria_cpy (a->un.not);
186: break;
187: }
188:
189: return (b);
190: }
191:
192: static struct Guide * guidecpy (a)
193: struct Guide * a;
194: {
195: struct Guide * b;
196:
197: b = (struct Guide * ) smalloc (sizeof(struct Guide));
198:
199: if (a->objectClass)
200: b->objectClass = oid_cpy (a->objectClass);
201: else
202: b->objectClass = NULLOID;
203:
204: b->criteria = Criteria_cpy (a->criteria);
205:
206: return (b);
207: }
208:
209: #define NOCHOICE 255
210:
211: static CMD_TABLE guide_tab [] = {
212: "EQ", choice_equality,
213: "SUBSTR", choice_substrings,
214: "GE", choice_greaterOrEqual,
215: "LE", choice_lessOrEqual,
216: "APPROX", choice_approximateMatch,
217: 0, NOCHOICE
218: };
219:
220: static struct CriteriaItem * CriteriaItem_parse (str)
221: char * str;
222: {
223: struct CriteriaItem * res;
224: char * ptr;
225: if ((str == NULLCP) || (*str == 0))
226: return ((struct CriteriaItem *) NULL);
227:
228: res = (struct CriteriaItem *) smalloc (sizeof(struct CriteriaItem));
229:
230: if ((ptr = index (str,'$')) == NULLCP) {
231: parse_error ("Seperator missing in CriteriaItem %s",str);
232: return ((struct CriteriaItem *) NULL);
233: }
234: *ptr-- = 0;
235: if (isspace (*ptr))
236: *ptr = 0;
237: ptr++;
238: if ((res -> attrib = AttrT_new (str)) == NULLAttrT) {
239: parse_error ("Unknown attribute type in CriteriaItem %s",str);
240: return ((struct CriteriaItem *) NULL);
241: }
242: *ptr++ = '$';
243:
244: if ((res -> offset = cmd_srch(SkipSpace(ptr),guide_tab)) == NOCHOICE) {
245: parse_error ("Unknown search type in CriteriaItem %s",ptr);
246: return ((struct CriteriaItem *) NULL);
247: }
248:
249: return (res);
250:
251: }
252:
253:
254:
255: static getop (str, ch)
256: char *str,
257: *ch;
258: {
259: int i,
260: bracket = 0;
261:
262: for (i = 0; i < strlen (str); i++) {
263: if (bracket == 0 && (str[i] == '@' || str[i] == '|')) {
264: *ch = str[i];
265: return (i);
266: }
267: if (str[i] == '(')
268: ++bracket;
269: if (str[i] == ')')
270: --bracket;
271: if (bracket < 0) {
272: parse_error ("Too many close brackets",NULLCP);
273: return (-2);
274: }
275: }
276: return (-1);
277: }
278:
279:
280: static struct Criteria * Criteria_parse (str)
281: char *str;
282: {
283: int gotit,
284: bracketed;
285: char ch,
286: och = '\0';
287: char * TidyString();
288: struct Criteria * result;
289:
290: struct and_or_set * ao = (struct and_or_set *)NULL;
291: struct and_or_set * ao_ptr;
292:
293: result = (struct Criteria *) smalloc (sizeof(struct Criteria));
294:
295: str = TidyString (str);
296:
297: /* Got a multiple-component string for parsing */
298:
299: do {
300: bracketed = FALSE;
301: if ((gotit = getop (str, &ch)) == -2)
302: return ((struct Criteria *)NULL);
303:
304: if (gotit < 0) {/* Match an open bracket. */
305: if (*str == '(')
306: if (str[strlen (str) - 1] == ')') {
307: str[strlen (str) - 1] = '\0';
308: ++str;
309: bracketed = TRUE;
310: } else {
311: parse_error ("Too many open brackets",NULLCP);
312: return ((struct Criteria *)NULL);
313: }
314:
315: if (och == '\0') {
316: if (bracketed == TRUE) {
317: gotit = 0; /* Stop 'while' loop
318: * falling */
319: continue; /* Parse the internals */
320: } else
321: break; /* Single item only */
322: } else
323: ch = och; /* Use last operation */
324: }
325: if (och == '\0')/* Remember last operation */
326: och = ch;
327: else if (och != ch) {
328: parse_error ("Can't Mix Operations.",NULLCP);
329: return ((struct Criteria *)NULL);
330: }
331: if (gotit >= 0) /* If got an op, make it null */
332: str[gotit] = '\0';
333: /* Recurse on the 'first' string */
334: ao_ptr = (struct and_or_set*) smalloc (sizeof(struct and_or_set));
335: if ((ao_ptr->and_or_comp = Criteria_parse (str)) == (struct Criteria *)NULL)
336: return ((struct Criteria *)NULL);
337:
338: ao_ptr->and_or_next = (struct and_or_set*) NULL;
339: if (ao != (struct and_or_set *)NULL)
340: ao_ptr->and_or_next = ao;
341: ao = ao_ptr;
342: str += gotit + 1;
343:
344: if (gotit >= 0) { /* Match an and symbol */
345: if (och == '@') {
346: result->offset = Criteria_and;
347: } else {/* Match an or symbol */
348: result->offset = Criteria_or;
349: }
350: }
351: result->un.and_or = ao;
352: }
353: while (gotit >= 0);
354: if (och == '\0') {
355: if (*str == '!') { /* Match a not symbol */
356: result->offset = Criteria_not;
357: if ((result->un.not = Criteria_parse (str + 1)) == (struct Criteria *)NULL)
358: return ((struct Criteria *)NULL);
359: } else {
360: result->offset = Criteria_type;
361: if ((result->un.type = CriteriaItem_parse(str)) == (struct CriteriaItem *)NULL)
362: return ((struct Criteria *)NULL);
363: }
364: }
365: return (result);
366: }
367:
368: static struct Guide * guideparse (str)
369: char *str;
370: {
371: char *ptr;
372: struct Guide * res;
373:
374: res = (struct Guide *) smalloc (sizeof (struct Guide));
375:
376: if ((ptr = index (str,'#')) != NULLCP) {
377: *ptr-- = 0;
378: if (isspace (*ptr))
379: *ptr = 0;
380: ptr++;
381: if (( res->objectClass = name2oid(str)) == NULLOID) {
382: parse_error ("Unknown class in Guide %s",str);
383: return ((struct Guide *)NULL);
384: }
385: res->objectClass = oid_cpy (res->objectClass);
386: *ptr++ = '#';
387: str = ptr;
388: }
389:
390: if ((res->criteria = Criteria_parse (SkipSpace(str))) == (struct Criteria *)NULL)
391: return ((struct Guide *)NULL);
392:
393: return (res);
394: }
395:
396:
397: static CriteriaItem_print(ps,parm,format)
398: PS ps;
399: struct CriteriaItem * parm;
400: int format;
401: {
402: char *ptr;
403:
404: if (parm == NULL)
405: return;
406:
407: if ((ptr = rcmd_srch ((int)parm->offset,guide_tab)) == NULLCP)
408: ptr = "UNKNOWN !!!";
409:
410: if (format == READOUT) {
411: ps_printf (ps,"%s on ",ptr);
412: AttrT_print (ps,parm->attrib,EDBOUT);
413: } else {
414: AttrT_print (ps,parm->attrib,format);
415: ps_printf (ps,"$%s",ptr);
416: }
417:
418:
419: }
420:
421:
422: static Criteria_print (ps,a,format)
423: PS ps;
424: struct Criteria * a;
425: int format;
426: {
427: char * sep;
428:
429: if (format == READOUT)
430: sep = " OR ";
431: else
432: sep = "|";
433:
434: if (a == NULL)
435: return;
436:
437: switch (a -> offset) {
438: case Criteria_type:
439: CriteriaItem_print (ps,a->un.type,format);
440: break;
441: case Criteria_and:
442: if (format == READOUT)
443: sep = " AND ";
444: else
445: sep = "@";
446: case Criteria_or:
447: {
448: struct and_or_set *and_or_set;
449: char * tmp = NULLCP;
450:
451: for (and_or_set = a -> un.and_or; and_or_set; and_or_set = and_or_set->and_or_next) {
452: if (tmp != NULLCP)
453: ps_print (ps,tmp);
454: ps_print (ps,"(");
455: Criteria_print(ps,and_or_set->and_or_comp,format);
456: ps_print (ps,")");
457: tmp = sep;
458: }
459: }
460: break;
461:
462: case Criteria_not:
463: if (format == READOUT)
464: ps_print (ps,"NOT ");
465: else
466: ps_print (ps,"!");
467: ps_print (ps,"(");
468: Criteria_print (ps,a->un.not,format);
469: ps_print (ps,")");
470: break;
471: }
472: }
473:
474: static guideprint (ps,a,format)
475: PS ps;
476: struct Guide * a;
477: int format;
478: {
479: if (a->objectClass) {
480: if (format == READOUT) {
481: ps_print (ps,"Class: ");
482: oidprint (ps,a->objectClass,format);
483: ps_print (ps,", search for: ");
484: } else {
485: oidprint (ps,a->objectClass,format);
486: ps_print (ps,"#");
487: }
488: }
489:
490: Criteria_print (ps,a->criteria,format);
491:
492: }
493:
494: static PE guideenc (m)
495: struct Guide * m;
496: {
497: PE ret_pe;
498:
499: (void) encode_SA_Guide (&ret_pe,0,0,NULLCP,m);
500:
501: return (ret_pe);
502: }
503:
504: static struct Guide * guidedec (pe)
505: PE pe;
506: {
507: struct Guide * m;
508:
509: if (decode_SA_Guide (pe,1,NULLIP,NULLVP,&m) == NOTOK)
510: return ((struct Guide *) NULL);
511:
512: if (decode_Criteria (m->criteria) == NOTOK)
513: return ((struct Guide *) NULL);
514:
515: return (m);
516: }
517:
518: static decode_Criteria (m)
519: struct Criteria * m;
520: {
521: int result;
522:
523: switch (m -> offset) {
524: case Criteria_type:
525: result = decode_CriteriaItem (m -> un.type);
526: break;
527:
528: case Criteria_and:
529: case Criteria_or:
530: {
531: struct and_or_set *and_or_set;
532:
533: result = OK;
534: for (and_or_set = m -> un.and_or; and_or_set;) {
535: struct and_or_set *f_and_or_set = and_or_set -> and_or_next;
536: if (decode_Criteria (and_or_set -> and_or_comp) == NOTOK)
537: result = NOTOK;
538: and_or_set = f_and_or_set;
539: }
540:
541: }
542: break;
543:
544: case Criteria_not:
545: result = decode_Criteria (m -> un.not);
546: break;
547: }
548:
549: return (result);
550: }
551:
552: static decode_CriteriaItem (m)
553: struct CriteriaItem *m;
554: {
555:
556: if (m == NULL)
557: return OK;
558:
559: return OK;
560: }
561:
562: static criteriaItem_cmp (a,b)
563: struct CriteriaItem *a,*b;
564: {
565:
566: if (a == NULL)
567: return (b==NULL ? 0 : -1);
568: if (b == NULL)
569: return (1);
570:
571: if (a->offset != b->offset)
572: return (a->offset>b->offset ? 1 : -1);
573:
574: return (AttrT_cmp (a->attrib,b->attrib));
575: }
576:
577: static criteria_cmp(a,b)
578: struct Criteria * a, *b;
579: {
580: int result;
581:
582: if (a==NULL)
583: return(b==NULL ? 0 : -1);
584: if (b==NULL)
585: return(1);
586:
587: if (a->offset != b->offset)
588: return (a->offset > b->offset ? 1 : -1);
589:
590: switch (a -> offset) {
591: case Criteria_type:
592: return (criteriaItem_cmp (a->un.type, b->un.type));
593:
594: case Criteria_and:
595: case Criteria_or:
596: {
597: struct and_or_set *a_set;
598: struct and_or_set *b_set;
599:
600: for (a_set = a->un.and_or; a_set ; a_set = a_set->and_or_next) {
601: for (b_set = b->un.and_or; b_set ; b_set = b_set->and_or_next) {
602: if ((result=criteria_cmp (a_set -> and_or_comp,b_set->and_or_comp)) == 0)
603: break;
604: }
605: if (result != 0)
606: return (1);
607: }
608: for (b_set = b->un.and_or; b_set ; b_set = b_set->and_or_next) {
609: for (a_set = a->un.and_or; a_set ; a_set = a_set->and_or_next) {
610: if ((result=criteria_cmp (a_set -> and_or_comp,b_set->and_or_comp)) == 0)
611: break;
612: }
613: if (result != 0)
614: return (-1);
615: }
616: return (0);
617:
618: }
619:
620: case Criteria_not:
621: result = criteria_cmp (a->un.not,b->un.not);
622: break;
623: }
624:
625: return (result);
626: }
627:
628: static guidecmp (a,b)
629: struct Guide *a, *b;
630: {
631: int i;
632: if (a == (struct Guide *)NULL)
633: if (b == (struct Guide *)NULL)
634: return (0);
635: else
636: return (1);
637:
638: if (b==(struct Guide *)NULL)
639: return (-1);
640:
641: if ((i=oid_cmp(a->objectClass,b->objectClass)) == 0)
642: return (criteria_cmp(a->criteria,b->criteria));
643:
644: return (i);
645: }
646:
647: guide_syntax ()
648: {
649: (void) add_attribute_syntax ("Guide",
650: (IFP) guideenc, (IFP) guidedec,
651: (IFP) guideparse,guideprint,
652: (IFP) guidecpy, guidecmp,
653: guidefree, NULLCP,
654: NULLIFP, TRUE);
655:
656: }
657:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.