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