![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to algo.py 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 / doc / ufn|
Return to algo.py CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / isode-beta / doc / ufn |
1.1 root 1:
2:
3: PurportedName ::= SEQUENCE OF String
4: -- simplication, as attribute types can optionally be
5: -- specified
6:
7: -- Each element of the Purported Name is a string
8: -- which has been parsed from the BNF
9:
10: Attribute ::= SEQUENCE {
11: type OBJECT IDENTIFIER,
12: value ANY }
13:
14: RDN ::= Attribute -- simplification, as can be multi-value
15:
16: DN ::= SEQUENCE OF RDN
17:
18: Environment ::= SEQUENCE OF DN
19:
20:
21: EnvironmentList ::= SEQUENCE OF SEQUENCE {
22: lower-bound INTEGER,
23: upper-bound INTEGER,
24: environment Environment }
25:
26:
27: friendlyMatch(p: PurportedName; el: EnvironmentList): SET OF DN
28: {
29: -- Find correct environment
30:
31: IF length(el) == 0 THEN return(NULL);
32:
33: IF length(p) <= head(el).upper-bound
34: && length(p) >= head(el).lower-bound THEN
35: return envMatch (p, head(el).environment);
36: ELSE
37: return(friendlyMatch(p, tail(el));
38: }
39:
40:
41: envMatch(p: PurportedName; e: Environment): SET OF DN
42: {
43: -- Check elements of environment
44: -- in the defined order
45:
46: matches: SET OF DN;
47:
48: IF length(e) == 0 THEN return(NULL);
49:
50: matches = purportedMatch(head(el).DN, p)
51: IF matches != NULL THEN
52: return(matches);
53: ELSE
54: return(envMatch(p, tail(e));
55: }
56:
57:
58: purportedMatch(base: DN; p: PurportedName): SET OF DN
59: {
60: s: String = head(p);
61: matches: SET OF DN = NULL;
62:
63: IF length(p) == 1 THEN
64: IF length(base) == 0 THEN
65: IF (matches = rootSearch(s)) != NULL THEN
66: return(matches);
67: ELSE return(leafSearch(base, s, FALSE);
68: ELSE IF length(base) == 1 THEN
69: IF (matches = intSearch(base, s)) != NULL THEN
70: return(matches);
71: ELSE return(leafSearch(base, s, FALSE);
72: ELSE
73: IF (matches = leafSearch(base, s, TRUE)) != NULL THEN
74: return(matches);
75: ELSE return(intsearch(base, s);
76:
77:
78: IF length(base) == 0 THEN
79: FOR x IN rootSearch(s) DO
80: matches += (purportedMatch(x, tail(p));
81: ELSE
82: FOR x IN intSearch(base, s) DO
83: matches += (purportedMatch(x, tail(p));
84: return(matches);
85: }
86:
87:
88: -- General. Might need to tighten the filter for short strings,
89: -- in order to stop being flooded. Alternatively, this could be
90: -- done if the loose search hists a size limit
91:
92: rootSearch(s: String): SET OF DN
93: {
94: IF length == 2 THEN
95: return(search(NULL, FALSE, s, {CountryName,
96: FriendlyCountryName, OrganizationName},
97: {exact}, {Country, Organisation}));
98: ELSE
99: return(search(NULL, FALSE, s, {OrganizationName,
100: FriendlyCountryName}, {substring, approx},
101: {Country, Organisation}));
102: }
103:
104:
105: intSearch( base: DN; s: String)
106: {
107: IF present(base, OrgUnitName) THEN
108: return(search(base, FALSE, s, {OrgUnitName},
109: {substring, approx}, {OrgUnit}));
110: ELSE IF present(base, OrganisationName) THEN
111: return(search(base, FALSE, {OrgUnitName,
112: LocalityName}, {substring, approx},
113: {Organization, OrgUnit, Locality}));
114: ELSE IF present(base, LocalityName) THEN
115: return(search(base, FALSE, s, {OrganisationName},
116: {substring, approx}, {Locality});
117: ELSE
118: return(search(base, false, s, {OrganisationName,
119: LocalityName}, {substring, approx},
120: {Organisation, Locality}));
121: }
122:
123:
124: present(d: DN; t: AttributeType): BOOLEAN
125: {
126: FOR x IN d DO
127: IF x.type == t THEN return(TRUE);
128: return(FALSE);
129: }
130:
131: leafSearch(base: DN; s: String; subtree: BOOLEAN)
132: {
133: return(search(base, subtree, s, {CommonName, Surname,
134: UserId}, {substring, approx}));
135: }
136:
137:
138: search(base: DN; subtrees: BOOLEAN; s: string;
139: alist SET OF AttributeType; matchtypes SET OF MatchType
140: objectClasses SET OF ObjectClass OPTIONAL): SET OF DN
141: {
142: -- mapped onto Directory Search, with OR conjunction
143: -- of filter items
144:
145: return dNSelect (s, search-results, alist);
146: }
147:
148: read(base: DN; alist SET OF AttributeType): SET OF Attribute;
149: {
150: -- mapped onto Directory Read
151: -- Types repeated to deal with multiple values
152: -- This would be implemented by returning selected info
153: -- with the search operation
154: }
155:
156: dNSelect(s: String; dlist SET OF DN; alist: SET OF AttributeType): SET OF DN
157: {
158: exact, good: SET OF DN;
159:
160: FOR x IN dlist DO
161: IF last(DN).Value == s THEN
162: exact += x;
163: ELSE IF FOR y IN read(x, alist) DO
164: IF y.value == s THEN
165: good += x;
166:
167:
168: IF exact != NULL THEN return(exact);
169: IF good != NULL THEN return(good);
170: return(userQuery(dlist));
171: }
172:
173:
174: userQuery(dlist SET OF DN): SET OF DN
175: {
176: -- pass back up for manual checking
177: -- user can strip all matches to force progres....
178: }
179:
180:
181: head() -- return first element of list
182: tail() -- return list with first element removed
183: length() -- return size of list
184: last() -- return last element of list
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.