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