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 <stdarg.h>
  22 #include <stdlib.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winnls.h"
  26 #include "winternl.h"
  27 #include "schannel.h"
  28 #include "sspi.h"
  29
  30 #include "wine/debug.h"
  31 #include "winldap_private.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  34
  35 /* Split a space separated string of hostnames into a string array */
  36 static char **split_hostnames( const char *hostnames )
  37 {
  38     char **res, *str, *p, *q;
  39     unsigned int i = 0;
  40
  41     str = strdup( hostnames );
  42     if (!str) return NULL;
  43
  44     p = str;
  45     while (isspace( *p )) p++;
  46     if (*p) i++;
  47
  48     while (*p)
  49     {
  50         if (isspace( *p ))
  51         {
  52             while (isspace( *p )) p++;
  53             if (*p) i++;
  54         }
  55         p++;
  56     }
  57
  58     if (!(res = malloc( (i + 1) * sizeof(char *) )))
  59     {
  60         free( str );
  61         return NULL;
  62     }
  63
  64     p = str;
  65     while (isspace( *p )) p++;
  66
  67     q = p;
  68     i = 0;
  69
  70     while (*p)
  71     {
  72         if (p[1] != '\0')
  73         {
  74             if (isspace( *p ))
  75             {
  76                 *p = '\0'; p++;
  77                 res[i] = strdup( q );
  78                 if (!res[i]) goto oom;
  79                 i++;
  80
  81                 while (isspace( *p )) p++;
  82                 q = p;
  83             }
  84         }
  85         else
  86         {
  87             res[i] = strdup( q );
  88             if (!res[i]) goto oom;
  89             i++;
  90         }
  91         p++;
  92     }
  93     res[i] = NULL;
  94
  95     free( str );
  96     return res;
  97
  98 oom:
  99     while (i > 0) free( res[--i] );
 100     free( res );
 101     free( str );
 102     return NULL;
 103 }
 104
 105 /* Determine if a URL starts with a known LDAP scheme */
 106 static BOOL has_ldap_scheme( char *url )
 107 {
 108     return !_strnicmp( url, "ldap://", 7 )  ||
 109            !_strnicmp( url, "ldaps://", 8 ) ||
 110            !_strnicmp( url, "ldapi://", 8 ) ||
 111            !_strnicmp( url, "cldap://", 8 );
 112 }
 113
 114 /* Flatten an array of hostnames into a space separated string of URLs.
 115  * Prepend a given scheme and append a given port number to each hostname
 116  * if necessary.
 117  */
 118 static char *join_hostnames( const char *scheme, char **hostnames, ULONG portnumber )
 119 {
 120     char *res, *p, *q, **v;
 121     unsigned int i = 0, size = 0;
 122     static const char sep[] = " ";
 123     char port[7];
 124
 125     sprintf( port, ":%lu", portnumber );
 126
 127     for (v = hostnames; *v; v++)
 128     {
 129         if (!has_ldap_scheme( *v ))
 130         {
 131             size += strlen( scheme );
 132             q = *v;
 133         }
 134         else
 135             /* skip past colon in scheme prefix */
 136             q = strchr( *v, '/' );
 137
 138         size += strlen( *v );
 139
 140         if (!strchr( q, ':' ))
 141             size += strlen( port );
 142
 143         i++;
 144     }
 145
 146     size += (i - 1) * strlen( sep );
 147     if (!(res = malloc( size + 1 ))) return NULL;
 148
 149     p = res;
 150     for (v = hostnames; *v; v++)
 151     {
 152         if (v != hostnames)
 153         {
 154             strcpy( p, sep );
 155             p += strlen( sep );
 156         }
 157
 158         if (!has_ldap_scheme( *v ))
 159         {
 160             strcpy( p, scheme );
 161             p += strlen( scheme );
 162             q = *v;
 163         }
 164         else
 165             /* skip past colon in scheme prefix */
 166             q = strchr( *v, '/' );
 167
 168         strcpy( p, *v );
 169         p += strlen( *v );
 170
 171         if (!strchr( q, ':' ))
 172         {
 173             strcpy( p, port );
 174             p += strlen( port );
 175         }
 176     }
 177     return res;
 178 }
 179
 180 static char *urlify_hostnames( const char *scheme, char *hostnames, ULONG port )
 181 {
 182     char *url = NULL, **strarray;
 183
 184     strarray = split_hostnames( hostnames );
 185     if (strarray)
 186         url = join_hostnames( scheme, strarray, port );
 187     else
 188         return NULL;
 189
 190     strarrayfreeU( strarray );
 191     return url;
 192 }
 193
 194 static LDAP *create_context( const char *url )
 195 {
 196     LDAP *ld;
 197     int version = WLDAP32_LDAP_VERSION3;
 198
 199     if (!(ld = calloc( 1, sizeof( *ld )))) return NULL;
 200     if (map_error( ldap_initialize( &CTX(ld), url ) ) == WLDAP32_LDAP_SUCCESS)
 201     {
 202         ldap_set_option( CTX(ld), WLDAP32_LDAP_OPT_PROTOCOL_VERSION, &version );
 203         return ld;
 204     }
 205     free( ld );
 206     return NULL;
 207 }
 208
 209 /***********************************************************************
 210  *      cldap_openA     (WLDAP32.@)
 211  */
 212 LDAP * CDECL cldap_openA( char *hostname, ULONG portnumber )
 213 {
 214     LDAP *ld;
 215     WCHAR *hostnameW = NULL;
 216
 217     TRACE( "(%s, %lu)\n", debugstr_a(hostname), portnumber );
 218
 219     if (hostname && !(hostnameW = strAtoW( hostname ))) return NULL;
 220
 221     ld = cldap_openW( hostnameW, portnumber );
 222
 223     free( hostnameW );
 224     return ld;
 225 }
 226
 227 /***********************************************************************
 228  *      cldap_openW     (WLDAP32.@)
 229  */
 230 LDAP * CDECL cldap_openW( WCHAR *hostname, ULONG portnumber )
 231 {
 232     LDAP *ld = NULL;
 233     char *hostnameU, *url = NULL;
 234
 235     TRACE( "(%s, %lu)\n", debugstr_w(hostname), portnumber );
 236
 237     if (!(hostnameU = strWtoU( hostname ? hostname : L"localhost" ))) return NULL;
 238     if (!(url = urlify_hostnames( "cldap://", hostnameU, portnumber ))) goto exit;
 239
 240     ld = create_context( url );
 241
 242 exit:
 243     free( hostnameU );
 244     free( url );
 245     return ld;
 246 }
 247
 248 /***********************************************************************
 249  *      ldap_connect     (WLDAP32.@)
 250  */
 251 ULONG CDECL WLDAP32_ldap_connect( LDAP *ld, struct l_timeval *timeout )
 252 {
 253     QUERYCLIENTCERT *client_cert_callback = CLIENT_CERT_CALLBACK(ld);
 254     VERIFYSERVERCERT *server_cert_callback = SERVER_CERT_CALLBACK(ld);
 255     int ret;
 256
 257     TRACE( "(%p, %p)\n", ld, timeout );
 258
 259     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 260     if (CONNECTED(ld)) return WLDAP32_LDAP_SUCCESS;
 261
 262     if (client_cert_callback)
 263         FIXME( "mTLS is not implemented\n" );
 264
 265     if (timeout && (timeout->tv_sec || timeout->tv_usec)) FIXME( "ignoring timeout\n" );
 266     if ((ret = ldap_connect( CTX(ld) ))) return map_error( ret );
 267
 268     if (server_cert_callback)
 269     {
 270         CtxtHandle *tls_context;
 271         const CERT_CONTEXT *cert;
 272
 273         if ((ret = ldap_get_option( CTX(ld), LDAP_OPT_X_TLS_SSL_CTX, &tls_context )))
 274             return map_error( ret );
 275
 276         if (QueryContextAttributesA( tls_context, SECPKG_ATTR_REMOTE_CERT_CONTEXT, &cert ) == SEC_E_OK)
 277         {
 278             if (server_cert_callback( ld, &cert ))
 279             {
 280                 TRACE( "accepted\n" );
 281             }
 282             else
 283             {
 284                 WARN( "rejected\n" );
 285                 return WLDAP32_LDAP_SERVER_DOWN;
 286             }
 287         }
 288     }
 289
 290     CONNECTED(ld) = TRUE;
 291     return WLDAP32_LDAP_SUCCESS;
 292 }
 293
 294 /***********************************************************************
 295  *      ldap_initA     (WLDAP32.@)
 296  */
 297 LDAP *  CDECL ldap_initA( const PCHAR hostname, ULONG portnumber )
 298 {
 299     LDAP *ld;
 300     WCHAR *hostnameW = NULL;
 301
 302     TRACE( "(%s, %lu)\n", debugstr_a(hostname), portnumber );
 303
 304     if (hostname && !(hostnameW = strAtoW( hostname ))) return NULL;
 305
 306     ld = ldap_initW( hostnameW, portnumber );
 307
 308     free( hostnameW );
 309     return ld;
 310 }
 311
 312 /***********************************************************************
 313  *      ldap_initW     (WLDAP32.@)
 314  */
 315 LDAP * CDECL ldap_initW( const PWCHAR hostname, ULONG portnumber )
 316 {
 317     LDAP *ld = NULL;
 318     char *hostnameU, *url = NULL;
 319
 320     TRACE( "(%s, %lu)\n", debugstr_w(hostname), portnumber );
 321
 322     if (!(hostnameU = strWtoU( hostname ? hostname : L"localhost" ))) return NULL;
 323     if (!(url = urlify_hostnames( "ldap://", hostnameU, portnumber ))) goto exit;
 324
 325     ld = create_context( url );
 326
 327 exit:
 328     free( hostnameU );
 329     free( url );
 330     return ld;
 331 }
 332
 333 /***********************************************************************
 334  *      ldap_openA     (WLDAP32.@)
 335  */
 336 LDAP * CDECL ldap_openA( char *hostname, ULONG portnumber )
 337 {
 338     LDAP *ld;
 339     WCHAR *hostnameW = NULL;
 340
 341     TRACE( "(%s, %lu)\n", debugstr_a(hostname), portnumber );
 342
 343     if (hostname && !(hostnameW = strAtoW( hostname ))) return NULL;
 344
 345     ld = ldap_openW( hostnameW, portnumber );
 346
 347     free( hostnameW );
 348     return ld;
 349 }
 350
 351 /***********************************************************************
 352  *      ldap_openW     (WLDAP32.@)
 353  */
 354 LDAP * CDECL ldap_openW( WCHAR *hostname, ULONG portnumber )
 355 {
 356     LDAP *ld = NULL;
 357     char *hostnameU, *url = NULL;
 358
 359     TRACE( "(%s, %lu)\n", debugstr_w(hostname), portnumber );
 360
 361     if (!(hostnameU = strWtoU( hostname ? hostname : L"localhost" ))) return NULL;
 362     if (!(url = urlify_hostnames( "ldap://", hostnameU, portnumber ))) goto exit;
 363
 364     ld = create_context( url );
 365
 366 exit:
 367     free( hostnameU );
 368     free( url );
 369     return ld;
 370 }
 371
 372 /***********************************************************************
 373  *      ldap_sslinitA     (WLDAP32.@)
 374  */
 375 LDAP * CDECL ldap_sslinitA( char *hostname, ULONG portnumber, int secure )
 376 {
 377     LDAP *ld;
 378     WCHAR *hostnameW = NULL;
 379
 380     TRACE( "(%s, %lu, %d)\n", debugstr_a(hostname), portnumber, secure );
 381
 382     if (hostname && !(hostnameW = strAtoW( hostname ))) return NULL;
 383
 384     ld  = ldap_sslinitW( hostnameW, portnumber, secure );
 385
 386     free( hostnameW );
 387     return ld;
 388 }
 389
 390 /***********************************************************************
 391  *      ldap_sslinitW     (WLDAP32.@)
 392  */
 393 LDAP * CDECL ldap_sslinitW( WCHAR *hostname, ULONG portnumber, int secure )
 394 {
 395     LDAP *ld = NULL;
 396     char *hostnameU, *url = NULL;
 397
 398     TRACE( "(%s, %lu, %d)\n", debugstr_w(hostname), portnumber, secure );
 399
 400     if (!(hostnameU = strWtoU( hostname ? hostname : L"localhost" ))) return NULL;
 401
 402     if (secure)
 403         url = urlify_hostnames( "ldaps://", hostnameU, portnumber );
 404     else
 405         url = urlify_hostnames( "ldap://", hostnameU, portnumber );
 406     if (!url) goto exit;
 407
 408     ld = create_context( url );
 409
 410 exit:
 411     free( hostnameU );
 412     free( url );
 413     return ld;
 414 }
 415
 416 /***********************************************************************
 417  *      ldap_start_tls_sA     (WLDAP32.@)
 418  */
 419 ULONG CDECL ldap_start_tls_sA( LDAP *ld, ULONG *retval, LDAPMessage **result, LDAPControlA **serverctrls,
 420                                LDAPControlA **clientctrls )
 421 {
 422     ULONG ret = WLDAP32_LDAP_NO_MEMORY;
 423     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 424
 425     TRACE( "(%p, %p, %p, %p, %p)\n", ld, retval, result, serverctrls, clientctrls );
 426
 427     if (!ld) return ~0u;
 428
 429     if (serverctrls && !(serverctrlsW = controlarrayAtoW( serverctrls ))) goto exit;
 430     if (clientctrls && !(clientctrlsW = controlarrayAtoW( clientctrls ))) goto exit;
 431
 432     ret = ldap_start_tls_sW( ld, retval, result, serverctrlsW, clientctrlsW );
 433
 434 exit:
 435     controlarrayfreeW( serverctrlsW );
 436     controlarrayfreeW( clientctrlsW );
 437     return ret;
 438 }
 439
 440 /***********************************************************************
 441  *      ldap_start_tls_s     (WLDAP32.@)
 442  */
 443 ULONG CDECL ldap_start_tls_sW( LDAP *ld, ULONG *retval, LDAPMessage **result, LDAPControlW **serverctrls,
 444                                LDAPControlW **clientctrls )
 445 {
 446     ULONG ret = WLDAP32_LDAP_NO_MEMORY;
 447     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 448
 449     TRACE( "(%p, %p, %p, %p, %p)\n", ld, retval, result, serverctrls, clientctrls );
 450     if (result)
 451     {
 452         FIXME( "result message not supported\n" );
 453         *result = NULL;
 454     }
 455
 456     if (!ld) return ~0u;
 457     if (CONNECTED(ld)) return WLDAP32_LDAP_LOCAL_ERROR;
 458
 459     if (serverctrls && !(serverctrlsU = controlarrayWtoU( serverctrls ))) goto exit;
 460     if (clientctrls && !(clientctrlsU = controlarrayWtoU( clientctrls ))) goto exit;
 461
 462     ret = map_error( ldap_start_tls_s( CTX(ld), serverctrlsU, clientctrlsU ) );
 463
 464 exit:
 465     controlarrayfreeU( serverctrlsU );
 466     controlarrayfreeU( clientctrlsU );
 467     return ret;
 468 }
 469
 470 /***********************************************************************
 471  *      ldap_startup     (WLDAP32.@)
 472  */
 473 ULONG CDECL ldap_startup( LDAP_VERSION_INFO *version, HANDLE *instance )
 474 {
 475     TRACE( "(%p, %p)\n", version, instance );
 476     return WLDAP32_LDAP_SUCCESS;
 477 }
 478
 479 /***********************************************************************
 480  *      ldap_stop_tls_s     (WLDAP32.@)
 481  */
 482 BOOLEAN CDECL ldap_stop_tls_s( LDAP *ld )
 483 {
 484     TRACE( "(%p)\n", ld );
 485     return TRUE; /* FIXME: find a way to stop tls on a connection */
 486 }