[WLDAP32] Sync with Wine Staging 4.18. CORE-16441
[reactos.git] / dll / win32 / wldap32 / init.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 #include "wine/port.h"
23
24 #include <stdio.h>
25 #include <stdarg.h>
26 #ifdef HAVE_LDAP_H
27 #include <ldap.h>
28 #endif
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winnls.h"
33 #include "wine/winternl.h"
34
35 #include "winldap_private.h"
36 #include "wldap32.h"
37 #include "wine/debug.h"
38
39 #ifdef HAVE_LDAP
40 /* Should eventually be determined by the algorithm documented on MSDN. */
41 static const WCHAR defaulthost[] = { 'l','o','c','a','l','h','o','s','t',0 };
42
43 /* Split a space separated string of hostnames into a string array */
44 static char **split_hostnames( const char *hostnames )
45 {
46 char **res, *str, *p, *q;
47 unsigned int i = 0;
48
49 str = strdupU( hostnames );
50 if (!str) return NULL;
51
52 p = str;
53 while (isspace( *p )) p++;
54 if (*p) i++;
55
56 while (*p)
57 {
58 if (isspace( *p ))
59 {
60 while (isspace( *p )) p++;
61 if (*p) i++;
62 }
63 p++;
64 }
65
66 if (!(res = heap_alloc( (i + 1) * sizeof(char *) )))
67 {
68 heap_free( str );
69 return NULL;
70 }
71
72 p = str;
73 while (isspace( *p )) p++;
74
75 q = p;
76 i = 0;
77
78 while (*p)
79 {
80 if (p[1] != '\0')
81 {
82 if (isspace( *p ))
83 {
84 *p = '\0'; p++;
85 res[i] = strdupU( q );
86 if (!res[i]) goto oom;
87 i++;
88
89 while (isspace( *p )) p++;
90 q = p;
91 }
92 }
93 else
94 {
95 res[i] = strdupU( q );
96 if (!res[i]) goto oom;
97 i++;
98 }
99 p++;
100 }
101 res[i] = NULL;
102
103 heap_free( str );
104 return res;
105
106 oom:
107 while (i > 0) strfreeU( res[--i] );
108
109 heap_free( res );
110 heap_free( str );
111
112 return NULL;
113 }
114
115 /* Determine if a URL starts with a known LDAP scheme */
116 static BOOL has_ldap_scheme( char *url )
117 {
118 return !_strnicmp( url, "ldap://", 7 ) ||
119 !_strnicmp( url, "ldaps://", 8 ) ||
120 !_strnicmp( url, "ldapi://", 8 ) ||
121 !_strnicmp( url, "cldap://", 8 );
122 }
123
124 /* Flatten an array of hostnames into a space separated string of URLs.
125 * Prepend a given scheme and append a given port number to each hostname
126 * if necessary.
127 */
128 static char *join_hostnames( const char *scheme, char **hostnames, ULONG portnumber )
129 {
130 char *res, *p, *q, **v;
131 unsigned int i = 0, size = 0;
132 static const char sep[] = " ", fmt[] = ":%d";
133 char port[7];
134
135 sprintf( port, fmt, portnumber );
136
137 for (v = hostnames; *v; v++)
138 {
139 if (!has_ldap_scheme( *v ))
140 {
141 size += strlen( scheme );
142 q = *v;
143 }
144 else
145 /* skip past colon in scheme prefix */
146 q = strchr( *v, '/' );
147
148 size += strlen( *v );
149
150 if (!strchr( q, ':' ))
151 size += strlen( port );
152
153 i++;
154 }
155
156 size += (i - 1) * strlen( sep );
157 if (!(res = heap_alloc( size + 1 ))) return NULL;
158
159 p = res;
160 for (v = hostnames; *v; v++)
161 {
162 if (v != hostnames)
163 {
164 strcpy( p, sep );
165 p += strlen( sep );
166 }
167
168 if (!has_ldap_scheme( *v ))
169 {
170 strcpy( p, scheme );
171 p += strlen( scheme );
172 q = *v;
173 }
174 else
175 /* skip past colon in scheme prefix */
176 q = strchr( *v, '/' );
177
178 strcpy( p, *v );
179 p += strlen( *v );
180
181 if (!strchr( q, ':' ))
182 {
183 strcpy( p, port );
184 p += strlen( port );
185 }
186 }
187 return res;
188 }
189
190 static char *urlify_hostnames( const char *scheme, char *hostnames, ULONG port )
191 {
192 char *url = NULL, **strarray;
193
194 strarray = split_hostnames( hostnames );
195 if (strarray)
196 url = join_hostnames( scheme, strarray, port );
197 else
198 return NULL;
199
200 strarrayfreeU( strarray );
201 return url;
202 }
203 #endif
204
205 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
206
207 #ifdef HAVE_LDAP
208 static LDAP *create_context( const char *url )
209 {
210 LDAP *ld;
211 int version = LDAP_VERSION3;
212 if (ldap_initialize( &ld, url ) != LDAP_SUCCESS) return NULL;
213 ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
214 return ld;
215 }
216 #endif
217
218 /***********************************************************************
219 * cldap_openA (WLDAP32.@)
220 *
221 * See cldap_openW.
222 */
223 WLDAP32_LDAP * CDECL cldap_openA( PCHAR hostname, ULONG portnumber )
224 {
225 #ifdef HAVE_LDAP
226 WLDAP32_LDAP *ld = NULL;
227 WCHAR *hostnameW = NULL;
228
229 TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
230
231 if (hostname) {
232 hostnameW = strAtoW( hostname );
233 if (!hostnameW) goto exit;
234 }
235
236 ld = cldap_openW( hostnameW, portnumber );
237
238 exit:
239 strfreeW( hostnameW );
240 return ld;
241
242 #else
243 return NULL;
244 #endif
245 }
246
247 /***********************************************************************
248 * cldap_openW (WLDAP32.@)
249 *
250 * Initialize an LDAP context and create a UDP connection.
251 *
252 * PARAMS
253 * hostname [I] Name of the host to connect to.
254 * portnumber [I] Port number to use.
255 *
256 * RETURNS
257 * Success: Pointer to an LDAP context.
258 * Failure: NULL
259 *
260 * NOTES
261 * The hostname string can be a space separated string of hostnames,
262 * in which case the LDAP runtime will try to connect to the hosts
263 * in order, until a connection can be made. A hostname may have a
264 * trailing port number (separated from the hostname by a ':'), which
265 * will take precedence over the port number supplied as a parameter
266 * to this function.
267 */
268 WLDAP32_LDAP * CDECL cldap_openW( PWCHAR hostname, ULONG portnumber )
269 {
270 #ifdef HAVE_LDAP
271 LDAP *ld = NULL;
272 char *hostnameU = NULL, *url = NULL;
273
274 TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
275
276 if (hostname) {
277 hostnameU = strWtoU( hostname );
278 if (!hostnameU) goto exit;
279 }
280 else {
281 hostnameU = strWtoU( defaulthost );
282 if (!hostnameU) goto exit;
283 }
284
285 url = urlify_hostnames( "cldap://", hostnameU, portnumber );
286 if (!url) goto exit;
287
288 ld = create_context( url );
289
290 exit:
291 strfreeU( hostnameU );
292 strfreeU( url );
293 return ld;
294
295 #else
296 return NULL;
297 #endif
298 }
299
300 /***********************************************************************
301 * ldap_connect (WLDAP32.@)
302 *
303 * Connect to an LDAP server.
304 *
305 * PARAMS
306 * ld [I] Pointer to an LDAP context.
307 * timeout [I] Pointer to an l_timeval structure specifying the
308 * timeout in seconds.
309 *
310 * RETURNS
311 * Success: LDAP_SUCCESS
312 * Failure: An LDAP error code.
313 *
314 * NOTES
315 * The timeout parameter may be NULL in which case a default timeout
316 * value will be used.
317 */
318 ULONG CDECL ldap_connect( WLDAP32_LDAP *ld, struct l_timeval *timeout )
319 {
320 TRACE( "(%p, %p)\n", ld, timeout );
321
322 if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
323 return WLDAP32_LDAP_SUCCESS; /* FIXME: do something, e.g. ping the host */
324 }
325
326 /***********************************************************************
327 * ldap_initA (WLDAP32.@)
328 *
329 * See ldap_initW.
330 */
331 WLDAP32_LDAP * CDECL ldap_initA( const PCHAR hostname, ULONG portnumber )
332 {
333 #ifdef HAVE_LDAP
334 WLDAP32_LDAP *ld = NULL;
335 WCHAR *hostnameW = NULL;
336
337 TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
338
339 if (hostname) {
340 hostnameW = strAtoW( hostname );
341 if (!hostnameW) goto exit;
342 }
343
344 ld = ldap_initW( hostnameW, portnumber );
345
346 exit:
347 strfreeW( hostnameW );
348 return ld;
349
350 #else
351 return NULL;
352 #endif
353 }
354
355 /***********************************************************************
356 * ldap_initW (WLDAP32.@)
357 *
358 * Initialize an LDAP context and create a TCP connection.
359 *
360 * PARAMS
361 * hostname [I] Name of the host to connect to.
362 * portnumber [I] Port number to use.
363 *
364 * RETURNS
365 * Success: Pointer to an LDAP context.
366 * Failure: NULL
367 *
368 * NOTES
369 * The hostname string can be a space separated string of hostnames,
370 * in which case the LDAP runtime will try to connect to the hosts
371 * in order, until a connection can be made. A hostname may have a
372 * trailing port number (separated from the hostname by a ':'), which
373 * will take precedence over the port number supplied as a parameter
374 * to this function. The connection will not be made until the first
375 * LDAP function that needs it is called.
376 */
377 WLDAP32_LDAP * CDECL ldap_initW( const PWCHAR hostname, ULONG portnumber )
378 {
379 #ifdef HAVE_LDAP
380 LDAP *ld = NULL;
381 char *hostnameU = NULL, *url = NULL;
382
383 TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
384
385 if (hostname) {
386 hostnameU = strWtoU( hostname );
387 if (!hostnameU) goto exit;
388 }
389 else {
390 hostnameU = strWtoU( defaulthost );
391 if (!hostnameU) goto exit;
392 }
393
394 url = urlify_hostnames( "ldap://", hostnameU, portnumber );
395 if (!url) goto exit;
396
397 ld = create_context( url );
398
399 exit:
400 strfreeU( hostnameU );
401 strfreeU( url );
402 return ld;
403
404 #else
405 return NULL;
406 #endif
407 }
408
409 /***********************************************************************
410 * ldap_openA (WLDAP32.@)
411 *
412 * See ldap_openW.
413 */
414 WLDAP32_LDAP * CDECL ldap_openA( PCHAR hostname, ULONG portnumber )
415 {
416 #ifdef HAVE_LDAP
417 WLDAP32_LDAP *ld = NULL;
418 WCHAR *hostnameW = NULL;
419
420 TRACE( "(%s, %d)\n", debugstr_a(hostname), portnumber );
421
422 if (hostname) {
423 hostnameW = strAtoW( hostname );
424 if (!hostnameW) goto exit;
425 }
426
427 ld = ldap_openW( hostnameW, portnumber );
428
429 exit:
430 strfreeW( hostnameW );
431 return ld;
432
433 #else
434 return NULL;
435 #endif
436 }
437
438 /***********************************************************************
439 * ldap_openW (WLDAP32.@)
440 *
441 * Initialize an LDAP context and create a TCP connection.
442 *
443 * PARAMS
444 * hostname [I] Name of the host to connect to.
445 * portnumber [I] Port number to use.
446 *
447 * RETURNS
448 * Success: Pointer to an LDAP context.
449 * Failure: NULL
450 *
451 * NOTES
452 * The hostname string can be a space separated string of hostnames,
453 * in which case the LDAP runtime will try to connect to the hosts
454 * in order, until a connection can be made. A hostname may have a
455 * trailing port number (separated from the hostname by a ':'), which
456 * will take precedence over the port number supplied as a parameter
457 * to this function.
458 */
459 WLDAP32_LDAP * CDECL ldap_openW( PWCHAR hostname, ULONG portnumber )
460 {
461 #ifdef HAVE_LDAP
462 LDAP *ld = NULL;
463 char *hostnameU = NULL, *url = NULL;
464
465 TRACE( "(%s, %d)\n", debugstr_w(hostname), portnumber );
466
467 if (hostname) {
468 hostnameU = strWtoU( hostname );
469 if (!hostnameU) goto exit;
470 }
471 else {
472 hostnameU = strWtoU( defaulthost );
473 if (!hostnameU) goto exit;
474 }
475
476 url = urlify_hostnames( "ldap://", hostnameU, portnumber );
477 if (!url) goto exit;
478
479 ld = create_context( url );
480
481 exit:
482 strfreeU( hostnameU );
483 strfreeU( url );
484 return ld;
485
486 #else
487 return NULL;
488 #endif
489 }
490
491 /***********************************************************************
492 * ldap_sslinitA (WLDAP32.@)
493 *
494 * See ldap_sslinitW.
495 */
496 WLDAP32_LDAP * CDECL ldap_sslinitA( PCHAR hostname, ULONG portnumber, int secure )
497 {
498 #ifdef HAVE_LDAP
499 WLDAP32_LDAP *ld;
500 WCHAR *hostnameW = NULL;
501
502 TRACE( "(%s, %d, 0x%08x)\n", debugstr_a(hostname), portnumber, secure );
503
504 if (hostname) {
505 hostnameW = strAtoW( hostname );
506 if (!hostnameW) return NULL;
507 }
508
509 ld = ldap_sslinitW( hostnameW, portnumber, secure );
510
511 strfreeW( hostnameW );
512 return ld;
513
514 #else
515 return NULL;
516 #endif
517 }
518
519 /***********************************************************************
520 * ldap_sslinitW (WLDAP32.@)
521 *
522 * Initialize an LDAP context and create a secure TCP connection.
523 *
524 * PARAMS
525 * hostname [I] Name of the host to connect to.
526 * portnumber [I] Port number to use.
527 * secure [I] Ask the server to create an SSL connection.
528 *
529 * RETURNS
530 * Success: Pointer to an LDAP context.
531 * Failure: NULL
532 *
533 * NOTES
534 * The hostname string can be a space separated string of hostnames,
535 * in which case the LDAP runtime will try to connect to the hosts
536 * in order, until a connection can be made. A hostname may have a
537 * trailing port number (separated from the hostname by a ':'), which
538 * will take precedence over the port number supplied as a parameter
539 * to this function. The connection will not be made until the first
540 * LDAP function that needs it is called.
541 */
542 WLDAP32_LDAP * CDECL ldap_sslinitW( PWCHAR hostname, ULONG portnumber, int secure )
543 {
544 #ifdef HAVE_LDAP
545 WLDAP32_LDAP *ld = NULL;
546 char *hostnameU = NULL, *url = NULL;
547
548 TRACE( "(%s, %d, 0x%08x)\n", debugstr_w(hostname), portnumber, secure );
549
550 if (hostname) {
551 hostnameU = strWtoU( hostname );
552 if (!hostnameU) goto exit;
553 }
554 else {
555 hostnameU = strWtoU( defaulthost );
556 if (!hostnameU) goto exit;
557 }
558
559 if (secure)
560 url = urlify_hostnames( "ldaps://", hostnameU, portnumber );
561 else
562 url = urlify_hostnames( "ldap://", hostnameU, portnumber );
563
564 if (!url) goto exit;
565 ldap_initialize( &ld, url );
566
567 exit:
568 strfreeU( hostnameU );
569 strfreeU( url );
570 return ld;
571
572 #else
573 return NULL;
574 #endif
575 }
576
577 /***********************************************************************
578 * ldap_start_tls_sA (WLDAP32.@)
579 *
580 * See ldap_start_tls_sW.
581 */
582 ULONG CDECL ldap_start_tls_sA( WLDAP32_LDAP *ld, PULONG retval, WLDAP32_LDAPMessage **result,
583 PLDAPControlA *serverctrls, PLDAPControlA *clientctrls )
584 {
585 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
586 #ifdef HAVE_LDAP
587 LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
588
589 ret = WLDAP32_LDAP_NO_MEMORY;
590
591 TRACE( "(%p, %p, %p, %p, %p)\n", ld, retval, result, serverctrls, clientctrls );
592
593 if (!ld) return ~0u;
594
595 if (serverctrls) {
596 serverctrlsW = controlarrayAtoW( serverctrls );
597 if (!serverctrlsW) goto exit;
598 }
599 if (clientctrls) {
600 clientctrlsW = controlarrayAtoW( clientctrls );
601 if (!clientctrlsW) goto exit;
602 }
603
604 ret = ldap_start_tls_sW( ld, retval, result, serverctrlsW, clientctrlsW );
605
606 exit:
607 controlarrayfreeW( serverctrlsW );
608 controlarrayfreeW( clientctrlsW );
609
610 #endif
611 return ret;
612 }
613
614 /***********************************************************************
615 * ldap_start_tls_s (WLDAP32.@)
616 *
617 * Start TLS encryption on an LDAP connection.
618 *
619 * PARAMS
620 * ld [I] Pointer to an LDAP context.
621 * retval [I] Return value from the server.
622 * result [I] Response message from the server.
623 * serverctrls [I] Array of LDAP server controls.
624 * clientctrls [I] Array of LDAP client controls.
625 *
626 * RETURNS
627 * Success: LDAP_SUCCESS
628 * Failure: An LDAP error code.
629 *
630 * NOTES
631 * LDAP function that needs it is called.
632 */
633 ULONG CDECL ldap_start_tls_sW( WLDAP32_LDAP *ld, PULONG retval, WLDAP32_LDAPMessage **result,
634 PLDAPControlW *serverctrls, PLDAPControlW *clientctrls )
635 {
636 ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
637 #ifdef HAVE_LDAP
638 LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
639
640 ret = WLDAP32_LDAP_NO_MEMORY;
641
642 TRACE( "(%p, %p, %p, %p, %p)\n", ld, retval, result, serverctrls, clientctrls );
643
644 if (!ld) return ~0u;
645
646 if (serverctrls) {
647 serverctrlsU = controlarrayWtoU( serverctrls );
648 if (!serverctrlsU) goto exit;
649 }
650 if (clientctrls) {
651 clientctrlsU = controlarrayWtoU( clientctrls );
652 if (!clientctrlsU) goto exit;
653 }
654
655 ret = map_error( ldap_start_tls_s( ld, serverctrlsU, clientctrlsU ));
656
657 exit:
658 controlarrayfreeU( serverctrlsU );
659 controlarrayfreeU( clientctrlsU );
660
661 #endif
662 return ret;
663 }
664
665 /***********************************************************************
666 * ldap_startup (WLDAP32.@)
667 */
668 ULONG CDECL ldap_startup( PLDAP_VERSION_INFO version, HANDLE *instance )
669 {
670 TRACE( "(%p, %p)\n", version, instance );
671 return WLDAP32_LDAP_SUCCESS;
672 }
673
674 /***********************************************************************
675 * ldap_stop_tls_s (WLDAP32.@)
676 *
677 * Stop TLS encryption on an LDAP connection.
678 *
679 * PARAMS
680 * ld [I] Pointer to an LDAP context.
681 *
682 * RETURNS
683 * Success: TRUE
684 * Failure: FALSE
685 */
686 BOOLEAN CDECL ldap_stop_tls_s( WLDAP32_LDAP *ld )
687 {
688 TRACE( "(%p)\n", ld );
689 return TRUE; /* FIXME: find a way to stop tls on a connection */
690 }