shell32/tests: Add verification of FOLDERID_ProgramFilesX64 and FOLDERID_ProgramFiles...
[wine] / dlls / wldap32 / search.c
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_searchA     (WLDAP32.@)
43  *
44  * See ldap_searchW.
45  */
46 ULONG CDECL ldap_searchA( WLDAP32_LDAP *ld, PCHAR base, ULONG scope, PCHAR filter,
47     PCHAR attrs[], ULONG attrsonly )
48 {
49     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
50 #ifdef HAVE_LDAP
51     WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
52
53     ret = WLDAP32_LDAP_NO_MEMORY;
54
55     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x)\n", ld, debugstr_a(base),
56            scope, debugstr_a(filter), attrs, attrsonly );
57
58     if (!ld) return ~0u;
59
60     if (base) {
61         baseW = strAtoW( base );
62         if (!baseW) goto exit;
63     }
64     if (filter) {
65         filterW = strAtoW( filter );
66         if (!filterW) goto exit;
67     }
68     if (attrs) {
69         attrsW = strarrayAtoW( attrs );
70         if (!attrsW) goto exit;
71     }
72
73     ret = ldap_searchW( ld, baseW, scope, filterW, attrsW, attrsonly );
74
75 exit:
76     strfreeW( baseW );
77     strfreeW( filterW );
78     strarrayfreeW( attrsW );
79
80 #endif
81     return ret;
82 }
83
84 /***********************************************************************
85  *      ldap_searchW     (WLDAP32.@)
86  *
87  * Search a directory tree (asynchronous operation).
88  *
89  * PARAMS
90  *  ld        [I] Pointer to an LDAP context.
91  *  base      [I] Starting point for the search.
92  *  scope     [I] Search scope. One of LDAP_SCOPE_BASE,
93  *                LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
94  *  filter    [I] Search filter.
95  *  attrs     [I] Attributes to return.
96  *  attrsonly [I] Return no values, only attributes.
97  *
98  * RETURNS
99  *  Success: Message ID of the search operation.
100  *  Failure: ~0u
101  *
102  * NOTES
103  *  Call ldap_result with the message ID to get the result of
104  *  the operation. Cancel the operation by calling ldap_abandon
105  *  with the message ID.
106  */
107 ULONG CDECL ldap_searchW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope, PWCHAR filter,
108     PWCHAR attrs[], ULONG attrsonly )
109 {
110     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
111 #ifdef HAVE_LDAP
112     char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
113     int msg;
114
115     ret = WLDAP32_LDAP_NO_MEMORY;
116
117     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x)\n", ld, debugstr_w(base),
118            scope, debugstr_w(filter), attrs, attrsonly );
119
120     if (!ld) return ~0u;
121
122     if (base) {
123         baseU = strWtoU( base );
124         if (!baseU) goto exit;
125     }
126     if (filter) {
127         filterU = strWtoU( filter );
128         if (!filterU) goto exit;
129     }
130     if (attrs) {
131         attrsU = strarrayWtoU( attrs );
132         if (!attrsU) goto exit;
133     }
134
135     ret = ldap_search_ext( ld, baseU, scope, filterU, attrsU, attrsonly,
136                            NULL, NULL, NULL, 0, &msg );
137
138     if (ret == LDAP_SUCCESS)
139         ret = msg;
140     else
141         ret = ~0u;
142
143 exit:
144     strfreeU( baseU );
145     strfreeU( filterU );
146     strarrayfreeU( attrsU );
147
148 #endif
149     return ret;
150 }
151
152 /***********************************************************************
153  *      ldap_search_extA     (WLDAP32.@)
154  *
155  * See ldap_search_extW.
156  */
157 ULONG CDECL ldap_search_extA( WLDAP32_LDAP *ld, PCHAR base, ULONG scope,
158     PCHAR filter, PCHAR attrs[], ULONG attrsonly, PLDAPControlA *serverctrls,
159     PLDAPControlA *clientctrls, ULONG timelimit, ULONG sizelimit, ULONG *message )
160 {
161     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
162 #ifdef HAVE_LDAP
163     WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
164     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
165
166     ret = WLDAP32_LDAP_NO_MEMORY;
167
168     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, 0x%08x, 0x%08x, %p)\n",
169            ld, debugstr_a(base), scope, debugstr_a(filter), attrs, attrsonly,
170            serverctrls, clientctrls, timelimit, sizelimit, message );
171
172     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
173
174     if (base) {
175         baseW = strAtoW( base );
176         if (!baseW) goto exit;
177     }
178     if (filter)
179     {
180         filterW = strAtoW( filter );
181         if (!filterW) goto exit;
182     }
183     if (attrs) {
184         attrsW = strarrayAtoW( attrs );
185         if (!attrsW) goto exit;
186     }
187     if (serverctrls) {
188         serverctrlsW = controlarrayAtoW( serverctrls );
189         if (!serverctrlsW) goto exit;
190     }
191     if (clientctrls) {
192         clientctrlsW = controlarrayAtoW( clientctrls );
193         if (!clientctrlsW) goto exit;
194     }
195
196     ret = ldap_search_extW( ld, baseW, scope, filterW, attrsW, attrsonly,
197                             serverctrlsW, clientctrlsW, timelimit, sizelimit, message );
198
199 exit:
200     strfreeW( baseW );
201     strfreeW( filterW );
202     strarrayfreeW( attrsW );
203     controlarrayfreeW( serverctrlsW );
204     controlarrayfreeW( clientctrlsW );
205
206 #endif
207     return ret;
208 }
209
210 /***********************************************************************
211  *      ldap_search_extW     (WLDAP32.@)
212  *
213  * Search a directory tree (asynchronous operation).
214  *
215  * PARAMS
216  *  ld          [I] Pointer to an LDAP context.
217  *  base        [I] Starting point for the search.
218  *  scope       [I] Search scope. One of LDAP_SCOPE_BASE,
219  *                  LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
220  *  filter      [I] Search filter.
221  *  attrs       [I] Attributes to return.
222  *  attrsonly   [I] Return no values, only attributes.
223  *  serverctrls [I] Array of LDAP server controls.
224  *  clientctrls [I] Array of LDAP client controls.
225  *  timelimit   [I] Timeout in seconds.
226  *  sizelimit   [I] Maximum number of entries to return. Zero means unlimited.
227  *  message     [O] Message ID of the search operation.
228  *
229  * RETURNS
230  *  Success: LDAP_SUCCESS
231  *  Failure: An LDAP error code.
232  *
233  * NOTES
234  *  Call ldap_result with the message ID to get the result of
235  *  the operation. Cancel the operation by calling ldap_abandon
236  *  with the message ID.
237  */
238 ULONG CDECL ldap_search_extW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope,
239     PWCHAR filter, PWCHAR attrs[], ULONG attrsonly, PLDAPControlW *serverctrls,
240     PLDAPControlW *clientctrls, ULONG timelimit, ULONG sizelimit, ULONG *message )
241 {
242     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
243 #ifdef HAVE_LDAP
244     char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
245     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
246     struct timeval tv, *tvp = NULL;
247
248     ret = WLDAP32_LDAP_NO_MEMORY;
249
250     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, 0x%08x, 0x%08x, %p)\n",
251            ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
252            serverctrls, clientctrls, timelimit, sizelimit, message );
253
254     if (!ld) return ~0u;
255
256     if (base) {
257         baseU = strWtoU( base );
258         if (!baseU) goto exit;
259     }
260     if (filter) {
261         filterU = strWtoU( filter );
262         if (!filterU) goto exit;
263     }
264     if (attrs) {
265         attrsU = strarrayWtoU( attrs );
266         if (!attrsU) goto exit;
267     }
268     if (serverctrls) {
269         serverctrlsU = controlarrayWtoU( serverctrls );
270         if (!serverctrlsU) goto exit;
271     }
272     if (clientctrls) {
273         clientctrlsU = controlarrayWtoU( clientctrls );
274         if (!clientctrlsU) goto exit;
275     }
276
277     if (timelimit)
278     {
279         tv.tv_sec = timelimit;
280         tv.tv_usec = 0;
281         tvp = &tv;
282     }
283
284     ret = map_error( ldap_search_ext( ld, baseU, scope, filterU, attrsU, attrsonly,
285                                       serverctrlsU, clientctrlsU, tvp, sizelimit, (int *)message ));
286
287 exit:
288     strfreeU( baseU );
289     strfreeU( filterU );
290     strarrayfreeU( attrsU );
291     controlarrayfreeU( serverctrlsU );
292     controlarrayfreeU( clientctrlsU );
293
294 #endif
295     return ret;
296 }
297
298 /***********************************************************************
299  *      ldap_search_ext_sA     (WLDAP32.@)
300  *
301  * See ldap_search_ext_sW.
302  */
303 ULONG CDECL ldap_search_ext_sA( WLDAP32_LDAP *ld, PCHAR base, ULONG scope,
304     PCHAR filter, PCHAR attrs[], ULONG attrsonly, PLDAPControlA *serverctrls,
305     PLDAPControlA *clientctrls, struct l_timeval* timeout, ULONG sizelimit, WLDAP32_LDAPMessage **res )
306 {
307     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
308 #ifdef HAVE_LDAP
309     WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
310     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
311
312     ret = WLDAP32_LDAP_NO_MEMORY;
313
314     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, %p, 0x%08x, %p)\n",
315            ld, debugstr_a(base), scope, debugstr_a(filter), attrs, attrsonly,
316            serverctrls, clientctrls, timeout, sizelimit, res );
317
318     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
319
320     if (base) {
321         baseW = strAtoW( base );
322         if (!baseW) goto exit;
323     }
324     if (filter) {
325         filterW = strAtoW( filter );
326         if (!filterW) goto exit;
327     }
328     if (attrs) {
329         attrsW = strarrayAtoW( attrs );
330         if (!attrsW) goto exit;
331     }
332     if (serverctrls) {
333         serverctrlsW = controlarrayAtoW( serverctrls );
334         if (!serverctrlsW) goto exit;
335     }
336     if (clientctrls) {
337         clientctrlsW = controlarrayAtoW( clientctrls );
338         if (!clientctrlsW) goto exit;
339     }
340
341     ret = ldap_search_ext_sW( ld, baseW, scope, filterW, attrsW, attrsonly,
342                               serverctrlsW, clientctrlsW, timeout, sizelimit, res );
343
344 exit:
345     strfreeW( baseW );
346     strfreeW( filterW );
347     strarrayfreeW( attrsW );
348     controlarrayfreeW( serverctrlsW );
349     controlarrayfreeW( clientctrlsW );
350
351 #endif
352     return ret;
353 }
354
355 /***********************************************************************
356  *      ldap_search_ext_sW     (WLDAP32.@)
357  *
358  * Search a directory tree (synchronous operation).
359  *
360  * PARAMS
361  *  ld          [I] Pointer to an LDAP context.
362  *  base        [I] Starting point for the search.
363  *  scope       [I] Search scope. One of LDAP_SCOPE_BASE,
364  *                  LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
365  *  filter      [I] Search filter.
366  *  attrs       [I] Attributes to return.
367  *  attrsonly   [I] Return no values, only attributes.
368  *  serverctrls [I] Array of LDAP server controls.
369  *  clientctrls [I] Array of LDAP client controls.
370  *  timeout     [I] Timeout in seconds.
371  *  sizelimit   [I] Maximum number of entries to return. Zero means unlimited.
372  *  res         [O] Results of the search operation.
373  *
374  * RETURNS
375  *  Success: LDAP_SUCCESS
376  *  Failure: An LDAP error code.
377  *
378  * NOTES
379  *  Call ldap_msgfree to free the results.
380  */
381 ULONG CDECL ldap_search_ext_sW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope,
382     PWCHAR filter, PWCHAR attrs[], ULONG attrsonly, PLDAPControlW *serverctrls,
383     PLDAPControlW *clientctrls, struct l_timeval* timeout, ULONG sizelimit, WLDAP32_LDAPMessage **res )
384 {
385     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
386 #ifdef HAVE_LDAP
387     char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
388     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
389
390     ret = WLDAP32_LDAP_NO_MEMORY;
391
392     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p, %p, 0x%08x, %p)\n",
393            ld, debugstr_w(base), scope, debugstr_w(filter), attrs, attrsonly,
394            serverctrls, clientctrls, timeout, sizelimit, res );
395
396     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
397
398     if (base) {
399         baseU = strWtoU( base );
400         if (!baseU) goto exit;
401     }
402     if (filter) {
403         filterU = strWtoU( filter );
404         if (!filterU) goto exit;
405     }
406     if (attrs) {
407         attrsU = strarrayWtoU( attrs );
408         if (!attrsU) goto exit;
409     }
410     if (serverctrls) {
411         serverctrlsU = controlarrayWtoU( serverctrls );
412         if (!serverctrlsU) goto exit;
413     }
414     if (clientctrls) {
415         clientctrlsU = controlarrayWtoU( clientctrls );
416         if (!clientctrlsU) goto exit;
417     }
418
419     ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
420                                         serverctrlsU, clientctrlsU, (struct timeval *)timeout,
421                                         sizelimit, res ));
422
423 exit:
424     strfreeU( baseU );
425     strfreeU( filterU );
426     strarrayfreeU( attrsU );
427     controlarrayfreeU( serverctrlsU );
428     controlarrayfreeU( clientctrlsU );
429
430 #endif
431     return ret;
432 }
433
434 /***********************************************************************
435  *      ldap_search_sA     (WLDAP32.@)
436  *
437  * See ldap_search_sW.
438  */
439 ULONG CDECL ldap_search_sA( WLDAP32_LDAP *ld, PCHAR base, ULONG scope, PCHAR filter,
440     PCHAR attrs[], ULONG attrsonly, WLDAP32_LDAPMessage **res )
441 {
442     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
443 #ifdef HAVE_LDAP
444     WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
445
446     ret = WLDAP32_LDAP_NO_MEMORY;
447
448     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p)\n", ld, debugstr_a(base),
449            scope, debugstr_a(filter), attrs, attrsonly, res );
450
451     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
452
453     if (base) {
454         baseW = strAtoW( base );
455         if (!baseW) goto exit;
456     }
457     if (filter) {
458         filterW = strAtoW( filter );
459         if (!filterW) goto exit;
460     }
461     if (attrs) {
462         attrsW = strarrayAtoW( attrs );
463         if (!attrsW) goto exit;
464     }
465
466     ret = ldap_search_sW( ld, baseW, scope, filterW, attrsW, attrsonly, res );
467
468 exit:
469     strfreeW( baseW );
470     strfreeW( filterW );
471     strarrayfreeW( attrsW );
472
473 #endif
474     return ret;
475 }
476
477 /***********************************************************************
478  *      ldap_search_sW     (WLDAP32.@)
479  *
480  * Search a directory tree (synchronous operation).
481  *
482  * PARAMS
483  *  ld        [I] Pointer to an LDAP context.
484  *  base      [I] Starting point for the search.
485  *  scope     [I] Search scope. One of LDAP_SCOPE_BASE,
486  *                LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
487  *  filter    [I] Search filter.
488  *  attrs     [I] Attributes to return.
489  *  attrsonly [I] Return no values, only attributes.
490  *  res       [O] Results of the search operation.
491  *
492  * RETURNS
493  *  Success: LDAP_SUCCESS
494  *  Failure: An LDAP error code.
495  *
496  * NOTES
497  *  Call ldap_msgfree to free the results.
498  */
499 ULONG CDECL ldap_search_sW( WLDAP32_LDAP *ld, PWCHAR base, ULONG scope, PWCHAR filter,
500     PWCHAR attrs[], ULONG attrsonly, WLDAP32_LDAPMessage **res )
501 {
502     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
503 #ifdef HAVE_LDAP
504     char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
505
506     ret = WLDAP32_LDAP_NO_MEMORY;
507
508     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p)\n", ld, debugstr_w(base),
509            scope, debugstr_w(filter), attrs, attrsonly, res );
510
511     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
512
513     if (base) {
514         baseU = strWtoU( base );
515         if (!baseU) goto exit;
516     }
517     if (filter) {
518         filterU = strWtoU( filter );
519         if (!filterU) goto exit;
520     }
521     if (attrs) {
522         attrsU = strarrayWtoU( attrs );
523         if (!attrsU) goto exit;
524     }
525
526     ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
527                                         NULL, NULL, NULL, 0, res ));
528
529 exit:
530     strfreeU( baseU );
531     strfreeU( filterU );
532     strarrayfreeU( attrsU );
533
534 #endif
535     return ret;
536 }
537
538 /***********************************************************************
539  *      ldap_search_stA     (WLDAP32.@)
540  *
541  * See ldap_search_stW.
542  */
543 ULONG CDECL ldap_search_stA( WLDAP32_LDAP *ld, const PCHAR base, ULONG scope,
544     const PCHAR filter, PCHAR attrs[], ULONG attrsonly,
545     struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
546 {
547     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
548 #ifdef HAVE_LDAP
549     WCHAR *baseW = NULL, *filterW = NULL, **attrsW = NULL;
550
551     ret = WLDAP32_LDAP_NO_MEMORY;
552
553     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p)\n", ld,
554            debugstr_a(base), scope, debugstr_a(filter), attrs,
555            attrsonly, timeout, res );
556
557     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
558
559     if (base) {
560         baseW = strAtoW( base );
561         if (!baseW) goto exit;
562     }
563     if (filter) {
564         filterW = strAtoW( filter );
565         if (!filterW) goto exit;
566     }
567     if (attrs) {
568         attrsW = strarrayAtoW( attrs );
569         if (!attrsW) goto exit;
570     }
571
572     ret = ldap_search_stW( ld, baseW, scope, filterW, attrsW, attrsonly,
573                            timeout, res );
574
575 exit:
576     strfreeW( baseW );
577     strfreeW( filterW );
578     strarrayfreeW( attrsW );
579
580 #endif
581     return ret;
582 }
583
584 /***********************************************************************
585  *      ldap_search_stW     (WLDAP32.@)
586  *
587  * Search a directory tree (synchronous operation).
588  *
589  * PARAMS
590  *  ld        [I] Pointer to an LDAP context.
591  *  base      [I] Starting point for the search.
592  *  scope     [I] Search scope. One of LDAP_SCOPE_BASE,
593  *                LDAP_SCOPE_ONELEVEL and LDAP_SCOPE_SUBTREE.
594  *  filter    [I] Search filter.
595  *  attrs     [I] Attributes to return.
596  *  attrsonly [I] Return no values, only attributes.
597  *  timeout   [I] Timeout in seconds.
598  *  res       [O] Results of the search operation.
599  *
600  * RETURNS
601  *  Success: LDAP_SUCCESS
602  *  Failure: An LDAP error code.
603  *
604  * NOTES
605  *  Call ldap_msgfree to free the results.
606  */
607 ULONG CDECL ldap_search_stW( WLDAP32_LDAP *ld, const PWCHAR base, ULONG scope,
608     const PWCHAR filter, PWCHAR attrs[], ULONG attrsonly,
609     struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
610 {
611     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
612 #ifdef HAVE_LDAP
613     char *baseU = NULL, *filterU = NULL, **attrsU = NULL;
614
615     ret = WLDAP32_LDAP_NO_MEMORY;
616
617     TRACE( "(%p, %s, 0x%08x, %s, %p, 0x%08x, %p, %p)\n", ld,
618            debugstr_w(base), scope, debugstr_w(filter), attrs,
619            attrsonly, timeout, res );
620
621     if (!ld || !res) return WLDAP32_LDAP_PARAM_ERROR;
622
623     if (base) {
624         baseU = strWtoU( base );
625         if (!baseU) goto exit;
626     }
627     if (filter) {
628         filterU = strWtoU( filter );
629         if (!filterU) goto exit;
630     }
631     if (attrs) {
632         attrsU = strarrayWtoU( attrs );
633         if (!attrsU) goto exit;
634     }
635
636     ret = map_error( ldap_search_ext_s( ld, baseU, scope, filterU, attrsU, attrsonly,
637                                         NULL, NULL, (struct timeval *)timeout, 0, res ));
638
639 exit:
640     strfreeU( baseU );
641     strfreeU( filterU );
642     strarrayfreeU( attrsU );
643
644 #endif
645     return ret;
646 }