git.oblomov.eu Git - wine/blob - dlls/wldap32/bind.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  33 #include <ldap.h>
  34 #else
  35 #define LDAP_SUCCESS        0x00
  36 #define LDAP_NOT_SUPPORTED  0x5c
  37 #endif
  38
  39 #include "winldap_private.h"
  40 #include "wldap32.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  43
  44 ULONG ldap_bindA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR cred, ULONG method )
  45 {
  46     ULONG ret = LDAP_NOT_SUPPORTED;
  47 #ifdef HAVE_LDAP
  48     WCHAR *dnW = NULL, *credW = NULL;
  49     ret = LDAP_NO_MEMORY;
  50
  51     TRACE( "(%p, %s, %p, 0x%08lx)\n", ld, debugstr_a(dn), cred, method );
  52
  53     if (!ld) return ~0UL;
  54
  55     if (dn) {
  56         dnW = strAtoW( dn );
  57         if (!dnW) goto exit;
  58     }
  59     if (cred) {
  60         credW = strAtoW( cred );
  61         if (!credW) goto exit;
  62     }
  63
  64     ret = ldap_bindW( ld, dnW, credW, method );
  65
  66 exit:
  67     strfreeW( dnW );
  68     strfreeW( credW );
  69
  70 #endif
  71     return ret;
  72 }
  73
  74 ULONG ldap_bindW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG method )
  75 {
  76     ULONG ret = LDAP_NOT_SUPPORTED;
  77 #ifdef HAVE_LDAP
  78     char *dnU = NULL, *credU = NULL;
  79     ret = LDAP_NO_MEMORY;
  80
  81     TRACE( "(%p, %s, %p, 0x%08lx)\n", ld, debugstr_w(dn), cred, method );
  82
  83     if (!ld) return ~0UL;
  84
  85     if (dn) {
  86         dnU = strWtoU( dn );
  87         if (!dnU) goto exit;
  88     }
  89     if (cred) {
  90         credU = strWtoU( cred );
  91         if (!credU) goto exit;
  92     }
  93
  94     ret = ldap_bind( ld, dnU, credU, method );
  95
  96 exit:
  97     strfreeU( dnU );
  98     strfreeU( credU );
  99
 100 #endif
 101     return ret;
 102 }
 103
 104 ULONG ldap_bind_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR cred, ULONG method )
 105 {
 106     ULONG ret = LDAP_NOT_SUPPORTED;
 107 #ifdef HAVE_LDAP
 108     WCHAR *dnW = NULL, *credW = NULL;
 109     ret = LDAP_NO_MEMORY;
 110
 111     TRACE( "(%p, %s, %p, 0x%08lx)\n", ld, debugstr_a(dn), cred, method );
 112
 113     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 114
 115     if (dn) {
 116         dnW = strAtoW( dn );
 117         if (!dnW) goto exit;
 118     }
 119     if (cred) {
 120         credW = strAtoW( cred );
 121         if (!credW) goto exit;
 122     }
 123
 124     ret = ldap_bind_sW( ld, dnW, credW, method );
 125
 126 exit:
 127     strfreeW( dnW );
 128     strfreeW( credW );
 129
 130 #endif
 131     return ret;
 132 }
 133
 134 ULONG ldap_bind_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR cred, ULONG method )
 135 {
 136     ULONG ret = LDAP_NOT_SUPPORTED;
 137 #ifdef HAVE_LDAP
 138     char *dnU = NULL, *credU = NULL;
 139     ret = LDAP_NO_MEMORY;
 140
 141     TRACE( "(%p, %s, %p, 0x%08lx)\n", ld, debugstr_w(dn), cred, method );
 142
 143     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 144
 145     if (dn) {
 146         dnU = strWtoU( dn );
 147         if (!dnU) goto exit;
 148     }
 149     if (cred) {
 150         credU = strWtoU( cred );
 151         if (!credU) goto exit;
 152     }
 153
 154     ret = ldap_bind_s( ld, dnU, credU, method );
 155
 156 exit:
 157     strfreeU( dnU );
 158     strfreeU( credU );
 159
 160 #endif
 161     return ret;
 162 }
 163
 164 ULONG ldap_sasl_bindA( WLDAP32_LDAP *ld, const PCHAR dn,
 165     const PCHAR mechanism, const BERVAL *cred, PLDAPControlA *serverctrls,
 166     PLDAPControlA *clientctrls, int *message )
 167 {
 168     ULONG ret = LDAP_NOT_SUPPORTED;
 169 #ifdef HAVE_LDAP
 170     WCHAR *dnW, *mechanismW = NULL;
 171     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 172     ret = LDAP_NO_MEMORY;
 173
 174     TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
 175            debugstr_a(mechanism), cred, serverctrls, clientctrls, message );
 176
 177     if (!ld || !dn || !mechanism || !cred || !message)
 178         return WLDAP32_LDAP_PARAM_ERROR;
 179
 180     dnW = strAtoW( dn );
 181     if (!dnW) goto exit;
 182
 183     mechanismW = strAtoW( mechanism );
 184     if (!mechanismW) goto exit;
 185
 186     if (serverctrls) {
 187         serverctrlsW = controlarrayAtoW( serverctrls );
 188         if (!serverctrlsW) goto exit;
 189     }
 190     if (clientctrls) {
 191         clientctrlsW = controlarrayAtoW( clientctrls );
 192         if (!clientctrlsW) goto exit;
 193     }
 194
 195     ret = ldap_sasl_bindW( ld, dnW, mechanismW, cred, serverctrlsW, clientctrlsW, message );
 196
 197 exit:
 198     strfreeW( dnW );
 199     strfreeW( mechanismW );
 200     controlarrayfreeW( serverctrlsW );
 201     controlarrayfreeW( clientctrlsW );
 202
 203 #endif
 204     return ret;
 205 }
 206
 207 ULONG ldap_sasl_bindW( WLDAP32_LDAP *ld, const PWCHAR dn,
 208     const PWCHAR mechanism, const BERVAL *cred, PLDAPControlW *serverctrls,
 209     PLDAPControlW *clientctrls, int *message )
 210 {
 211     ULONG ret = LDAP_NOT_SUPPORTED;
 212 #ifdef HAVE_LDAP
 213     char *dnU, *mechanismU = NULL;
 214     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 215     ret = LDAP_NO_MEMORY;
 216
 217     TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
 218            debugstr_w(mechanism), cred, serverctrls, clientctrls, message );
 219
 220     if (!ld || !dn || !mechanism || !cred || !message)
 221         return WLDAP32_LDAP_PARAM_ERROR;
 222
 223     dnU = strWtoU( dn );
 224     if (!dnU) goto exit;
 225
 226     mechanismU = strWtoU( mechanism );
 227     if (!mechanismU) goto exit;
 228
 229     if (serverctrls) {
 230         serverctrlsU = controlarrayWtoU( serverctrls );
 231         if (!serverctrlsU) goto exit;
 232     }
 233     if (clientctrls) {
 234         clientctrlsU = controlarrayWtoU( clientctrls );
 235         if (!clientctrlsU) goto exit;
 236     }
 237
 238     ret = ldap_sasl_bind( ld, dnU, mechanismU, (struct berval *)cred,
 239                           serverctrlsU, clientctrlsU, message );
 240
 241 exit:
 242     strfreeU( dnU );
 243     strfreeU( mechanismU );
 244     controlarrayfreeU( serverctrlsU );
 245     controlarrayfreeU( clientctrlsU );
 246
 247 #endif
 248     return ret;
 249 }
 250
 251 ULONG ldap_sasl_bind_sA( WLDAP32_LDAP *ld, const PCHAR dn,
 252     const PCHAR mechanism, const BERVAL *cred, PLDAPControlA *serverctrls,
 253     PLDAPControlA *clientctrls, PBERVAL *serverdata )
 254 {
 255     ULONG ret = LDAP_NOT_SUPPORTED;
 256 #ifdef HAVE_LDAP
 257     WCHAR *dnW, *mechanismW = NULL;
 258     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 259     ret = LDAP_NO_MEMORY;
 260
 261     TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
 262            debugstr_a(mechanism), cred, serverctrls, clientctrls, serverdata );
 263
 264     if (!ld || !dn || !mechanism || !cred || !serverdata)
 265         return WLDAP32_LDAP_PARAM_ERROR;
 266
 267     dnW = strAtoW( dn );
 268     if (!dnW) goto exit;
 269
 270     mechanismW = strAtoW( mechanism );
 271     if (!mechanismW) goto exit;
 272
 273     if (serverctrls) {
 274         serverctrlsW = controlarrayAtoW( serverctrls );
 275         if (!serverctrlsW) goto exit;
 276     }
 277     if (clientctrls) {
 278         clientctrlsW = controlarrayAtoW( clientctrls );
 279         if (!clientctrlsW) goto exit;
 280     }
 281
 282     ret = ldap_sasl_bind_sW( ld, dnW, mechanismW, cred, serverctrlsW, clientctrlsW, serverdata );
 283
 284 exit:
 285     strfreeW( dnW );
 286     strfreeW( mechanismW );
 287     controlarrayfreeW( serverctrlsW );
 288     controlarrayfreeW( clientctrlsW );
 289
 290 #endif
 291     return ret;
 292 }
 293
 294 ULONG ldap_sasl_bind_sW( WLDAP32_LDAP *ld, const PWCHAR dn,
 295     const PWCHAR mechanism, const BERVAL *cred, PLDAPControlW *serverctrls,
 296     PLDAPControlW *clientctrls, PBERVAL *serverdata )
 297 {
 298     ULONG ret = LDAP_NOT_SUPPORTED;
 299 #ifdef HAVE_LDAP
 300     char *dnU, *mechanismU = NULL;
 301     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 302     ret = LDAP_NO_MEMORY;
 303
 304     TRACE( "(%p, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
 305            debugstr_w(mechanism), cred, serverctrls, clientctrls, serverdata );
 306
 307     if (!ld || !dn || !mechanism || !cred || !serverdata)
 308         return WLDAP32_LDAP_PARAM_ERROR;
 309
 310     dnU = strWtoU( dn );
 311     if (!dnU) goto exit;
 312
 313     mechanismU = strWtoU( mechanism );
 314     if (!mechanismU) goto exit;
 315
 316     if (serverctrls) {
 317         serverctrlsU = controlarrayWtoU( serverctrls );
 318         if (!serverctrlsU) goto exit;
 319     }
 320     if (clientctrls) {
 321         clientctrlsU = controlarrayWtoU( clientctrls );
 322         if (!clientctrlsU) goto exit;
 323     }
 324
 325     ret = ldap_sasl_bind_s( ld, dnU, mechanismU, (struct berval *)cred,
 326                             serverctrlsU, clientctrlsU, (struct berval **)serverdata );
 327
 328 exit:
 329     strfreeU( dnU );
 330     strfreeU( mechanismU );
 331     controlarrayfreeU( serverctrlsU );
 332     controlarrayfreeU( clientctrlsU );
 333
 334 #endif
 335     return ret;
 336 }
 337
 338 ULONG ldap_simple_bindA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR passwd )
 339 {
 340     ULONG ret = LDAP_NOT_SUPPORTED;
 341 #ifdef HAVE_LDAP
 342     WCHAR *dnW = NULL, *passwdW = NULL;
 343     ret = LDAP_NO_MEMORY;
 344
 345     TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), passwd );
 346
 347     if (!ld) return ~0UL;
 348
 349     if (dn) {
 350         dnW = strAtoW( dn );
 351         if (!dnW) goto exit;
 352     }
 353     if (passwd) {
 354         passwdW = strAtoW( passwd );
 355         if (!passwdW) goto exit;
 356     }
 357
 358     ret = ldap_simple_bindW( ld, dnW, passwdW );
 359
 360 exit:
 361     strfreeW( dnW );
 362     strfreeW( passwdW );
 363
 364 #endif
 365     return ret;
 366 }
 367
 368 ULONG ldap_simple_bindW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR passwd )
 369 {
 370     ULONG ret = LDAP_NOT_SUPPORTED;
 371 #ifdef HAVE_LDAP
 372     char *dnU = NULL, *passwdU = NULL;
 373     ret = LDAP_NO_MEMORY;
 374
 375     TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), passwd );
 376
 377     if (!ld) return ~0UL;
 378
 379     if (dn) {
 380         dnU = strWtoU( dn );
 381         if (!dnU) goto exit;
 382     }
 383     if (passwd) {
 384         passwdU = strWtoU( passwd );
 385         if (!passwdU) goto exit;
 386     }
 387
 388     ret = ldap_simple_bind( ld, dnU, passwdU );
 389
 390 exit:
 391     strfreeU( dnU );
 392     strfreeU( passwdU );
 393
 394 #endif
 395     return ret;
 396 }
 397
 398 ULONG ldap_simple_bind_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR passwd )
 399 {
 400     ULONG ret = LDAP_NOT_SUPPORTED;
 401 #ifdef HAVE_LDAP
 402     WCHAR *dnW = NULL, *passwdW = NULL;
 403     ret = LDAP_NO_MEMORY;
 404
 405     TRACE( "(%p, %s, %p)\n", ld, debugstr_a(dn), passwd );
 406
 407     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 408
 409     if (dn) {
 410         dnW = strAtoW( dn );
 411         if (!dnW) goto exit;
 412     }
 413     if (passwd) {
 414         passwdW = strAtoW( passwd );
 415         if (!passwdW) goto exit;
 416     }
 417
 418     ret = ldap_simple_bind_sW( ld, dnW, passwdW );
 419
 420 exit:
 421     strfreeW( dnW );
 422     strfreeW( passwdW );
 423
 424 #endif
 425     return ret;
 426 }
 427
 428 ULONG ldap_simple_bind_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR passwd )
 429 {
 430     ULONG ret = LDAP_NOT_SUPPORTED;
 431 #ifdef HAVE_LDAP
 432     char *dnU = NULL, *passwdU = NULL;
 433     ret = LDAP_NO_MEMORY;
 434
 435     TRACE( "(%p, %s, %p)\n", ld, debugstr_w(dn), passwd );
 436
 437     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 438
 439     if (dn) {
 440         dnU = strWtoU( dn );
 441         if (!dnU) goto exit;
 442     }
 443     if (passwd) {
 444         passwdU = strWtoU( passwd );
 445         if (!passwdU) goto exit;
 446     }
 447
 448     ret = ldap_simple_bind_s( ld, dnU, passwdU );
 449
 450 exit:
 451     strfreeU( dnU );
 452     strfreeU( passwdU );
 453
 454 #endif
 455     return ret;
 456 }
 457
 458 ULONG WLDAP32_ldap_unbind( WLDAP32_LDAP *ld )
 459 {
 460     ULONG ret = LDAP_NOT_SUPPORTED;
 461 #ifdef HAVE_LDAP
 462
 463     TRACE( "(%p)\n", ld );
 464
 465     if (ld)
 466         ret = ldap_unbind( ld );
 467     else
 468         ret = WLDAP32_LDAP_PARAM_ERROR;
 469
 470 #endif
 471     return ret;
 472 }
 473
 474 ULONG WLDAP32_ldap_unbind_s( WLDAP32_LDAP *ld )
 475 {
 476     ULONG ret = LDAP_NOT_SUPPORTED;
 477 #ifdef HAVE_LDAP
 478
 479     TRACE( "(%p)\n", ld );
 480
 481     if (ld)
 482         ret = ldap_unbind_s( ld );
 483     else
 484         ret = WLDAP32_LDAP_PARAM_ERROR;
 485
 486 #endif
 487     return ret;
 488 }