1 |
|
2 |
|
3 | var assert = require('assert');
|
4 |
|
5 | var asn1 = require('asn1');
|
6 |
|
7 | var parents = require('ldap-filter');
|
8 |
|
9 | var Protocol = require('../protocol');
|
10 |
|
11 | var Filter = require('./filter');
|
12 | var AndFilter = require('./and_filter');
|
13 | var ApproximateFilter = require('./approx_filter');
|
14 | var EqualityFilter = require('./equality_filter');
|
15 | var ExtensibleFilter = require('./ext_filter');
|
16 | var GreaterThanEqualsFilter = require('./ge_filter');
|
17 | var LessThanEqualsFilter = require('./le_filter');
|
18 | var NotFilter = require('./not_filter');
|
19 | var OrFilter = require('./or_filter');
|
20 | var PresenceFilter = require('./presence_filter');
|
21 | var SubstringFilter = require('./substr_filter');
|
22 |
|
23 |
|
24 |
|
25 |
|
26 |
|
27 | var BerReader = asn1.BerReader;
|
28 |
|
29 |
|
30 |
|
31 |
|
32 |
|
33 |
|
34 |
|
35 |
|
36 |
|
37 |
|
38 |
|
39 |
|
40 |
|
41 |
|
42 |
|
43 |
|
44 |
|
45 |
|
46 |
|
47 |
|
48 |
|
49 |
|
50 |
|
51 |
|
52 |
|
53 |
|
54 |
|
55 |
|
56 |
|
57 |
|
58 |
|
59 |
|
60 |
|
61 |
|
62 |
|
63 |
|
64 |
|
65 | function _parse(ber) {
|
66 | assert.ok(ber);
|
67 |
|
68 | function parseSet(f) {
|
69 | var end = ber.offset + ber.length;
|
70 | while (ber.offset < end)
|
71 | f.addFilter(_parse(ber));
|
72 | }
|
73 |
|
74 | var f;
|
75 |
|
76 | var type = ber.readSequence();
|
77 | switch (type) {
|
78 |
|
79 | case Protocol.FILTER_AND:
|
80 | f = new AndFilter();
|
81 | parseSet(f);
|
82 | break;
|
83 |
|
84 | case Protocol.FILTER_APPROX:
|
85 | f = new ApproximateFilter();
|
86 | f.parse(ber);
|
87 | break;
|
88 |
|
89 | case Protocol.FILTER_EQUALITY:
|
90 | f = new EqualityFilter();
|
91 | f.parse(ber);
|
92 | return f;
|
93 |
|
94 | case Protocol.FILTER_EXT:
|
95 | f = new ExtensibleFilter();
|
96 | f.parse(ber);
|
97 | return f;
|
98 |
|
99 | case Protocol.FILTER_GE:
|
100 | f = new GreaterThanEqualsFilter();
|
101 | f.parse(ber);
|
102 | return f;
|
103 |
|
104 | case Protocol.FILTER_LE:
|
105 | f = new LessThanEqualsFilter();
|
106 | f.parse(ber);
|
107 | return f;
|
108 |
|
109 | case Protocol.FILTER_NOT:
|
110 | var _f = _parse(ber);
|
111 | f = new NotFilter({
|
112 | filter: _f
|
113 | });
|
114 | break;
|
115 |
|
116 | case Protocol.FILTER_OR:
|
117 | f = new OrFilter();
|
118 | parseSet(f);
|
119 | break;
|
120 |
|
121 | case Protocol.FILTER_PRESENT:
|
122 | f = new PresenceFilter();
|
123 | f.parse(ber);
|
124 | break;
|
125 |
|
126 | case Protocol.FILTER_SUBSTRINGS:
|
127 | f = new SubstringFilter();
|
128 | f.parse(ber);
|
129 | break;
|
130 |
|
131 | default:
|
132 | throw new Error('Invalid search filter type: 0x' + type.toString(16));
|
133 | }
|
134 |
|
135 |
|
136 | assert.ok(f);
|
137 | return f;
|
138 | }
|
139 |
|
140 |
|
141 | function cloneFilter(input) {
|
142 | var child;
|
143 | if (input.type === 'and' || input.type === 'or') {
|
144 | child = input.filters.map(cloneFilter);
|
145 | } else if (input.type === 'not') {
|
146 | child = cloneFilter(input.filter);
|
147 | }
|
148 | switch (input.type) {
|
149 | case 'and':
|
150 | return new AndFilter({filters: child});
|
151 | case 'or':
|
152 | return new OrFilter({filters: child});
|
153 | case 'not':
|
154 | return new NotFilter({filter: child});
|
155 | case 'equal':
|
156 | return new EqualityFilter(input);
|
157 | case 'substring':
|
158 | return new SubstringFilter(input);
|
159 | case 'ge':
|
160 | return new GreaterThanEqualsFilter(input);
|
161 | case 'le':
|
162 | return new LessThanEqualsFilter(input);
|
163 | case 'present':
|
164 | return new PresenceFilter(input);
|
165 | case 'approx':
|
166 | return new ApproximateFilter(input);
|
167 | case 'ext':
|
168 | return new ExtensibleFilter(input);
|
169 | default:
|
170 | throw new Error('invalid filter type:' + input.type);
|
171 | }
|
172 | }
|
173 |
|
174 |
|
175 | function parseString(str) {
|
176 | var generic = parents.parse(str);
|
177 |
|
178 |
|
179 | return cloneFilter(generic);
|
180 | }
|
181 |
|
182 |
|
183 |
|
184 |
|
185 | module.exports = {
|
186 | parse: function (ber) {
|
187 | if (!ber || !(ber instanceof BerReader))
|
188 | throw new TypeError('ber (BerReader) required');
|
189 |
|
190 | return _parse(ber);
|
191 | },
|
192 |
|
193 | parseString: parseString,
|
194 |
|
195 | isFilter: Filter.isFilter,
|
196 |
|
197 | AndFilter: AndFilter,
|
198 | ApproximateFilter: ApproximateFilter,
|
199 | EqualityFilter: EqualityFilter,
|
200 | ExtensibleFilter: ExtensibleFilter,
|
201 | GreaterThanEqualsFilter: GreaterThanEqualsFilter,
|
202 | LessThanEqualsFilter: LessThanEqualsFilter,
|
203 | NotFilter: NotFilter,
|
204 | OrFilter: OrFilter,
|
205 | PresenceFilter: PresenceFilter,
|
206 | SubstringFilter: SubstringFilter
|
207 | };
|