1 /*
2 * WLDAP32 - LDAP support for Wine
3 *
4 * Copyright 2005 Hans Leidekker
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22
23 #include "wine/port.h"
24 #include "wine/debug.h"
25
26 #include <stdarg.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winnls.h"
31
32 #ifdef HAVE_LDAP_H
33 #include <ldap.h>
34 #endif
35
36 #include "winldap_private.h"
37 #include "wldap32.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
40
41 /***********************************************************************
42 * ldap_compareA (WLDAP32.@)
43 *
44 * See ldap_compareW.
45 */
46 ULONG CDECL ldap_compareA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value )
47 {
48 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
49 #ifdef HAVE_LDAP
50 WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
51
52 ret = ~0u;
53
54 TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
55 debugstr_a(value) );
56
57 if (!ld || !attr) return ~0u;
58
59 if (dn) {
60 dnW = strAtoW( dn );
61 if (!dnW) goto exit;
62 }
63
64 attrW = strAtoW( attr );
65 if (!attrW) goto exit;
66
67 if (value) {
68 valueW = strAtoW( value );
69 if (!valueW) goto exit;
70 }
71
72 ret = ldap_compareW( ld, dnW, attrW, valueW );
73
74 exit:
75 strfreeW( dnW );
76 strfreeW( attrW );
77 strfreeW( valueW );
78
79 #endif
80 return ret;
81 }
82
83 /***********************************************************************
84 * ldap_compareW (WLDAP32.@)
85 *
86 * Check if an attribute has a certain value (asynchronous operation).
87 *
88 * PARAMS
89 * ld [I] Pointer to an LDAP context.
90 * dn [I] DN of entry to compare value for.
91 * attr [I] Attribute to compare value for.
92 * value [I] Value to compare.
93 *
94 * RETURNS
95 * Success: Message ID of the compare operation.
96 * Failure: An LDAP error code.
97 */
98 ULONG CDECL ldap_compareW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value )
99 {
100 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
101 #ifdef HAVE_LDAP
102 char *dnU = NULL, *attrU = NULL, *valueU = NULL;
103 struct berval val = { 0, NULL };
104 int msg;
105
106 ret = ~0u;
107
108 TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
109 debugstr_w(value) );
110
111 if (!ld || !attr) return ~0u;
112
113 if (dn) {
114 dnU = strWtoU( dn );
115 if (!dnU) goto exit;
116 }
117
118 attrU = strWtoU( attr );
119 if (!attrU) goto exit;
120
121 if (value) {
122 valueU = strWtoU( value );
123 if (!valueU) goto exit;
124
125 val.bv_len = strlen( valueU );
126 val.bv_val = valueU;
127 }
128
129 ret = ldap_compare_ext( ld, dn ? dnU : "", attrU, &val, NULL, NULL, &msg );
130
131 if (ret == LDAP_SUCCESS)
132 ret = msg;
133 else
134 ret = ~0u;
135
136 exit:
137 strfreeU( dnU );
138 strfreeU( attrU );
139 strfreeU( valueU );
140
141 #endif
142 return ret;
143 }
144
145 /***********************************************************************
146 * ldap_compare_extA (WLDAP32.@)
147 *
148 * See ldap_compare_extW.
149 */
150 ULONG CDECL ldap_compare_extA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value,
151 struct WLDAP32_berval *data, PLDAPControlA *serverctrls, PLDAPControlA *clientctrls,
152 ULONG *message )
153 {
154 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
155 #ifdef HAVE_LDAP
156 WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
157 LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
158
159 ret = WLDAP32_LDAP_NO_MEMORY;
160
161 TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
162 debugstr_a(attr), debugstr_a(value), data, serverctrls,
163 clientctrls, message );
164
165 if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
166
167 if (dn) {
168 dnW = strAtoW( dn );
169 if (!dnW) goto exit;
170 }
171 if (attr) {
172 attrW = strAtoW( attr );
173 if (!attrW) goto exit;
174 }
175 if (value) {
176 valueW = strAtoW( value );
177 if (!valueW) goto exit;
178 }
179 if (serverctrls) {
180 serverctrlsW = controlarrayAtoW( serverctrls );
181 if (!serverctrlsW) goto exit;
182 }
183 if (clientctrls) {
184 clientctrlsW = controlarrayAtoW( clientctrls );
185 if (!clientctrlsW) goto exit;
186 }
187
188 ret = ldap_compare_extW( ld, dnW, attrW, valueW, data,
189 serverctrlsW, clientctrlsW, message );
190
191 exit:
192 strfreeW( dnW );
193 strfreeW( attrW );
194 strfreeW( valueW );
195 controlarrayfreeW( serverctrlsW );
196 controlarrayfreeW( clientctrlsW );
197
198 #endif
199 return ret;
200 }
201
202 /***********************************************************************
203 * ldap_compare_extW (WLDAP32.@)
204 *
205 * Check if an attribute has a certain value (asynchronous operation).
206 *
207 * PARAMS
208 * ld [I] Pointer to an LDAP context.
209 * dn [I] DN of entry to compare value for.
210 * attr [I] Attribute to compare value for.
211 * value [I] string encoded value to compare.
212 * data [I] berval encoded value to compare.
213 * serverctrls [I] Array of LDAP server controls.
214 * clientctrls [I] Array of LDAP client controls.
215 * message [O] Message ID of the compare operation.
216 *
217 * RETURNS
218 * Success: LDAP_SUCCESS
219 * Failure: An LDAP error code.
220 *
221 * NOTES
222 * Set value to compare strings or data to compare binary values. If
223 * both are non-NULL, data will be used. The serverctrls and clientctrls
224 * parameters are optional and should be set to NULL if not used.
225 */
226 ULONG CDECL ldap_compare_extW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value,
227 struct WLDAP32_berval *data, PLDAPControlW *serverctrls, PLDAPControlW *clientctrls,
228 ULONG *message )
229 {
230 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
231 #ifdef HAVE_LDAP
232 char *dnU = NULL, *attrU = NULL, *valueU = NULL;
233 LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
234 struct berval val = { 0, NULL };
235
236 ret = WLDAP32_LDAP_NO_MEMORY;
237
238 TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
239 debugstr_w(attr), debugstr_w(value), data, serverctrls,
240 clientctrls, message );
241
242 if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
243 if (!attr) return WLDAP32_LDAP_NO_MEMORY;
244
245 if (dn) {
246 dnU = strWtoU( dn );
247 if (!dnU) goto exit;
248 }
249
250 attrU = strWtoU( attr );
251 if (!attrU) goto exit;
252
253 if (!data) {
254 if (value) {
255 valueU = strWtoU( value );
256 if (!valueU) goto exit;
257
258 val.bv_len = strlen( valueU );
259 val.bv_val = valueU;
260 }
261 }
262 if (serverctrls) {
263 serverctrlsU = controlarrayWtoU( serverctrls );
264 if (!serverctrlsU) goto exit;
265 }
266 if (clientctrls) {
267 clientctrlsU = controlarrayWtoU( clientctrls );
268 if (!clientctrlsU) goto exit;
269 }
270
271 ret = map_error( ldap_compare_ext( ld, dn ? dnU : "", attrU, data ? (struct berval *)data : &val,
272 serverctrlsU, clientctrlsU, (int *)message ));
273
274 exit:
275 strfreeU( dnU );
276 strfreeU( attrU );
277 strfreeU( valueU );
278 controlarrayfreeU( serverctrlsU );
279 controlarrayfreeU( clientctrlsU );
280
281 #endif
282 return ret;
283 }
284
285 /***********************************************************************
286 * ldap_compare_ext_sA (WLDAP32.@)
287 *
288 * See ldap_compare_ext_sW.
289 */
290 ULONG CDECL ldap_compare_ext_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value,
291 struct WLDAP32_berval *data, PLDAPControlA *serverctrls, PLDAPControlA *clientctrls )
292 {
293 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
294 #ifdef HAVE_LDAP
295 WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
296 LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
297
298 ret = WLDAP32_LDAP_NO_MEMORY;
299
300 TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_a(dn),
301 debugstr_a(attr), debugstr_a(value), data, serverctrls,
302 clientctrls );
303
304 if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
305
306 if (dn) {
307 dnW = strAtoW( dn );
308 if (!dnW) goto exit;
309 }
310 if (attr) {
311 attrW = strAtoW( attr );
312 if (!attrW) goto exit;
313 }
314 if (value) {
315 valueW = strAtoW( value );
316 if (!valueW) goto exit;
317 }
318 if (serverctrls) {
319 serverctrlsW = controlarrayAtoW( serverctrls );
320 if (!serverctrlsW) goto exit;
321 }
322 if (clientctrls) {
323 clientctrlsW = controlarrayAtoW( clientctrls );
324 if (!clientctrlsW) goto exit;
325 }
326
327 ret = ldap_compare_ext_sW( ld, dnW, attrW, valueW, data, serverctrlsW,
328 clientctrlsW );
329
330 exit:
331 strfreeW( dnW );
332 strfreeW( attrW );
333 strfreeW( valueW );
334 controlarrayfreeW( serverctrlsW );
335 controlarrayfreeW( clientctrlsW );
336
337 #endif
338 return ret;
339 }
340
341 /***********************************************************************
342 * ldap_compare_ext_sW (WLDAP32.@)
343 *
344 * Check if an attribute has a certain value (synchronous operation).
345 *
346 * PARAMS
347 * ld [I] Pointer to an LDAP context.
348 * dn [I] DN of entry to compare value for.
349 * attr [I] Attribute to compare value for.
350 * value [I] string encoded value to compare.
351 * data [I] berval encoded value to compare.
352 * serverctrls [I] Array of LDAP server controls.
353 * clientctrls [I] Array of LDAP client controls.
354 *
355 * RETURNS
356 * Success: LDAP_SUCCESS
357 * Failure: An LDAP error code.
358 *
359 * NOTES
360 * Set value to compare strings or data to compare binary values. If
361 * both are non-NULL, data will be used. The serverctrls and clientctrls
362 * parameters are optional and should be set to NULL if not used.
363 */
364 ULONG CDECL ldap_compare_ext_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value,
365 struct WLDAP32_berval *data, PLDAPControlW *serverctrls, PLDAPControlW *clientctrls )
366 {
367 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
368 #ifdef HAVE_LDAP
369 char *dnU = NULL, *attrU = NULL, *valueU = NULL;
370 LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
371 struct berval val = { 0, NULL };
372
373 ret = WLDAP32_LDAP_NO_MEMORY;
374
375 TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_w(dn),
376 debugstr_w(attr), debugstr_w(value), data, serverctrls,
377 clientctrls );
378
379 if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
380
381 if (dn) {
382 dnU = strWtoU( dn );
383 if (!dnU) goto exit;
384 }
385 if (attr) {
386 attrU = strWtoU( attr );
387 if (!attrU) goto exit;
388 }
389 if (!data) {
390 if (value) {
391 valueU = strWtoU( value );
392 if (!valueU) goto exit;
393
394 val.bv_len = strlen( valueU );
395 val.bv_val = valueU;
396 }
397 }
398 if (serverctrls) {
399 serverctrlsU = controlarrayWtoU( serverctrls );
400 if (!serverctrlsU) goto exit;
401 }
402 if (clientctrls) {
403 clientctrlsU = controlarrayWtoU( clientctrls );
404 if (!clientctrlsU) goto exit;
405 }
406
407 ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "",
408 data ? (struct berval *)data : &val,
409 serverctrlsU, clientctrlsU ));
410
411 exit:
412 strfreeU( dnU );
413 strfreeU( attrU );
414 strfreeU( valueU );
415 controlarrayfreeU( serverctrlsU );
416 controlarrayfreeU( clientctrlsU );
417
418 #endif
419 return ret;
420 }
421
422 /***********************************************************************
423 * ldap_compare_sA (WLDAP32.@)
424 *
425 * See ldap_compare_sW.
426 */
427 ULONG CDECL ldap_compare_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value )
428 {
429 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
430 #ifdef HAVE_LDAP
431 WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
432
433 ret = WLDAP32_LDAP_NO_MEMORY;
434
435 TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
436 debugstr_a(value) );
437
438 if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
439
440 if (dn) {
441 dnW = strAtoW( dn );
442 if (!dnW) goto exit;
443 }
444 if (attr) {
445 attrW = strAtoW( attr );
446 if (!attrW) goto exit;
447 }
448 if (value) {
449 valueW = strAtoW( value );
450 if (!valueW) goto exit;
451 }
452
453 ret = ldap_compare_sW( ld, dnW, attrW, valueW );
454
455 exit:
456 strfreeW( dnW );
457 strfreeW( attrW );
458 strfreeW( valueW );
459
460 #endif
461 return ret;
462 }
463
464 /***********************************************************************
465 * ldap_compare_sW (WLDAP32.@)
466 *
467 * Check if an attribute has a certain value (synchronous operation).
468 *
469 * PARAMS
470 * ld [I] Pointer to an LDAP context.
471 * dn [I] DN of entry to compare value for.
472 * attr [I] Attribute to compare value for.
473 * value [I] Value to compare.
474 *
475 * RETURNS
476 * Success: LDAP_SUCCESS
477 * Failure: An LDAP error code.
478 */
479 ULONG CDECL ldap_compare_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value )
480 {
481 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
482 #ifdef HAVE_LDAP
483 char *dnU = NULL, *attrU = NULL, *valueU = NULL;
484 struct berval val = { 0, NULL };
485
486 ret = WLDAP32_LDAP_NO_MEMORY;
487
488 TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
489 debugstr_w(value) );
490
491 if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
492
493 if (dn) {
494 dnU = strWtoU( dn );
495 if (!dnU) goto exit;
496 }
497 if (attr) {
498 attrU = strWtoU( attr );
499 if (!attrU) goto exit;
500 }
501 if (value) {
502 valueU = strWtoU( value );
503 if (!valueU) goto exit;
504
505 val.bv_len = strlen( valueU );
506 val.bv_val = valueU;
507 }
508
509 ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "", &val, NULL, NULL ));
510
511 exit:
512 strfreeU( dnU );
513 strfreeU( attrU );
514 strfreeU( valueU );
515
516 #endif
517 return ret;
518 }
519
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.