dlls/wldap32/compare.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_compareA     (WLDAP32.@)
  43  *
  44  * See ldap_compareW.
  45  */
  46 ULONG CDECL ldap_compareA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value )
  47 {
  48     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
  49 #ifdef HAVE_LDAP
  50     WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
  51
  52     ret = ~0u;
  53
  54     TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
  55            debugstr_a(value) );
  56
  57     if (!ld || !attr) return ~0u;
  58
  59     if (dn) {
  60         dnW = strAtoW( dn );
  61         if (!dnW) goto exit;
  62     }
  63
  64     attrW = strAtoW( attr );
  65     if (!attrW) goto exit;
  66
  67     if (value) {
  68         valueW = strAtoW( value );
  69         if (!valueW) goto exit;
  70     }
  71
  72     ret = ldap_compareW( ld, dnW, attrW, valueW );
  73
  74 exit:
  75     strfreeW( dnW );
  76     strfreeW( attrW );
  77     strfreeW( valueW );
  78
  79 #endif
  80     return ret;
  81 }
  82
  83 /***********************************************************************
  84  *      ldap_compareW     (WLDAP32.@)
  85  *
  86  * Check if an attribute has a certain value (asynchronous operation).
  87  *
  88  * PARAMS
  89  *  ld      [I] Pointer to an LDAP context.
  90  *  dn      [I] DN of entry to compare value for.
  91  *  attr    [I] Attribute to compare value for.
  92  *  value   [I] Value to compare.
  93  *
  94  * RETURNS
  95  *  Success: Message ID of the compare operation.
  96  *  Failure: An LDAP error code.
  97  */
  98 ULONG CDECL ldap_compareW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value )
  99 {
 100     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 101 #ifdef HAVE_LDAP
 102     char *dnU = NULL, *attrU = NULL, *valueU = NULL;
 103     struct berval val = { 0, NULL };
 104     int msg;
 105
 106     ret = ~0u;
 107
 108     TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
 109            debugstr_w(value) );
 110
 111     if (!ld || !attr) return ~0u;
 112
 113     if (dn) {
 114         dnU = strWtoU( dn );
 115         if (!dnU) goto exit;
 116     }
 117
 118     attrU = strWtoU( attr );
 119     if (!attrU) goto exit;
 120
 121     if (value) {
 122         valueU = strWtoU( value );
 123         if (!valueU) goto exit;
 124
 125         val.bv_len = strlen( valueU );
 126         val.bv_val = valueU;
 127     }
 128
 129     ret = ldap_compare_ext( ld, dn ? dnU : "", attrU, &val, NULL, NULL, &msg );
 130
 131     if (ret == LDAP_SUCCESS)
 132         ret = msg;
 133     else
 134         ret = ~0u;
 135
 136 exit:
 137     strfreeU( dnU );
 138     strfreeU( attrU );
 139     strfreeU( valueU );
 140
 141 #endif
 142     return ret;
 143 }
 144
 145 /***********************************************************************
 146  *      ldap_compare_extA     (WLDAP32.@)
 147  *
 148  * See ldap_compare_extW.
 149  */
 150 ULONG CDECL ldap_compare_extA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value,
 151     struct WLDAP32_berval *data, PLDAPControlA *serverctrls, PLDAPControlA *clientctrls,
 152     ULONG *message )
 153 {
 154     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 155 #ifdef HAVE_LDAP
 156     WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
 157     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 158
 159     ret = WLDAP32_LDAP_NO_MEMORY;
 160
 161     TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_a(dn),
 162            debugstr_a(attr), debugstr_a(value), data, serverctrls,
 163            clientctrls, message );
 164
 165     if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 166
 167     if (dn) {
 168         dnW = strAtoW( dn );
 169         if (!dnW) goto exit;
 170     }
 171     if (attr) {
 172         attrW = strAtoW( attr );
 173         if (!attrW) goto exit;
 174     }
 175     if (value) {
 176         valueW = strAtoW( value );
 177         if (!valueW) goto exit;
 178     }
 179     if (serverctrls) {
 180         serverctrlsW = controlarrayAtoW( serverctrls );
 181         if (!serverctrlsW) goto exit;
 182     }
 183     if (clientctrls) {
 184         clientctrlsW = controlarrayAtoW( clientctrls );
 185         if (!clientctrlsW) goto exit;
 186     }
 187
 188     ret = ldap_compare_extW( ld, dnW, attrW, valueW, data,
 189                              serverctrlsW, clientctrlsW, message );
 190
 191 exit:
 192     strfreeW( dnW );
 193     strfreeW( attrW );
 194     strfreeW( valueW );
 195     controlarrayfreeW( serverctrlsW );
 196     controlarrayfreeW( clientctrlsW );
 197
 198 #endif
 199     return ret;
 200 }
 201
 202 /***********************************************************************
 203  *      ldap_compare_extW     (WLDAP32.@)
 204  *
 205  * Check if an attribute has a certain value (asynchronous operation).
 206  *
 207  * PARAMS
 208  *  ld          [I] Pointer to an LDAP context.
 209  *  dn          [I] DN of entry to compare value for.
 210  *  attr        [I] Attribute to compare value for.
 211  *  value       [I] string encoded value to compare.
 212  *  data        [I] berval encoded value to compare.
 213  *  serverctrls [I] Array of LDAP server controls.
 214  *  clientctrls [I] Array of LDAP client controls.
 215  *  message     [O] Message ID of the compare operation.
 216  *
 217  * RETURNS
 218  *  Success: LDAP_SUCCESS
 219  *  Failure: An LDAP error code.
 220  *
 221  * NOTES
 222  *  Set value to compare strings or data to compare binary values. If
 223  *  both are non-NULL, data will be used. The serverctrls and clientctrls
 224  *  parameters are optional and should be set to NULL if not used.
 225  */
 226 ULONG CDECL ldap_compare_extW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value,
 227     struct WLDAP32_berval *data, PLDAPControlW *serverctrls, PLDAPControlW *clientctrls,
 228     ULONG *message )
 229 {
 230     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 231 #ifdef HAVE_LDAP
 232     char *dnU = NULL, *attrU = NULL, *valueU = NULL;
 233     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 234     struct berval val = { 0, NULL };
 235
 236     ret = WLDAP32_LDAP_NO_MEMORY;
 237
 238     TRACE( "(%p, %s, %s, %s, %p, %p, %p, %p)\n", ld, debugstr_w(dn),
 239            debugstr_w(attr), debugstr_w(value), data, serverctrls,
 240            clientctrls, message );
 241
 242     if (!ld || !message) return WLDAP32_LDAP_PARAM_ERROR;
 243     if (!attr) return WLDAP32_LDAP_NO_MEMORY;
 244
 245     if (dn) {
 246         dnU = strWtoU( dn );
 247         if (!dnU) goto exit;
 248     }
 249
 250     attrU = strWtoU( attr );
 251     if (!attrU) goto exit;
 252
 253     if (!data) {
 254         if (value) {
 255             valueU = strWtoU( value );
 256             if (!valueU) goto exit;
 257
 258             val.bv_len = strlen( valueU );
 259             val.bv_val = valueU;
 260         }
 261     }
 262     if (serverctrls) {
 263         serverctrlsU = controlarrayWtoU( serverctrls );
 264         if (!serverctrlsU) goto exit;
 265     }
 266     if (clientctrls) {
 267         clientctrlsU = controlarrayWtoU( clientctrls );
 268         if (!clientctrlsU) goto exit;
 269     }
 270
 271     ret = map_error( ldap_compare_ext( ld, dn ? dnU : "", attrU, data ? (struct berval *)data : &val,
 272                                        serverctrlsU, clientctrlsU, (int *)message ));
 273
 274 exit:
 275     strfreeU( dnU );
 276     strfreeU( attrU );
 277     strfreeU( valueU );
 278     controlarrayfreeU( serverctrlsU );
 279     controlarrayfreeU( clientctrlsU );
 280
 281 #endif
 282     return ret;
 283 }
 284
 285 /***********************************************************************
 286  *      ldap_compare_ext_sA     (WLDAP32.@)
 287  *
 288  * See ldap_compare_ext_sW.
 289  */
 290 ULONG CDECL ldap_compare_ext_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value,
 291     struct WLDAP32_berval *data, PLDAPControlA *serverctrls, PLDAPControlA *clientctrls )
 292 {
 293     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 294 #ifdef HAVE_LDAP
 295     WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
 296     LDAPControlW **serverctrlsW = NULL, **clientctrlsW = NULL;
 297
 298     ret = WLDAP32_LDAP_NO_MEMORY;
 299
 300     TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_a(dn),
 301            debugstr_a(attr), debugstr_a(value), data, serverctrls,
 302            clientctrls );
 303
 304     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 305
 306     if (dn) {
 307         dnW = strAtoW( dn );
 308         if (!dnW) goto exit;
 309     }
 310     if (attr) {
 311         attrW = strAtoW( attr );
 312         if (!attrW) goto exit;
 313     }
 314     if (value) {
 315         valueW = strAtoW( value );
 316         if (!valueW) goto exit;
 317     }
 318     if (serverctrls) {
 319         serverctrlsW = controlarrayAtoW( serverctrls );
 320         if (!serverctrlsW) goto exit;
 321     }
 322     if (clientctrls) {
 323         clientctrlsW = controlarrayAtoW( clientctrls );
 324         if (!clientctrlsW) goto exit;
 325     }
 326
 327     ret = ldap_compare_ext_sW( ld, dnW, attrW, valueW, data, serverctrlsW,
 328                                clientctrlsW );
 329
 330 exit:
 331     strfreeW( dnW );
 332     strfreeW( attrW );
 333     strfreeW( valueW );
 334     controlarrayfreeW( serverctrlsW );
 335     controlarrayfreeW( clientctrlsW );
 336
 337 #endif
 338     return ret;
 339 }
 340
 341 /***********************************************************************
 342  *      ldap_compare_ext_sW     (WLDAP32.@)
 343  *
 344  * Check if an attribute has a certain value (synchronous operation).
 345  *
 346  * PARAMS
 347  *  ld          [I] Pointer to an LDAP context.
 348  *  dn          [I] DN of entry to compare value for.
 349  *  attr        [I] Attribute to compare value for.
 350  *  value       [I] string encoded value to compare.
 351  *  data        [I] berval encoded value to compare.
 352  *  serverctrls [I] Array of LDAP server controls.
 353  *  clientctrls [I] Array of LDAP client controls.
 354  *
 355  * RETURNS
 356  *  Success: LDAP_SUCCESS
 357  *  Failure: An LDAP error code.
 358  *
 359  * NOTES
 360  *  Set value to compare strings or data to compare binary values. If
 361  *  both are non-NULL, data will be used. The serverctrls and clientctrls
 362  *  parameters are optional and should be set to NULL if not used.
 363  */
 364 ULONG CDECL ldap_compare_ext_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value,
 365     struct WLDAP32_berval *data, PLDAPControlW *serverctrls, PLDAPControlW *clientctrls )
 366 {
 367     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 368 #ifdef HAVE_LDAP
 369     char *dnU = NULL, *attrU = NULL, *valueU = NULL;
 370     LDAPControl **serverctrlsU = NULL, **clientctrlsU = NULL;
 371     struct berval val = { 0, NULL };
 372
 373     ret = WLDAP32_LDAP_NO_MEMORY;
 374
 375     TRACE( "(%p, %s, %s, %s, %p, %p, %p)\n", ld, debugstr_w(dn),
 376            debugstr_w(attr), debugstr_w(value), data, serverctrls,
 377            clientctrls );
 378
 379     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 380
 381     if (dn) {
 382         dnU = strWtoU( dn );
 383         if (!dnU) goto exit;
 384     }
 385     if (attr) {
 386         attrU = strWtoU( attr );
 387         if (!attrU) goto exit;
 388     }
 389     if (!data) {
 390         if (value) {
 391             valueU = strWtoU( value );
 392             if (!valueU) goto exit;
 393
 394             val.bv_len = strlen( valueU );
 395             val.bv_val = valueU;
 396         }
 397     }
 398     if (serverctrls) {
 399         serverctrlsU = controlarrayWtoU( serverctrls );
 400         if (!serverctrlsU) goto exit;
 401     }
 402     if (clientctrls) {
 403         clientctrlsU = controlarrayWtoU( clientctrls );
 404         if (!clientctrlsU) goto exit;
 405     }
 406
 407     ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "",
 408                                          data ? (struct berval *)data : &val,
 409                                          serverctrlsU, clientctrlsU ));
 410
 411 exit:
 412     strfreeU( dnU );
 413     strfreeU( attrU );
 414     strfreeU( valueU );
 415     controlarrayfreeU( serverctrlsU );
 416     controlarrayfreeU( clientctrlsU );
 417
 418 #endif
 419     return ret;
 420 }
 421
 422 /***********************************************************************
 423  *      ldap_compare_sA     (WLDAP32.@)
 424  *
 425  * See ldap_compare_sW.
 426  */
 427 ULONG CDECL ldap_compare_sA( WLDAP32_LDAP *ld, PCHAR dn, PCHAR attr, PCHAR value )
 428 {
 429     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 430 #ifdef HAVE_LDAP
 431     WCHAR *dnW = NULL, *attrW = NULL, *valueW = NULL;
 432
 433     ret = WLDAP32_LDAP_NO_MEMORY;
 434
 435     TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_a(dn), debugstr_a(attr),
 436            debugstr_a(value) );
 437
 438     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 439
 440     if (dn) {
 441         dnW = strAtoW( dn );
 442         if (!dnW) goto exit;
 443     }
 444     if (attr) {
 445         attrW = strAtoW( attr );
 446         if (!attrW) goto exit;
 447     }
 448     if (value) {
 449         valueW = strAtoW( value );
 450         if (!valueW) goto exit;
 451     }
 452
 453     ret = ldap_compare_sW( ld, dnW, attrW, valueW );
 454
 455 exit:
 456     strfreeW( dnW );
 457     strfreeW( attrW );
 458     strfreeW( valueW );
 459
 460 #endif
 461     return ret;
 462 }
 463
 464 /***********************************************************************
 465  *      ldap_compare_sW     (WLDAP32.@)
 466  *
 467  * Check if an attribute has a certain value (synchronous operation).
 468  *
 469  * PARAMS
 470  *  ld      [I] Pointer to an LDAP context.
 471  *  dn      [I] DN of entry to compare value for.
 472  *  attr    [I] Attribute to compare value for.
 473  *  value   [I] Value to compare.
 474  *
 475  * RETURNS
 476  *  Success: LDAP_SUCCESS
 477  *  Failure: An LDAP error code.
 478  */
 479 ULONG CDECL ldap_compare_sW( WLDAP32_LDAP *ld, PWCHAR dn, PWCHAR attr, PWCHAR value )
 480 {
 481     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 482 #ifdef HAVE_LDAP
 483     char *dnU = NULL, *attrU = NULL, *valueU = NULL;
 484     struct berval val = { 0, NULL };
 485
 486     ret = WLDAP32_LDAP_NO_MEMORY;
 487
 488     TRACE( "(%p, %s, %s, %s)\n", ld, debugstr_w(dn), debugstr_w(attr),
 489            debugstr_w(value) );
 490
 491     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 492
 493     if (dn) {
 494         dnU = strWtoU( dn );
 495         if (!dnU) goto exit;
 496     }
 497     if (attr) {
 498         attrU = strWtoU( attr );
 499         if (!attrU) goto exit;
 500     }
 501     if (value) {
 502         valueU = strWtoU( value );
 503         if (!valueU) goto exit;
 504
 505         val.bv_len = strlen( valueU );
 506         val.bv_val = valueU;
 507     }
 508
 509     ret = map_error( ldap_compare_ext_s( ld, dn ? dnU : "", attr ? attrU : "", &val, NULL, NULL ));
 510
 511 exit:
 512     strfreeU( dnU );
 513     strfreeU( attrU );
 514     strfreeU( valueU );
 515
 516 #endif
 517     return ret;
 518 }