dlls/wldap32/misc.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 #include <stdio.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winnls.h"
  32
  33 #ifdef HAVE_LDAP_H
  34 #include <ldap.h>
  35 #else
  36 #define LDAP_SUCCESS        0x00
  37 #define LDAP_NOT_SUPPORTED  0x5c
  38 #endif
  39
  40 #include "winldap_private.h"
  41 #include "wldap32.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  44
  45 /***********************************************************************
  46  *      ldap_abandon     (WLDAP32.@)
  47  *
  48  * Cancel an asynchronous operation.
  49  *
  50  * PARAMS
  51  *  ld    [I] Pointer to an LDAP context.
  52  *  msgid [I] ID of the operation to cancel.
  53  *
  54  * RETURNS
  55  *  Success: LDAP_SUCCESS
  56  *  Failure: An LDAP error code.
  57  */
  58 ULONG CDECL WLDAP32_ldap_abandon( WLDAP32_LDAP *ld, ULONG msgid )
  59 {
  60     ULONG ret = LDAP_NOT_SUPPORTED;
  61 #ifdef HAVE_LDAP
  62
  63     TRACE( "(%p, 0x%08x)\n", ld, msgid );
  64
  65     if (!ld) return ~0UL;
  66     ret = ldap_abandon_ext( ld, msgid, NULL, NULL );
  67
  68 #endif
  69     return ret;
  70 }
  71
  72 /***********************************************************************
  73  *      ldap_check_filterA     (WLDAP32.@)
  74  *
  75  * See ldap_check_filterW.
  76  */
  77 ULONG CDECL ldap_check_filterA( WLDAP32_LDAP *ld, PCHAR filter )
  78 {
  79     ULONG ret;
  80     WCHAR *filterW = NULL;
  81
  82     TRACE( "(%p, %s)\n", ld, debugstr_a(filter) );
  83
  84     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  85
  86     if (filter) {
  87         filterW = strAtoW( filter );
  88         if (!filterW) return WLDAP32_LDAP_NO_MEMORY;
  89     }
  90
  91     ret = ldap_check_filterW( ld, filterW );
  92
  93     strfreeW( filterW );
  94     return ret;
  95 }
  96
  97 /***********************************************************************
  98  *      ldap_check_filterW     (WLDAP32.@)
  99  *
 100  * Check filter syntax.
 101  *
 102  * PARAMS
 103  *  ld     [I] Pointer to an LDAP context.
 104  *  filter [I] Filter string.
 105  *
 106  * RETURNS
 107  *  Success: LDAP_SUCCESS
 108  *  Failure: An LDAP error code.
 109  */
 110 ULONG CDECL ldap_check_filterW( WLDAP32_LDAP *ld, PWCHAR filter )
 111 {
 112     TRACE( "(%p, %s)\n", ld, debugstr_w(filter) );
 113
 114     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 115     return LDAP_SUCCESS; /* FIXME: do some checks */
 116 }
 117
 118 /***********************************************************************
 119  *      ldap_cleanup     (WLDAP32.@)
 120  */
 121 ULONG CDECL ldap_cleanup( HANDLE instance )
 122 {
 123     TRACE( "(%p)\n", instance );
 124     return LDAP_SUCCESS;
 125 }
 126
 127 /***********************************************************************
 128  *      ldap_conn_from_msg     (WLDAP32.@)
 129  *
 130  * Get the LDAP context for a given message.
 131  *
 132  * PARAMS
 133  *  ld  [I] Pointer to an LDAP context.
 134  *  res [I] LDAP message.
 135  *
 136  * RETURNS
 137  *  Success: Pointer to an LDAP context.
 138  *  Failure: NULL
 139  */
 140 WLDAP32_LDAP * CDECL ldap_conn_from_msg( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
 141 {
 142     TRACE( "(%p, %p)\n", ld, res );
 143
 144     if (!ld || !res) return NULL;
 145     return ld; /* FIXME: not always correct */
 146 }
 147
 148 /***********************************************************************
 149  *      ldap_count_entries     (WLDAP32.@)
 150  *
 151  * Count the number of entries returned from a search.
 152  *
 153  * PARAMS
 154  *  ld  [I] Pointer to an LDAP context.
 155  *  res [I] LDAP message.
 156  *
 157  * RETURNS
 158  *  Success: The number of entries.
 159  *  Failure: ~0UL
 160  */
 161 ULONG CDECL WLDAP32_ldap_count_entries( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
 162 {
 163     ULONG ret = LDAP_NOT_SUPPORTED;
 164 #ifdef HAVE_LDAP
 165
 166     TRACE( "(%p, %p)\n", ld, res );
 167
 168     if (!ld) return ~0UL;
 169     ret = ldap_count_entries( ld, res );
 170
 171 #endif
 172     return ret;
 173 }
 174
 175 /***********************************************************************
 176  *      ldap_count_references     (WLDAP32.@)
 177  *
 178  * Count the number of references returned from a search.
 179  *
 180  * PARAMS
 181  *  ld  [I] Pointer to an LDAP context.
 182  *  res [I] LDAP message.
 183  *
 184  * RETURNS
 185  *  Success: The number of references.
 186  *  Failure: ~0UL
 187  */
 188 ULONG CDECL WLDAP32_ldap_count_references( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
 189 {
 190     ULONG ret = LDAP_NOT_SUPPORTED;
 191 #ifdef HAVE_LDAP_COUNT_REFERENCES
 192
 193     TRACE( "(%p, %p)\n", ld, res );
 194
 195     if (!ld) return 0;
 196     ret = ldap_count_references( ld, res );
 197
 198 #endif
 199     return ret;
 200 }
 201
 202 static ULONG get_escape_size( PCHAR src, ULONG srclen )
 203 {
 204     ULONG i, size = 0;
 205
 206     if (src)
 207     {
 208         for (i = 0; i < srclen; i++)
 209         {
 210             if ((src[i] >= '0' && src[i] <= '9') ||
 211                 (src[i] >= 'A' && src[i] <= 'Z') ||
 212                 (src[i] >= 'a' && src[i] <= 'z'))
 213                 size++;
 214             else
 215                 size += 3;
 216         }
 217     }
 218     return size + 1;
 219 }
 220
 221 static void escape_filter_element( PCHAR src, ULONG srclen, PCHAR dst )
 222 {
 223     ULONG i;
 224     static const char fmt[] = "\\%02X";
 225     char *d = dst;
 226
 227     for (i = 0; i < srclen; i++)
 228     {
 229         if ((src[i] >= '0' && src[i] <= '9') ||
 230             (src[i] >= 'A' && src[i] <= 'Z') ||
 231             (src[i] >= 'a' && src[i] <= 'z'))
 232             *d++ = src[i];
 233         else
 234         {
 235             sprintf( d, fmt, (unsigned char)src[i] );
 236             d += 3;
 237         }
 238     }
 239     *++d = 0;
 240 }
 241
 242 /***********************************************************************
 243  *      ldap_escape_filter_elementA     (WLDAP32.@)
 244  *
 245  * See ldap_escape_filter_elementW.
 246  */
 247 ULONG CDECL ldap_escape_filter_elementA( PCHAR src, ULONG srclen, PCHAR dst, ULONG dstlen )
 248 {
 249     ULONG len;
 250
 251     TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
 252
 253     len = get_escape_size( src, srclen );
 254     if (!dst) return len;
 255
 256     if (!src || dstlen < len)
 257         return WLDAP32_LDAP_PARAM_ERROR;
 258     else
 259     {
 260         escape_filter_element( src, srclen, dst );
 261         return LDAP_SUCCESS;
 262     }
 263 }
 264
 265 /***********************************************************************
 266  *      ldap_escape_filter_elementW     (WLDAP32.@)
 267  *
 268  * Escape binary data for safe passing in filters.
 269  *
 270  * PARAMS
 271  *  src    [I] Filter element to be escaped.
 272  *  srclen [I] Length in bytes of the filter element.
 273  *  dst    [O] Destination buffer for the escaped filter element.
 274  *  dstlen [I] Length in bytes of the destination buffer.
 275  *
 276  * RETURNS
 277  *  Success: LDAP_SUCCESS
 278  *  Failure: An LDAP error code.
 279  */
 280 ULONG CDECL ldap_escape_filter_elementW( PCHAR src, ULONG srclen, PWCHAR dst, ULONG dstlen )
 281 {
 282     ULONG len;
 283
 284     TRACE( "(%p, 0x%08x, %p, 0x%08x)\n", src, srclen, dst, dstlen );
 285
 286     len = get_escape_size( src, srclen );
 287     if (!dst) return len;
 288
 289     /* no matter what you throw at it, this is what native returns */
 290     return WLDAP32_LDAP_PARAM_ERROR;
 291 }
 292
 293 /***********************************************************************
 294  *      ldap_first_attributeA     (WLDAP32.@)
 295  *
 296  * See ldap_first_attributeW.
 297  */
 298 PCHAR CDECL ldap_first_attributeA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
 299     WLDAP32_BerElement** ptr )
 300 {
 301     PCHAR ret = NULL;
 302 #ifdef HAVE_LDAP
 303     WCHAR *retW;
 304
 305     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 306
 307     if (!ld || !entry) return NULL;
 308     retW = ldap_first_attributeW( ld, entry, ptr );
 309
 310     ret = strWtoA( retW );
 311     ldap_memfreeW( retW );
 312
 313 #endif
 314     return ret;
 315 }
 316
 317 /***********************************************************************
 318  *      ldap_first_attributeW     (WLDAP32.@)
 319  *
 320  * Get the first attribute for a given entry.
 321  *
 322  * PARAMS
 323  *  ld    [I] Pointer to an LDAP context.
 324  *  entry [I] Entry to retrieve attribute for.
 325  *  ptr   [O] Position pointer.
 326  *
 327  * RETURNS
 328  *  Success: Name of the first attribute.
 329  *  Failure: NULL
 330  *
 331  * NOTES
 332  *  Use ldap_memfree to free the returned string.
 333  */
 334 PWCHAR CDECL ldap_first_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
 335     WLDAP32_BerElement** ptr )
 336 {
 337     PWCHAR ret = NULL;
 338 #ifdef HAVE_LDAP
 339     char *retU;
 340
 341     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 342
 343     if (!ld || !entry) return NULL;
 344     retU = ldap_first_attribute( ld, entry, ptr );
 345
 346     ret = strUtoW( retU );
 347     ldap_memfree( retU );
 348
 349 #endif
 350     return ret;
 351 }
 352
 353 /***********************************************************************
 354  *      ldap_first_entry     (WLDAP32.@)
 355  *
 356  * Get the first entry from a result message.
 357  *
 358  * PARAMS
 359  *  ld  [I] Pointer to an LDAP context.
 360  *  res [I] Search result message.
 361  *
 362  * RETURNS
 363  *  Success: The first entry.
 364  *  Failure: NULL
 365  *
 366  * NOTES
 367  *  The returned entry will be freed when the message is freed.
 368  */
 369 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_entry( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
 370 {
 371 #ifdef HAVE_LDAP
 372
 373     TRACE( "(%p, %p)\n", ld, res );
 374
 375     if (!ld || !res) return NULL;
 376     return ldap_first_entry( ld, res );
 377
 378 #else
 379     return NULL;
 380 #endif
 381 }
 382
 383 /***********************************************************************
 384  *      ldap_first_reference     (WLDAP32.@)
 385  *
 386  * Get the first reference from a result message.
 387  *
 388  * PARAMS
 389  *  ld  [I] Pointer to an LDAP context.
 390  *  res [I] Search result message.
 391  *
 392  * RETURNS
 393  *  Success: The first reference.
 394  *  Failure: NULL
 395  */
 396 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_reference( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *res )
 397 {
 398 #ifdef HAVE_LDAP_FIRST_REFERENCE
 399
 400     TRACE( "(%p, %p)\n", ld, res );
 401
 402     if (!ld) return NULL;
 403     return ldap_first_reference( ld, res );
 404
 405 #else
 406     return NULL;
 407 #endif
 408 }
 409
 410 /***********************************************************************
 411  *      ldap_memfreeA     (WLDAP32.@)
 412  *
 413  * See ldap_memfreeW.
 414  */
 415 void CDECL ldap_memfreeA( PCHAR block )
 416 {
 417     TRACE( "(%p)\n", block );
 418     strfreeA( block );
 419 }
 420
 421 /***********************************************************************
 422  *      ldap_memfreeW     (WLDAP32.@)
 423  *
 424  * Free a block of memory.
 425  *
 426  * PARAMS
 427  *  block [I] Pointer to memory block to be freed.
 428  */
 429 void CDECL ldap_memfreeW( PWCHAR block )
 430 {
 431     TRACE( "(%p)\n", block );
 432     strfreeW( block );
 433 }
 434
 435 /***********************************************************************
 436  *      ldap_msgfree     (WLDAP32.@)
 437  *
 438  * Free a message.
 439  *
 440  * PARAMS
 441  *  res [I] Message to be freed.
 442  */
 443 ULONG CDECL WLDAP32_ldap_msgfree( WLDAP32_LDAPMessage *res )
 444 {
 445     ULONG ret = LDAP_SUCCESS;
 446 #ifdef HAVE_LDAP
 447
 448     TRACE( "(%p)\n", res );
 449     ldap_msgfree( res );
 450
 451 #endif
 452     return ret;
 453 }
 454
 455 /***********************************************************************
 456  *      ldap_next_attributeA     (WLDAP32.@)
 457  *
 458  * See ldap_next_attributeW.
 459  */
 460 PCHAR CDECL ldap_next_attributeA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
 461     WLDAP32_BerElement *ptr )
 462 {
 463     PCHAR ret = NULL;
 464 #ifdef HAVE_LDAP
 465     WCHAR *retW;
 466
 467     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 468
 469     if (!ld || !entry || !ptr) return NULL;
 470     retW = ldap_next_attributeW( ld, entry, ptr );
 471
 472     ret = strWtoA( retW );
 473     ldap_memfreeW( retW );
 474
 475 #endif
 476     return ret;
 477 }
 478
 479 /***********************************************************************
 480  *      ldap_next_attributeW     (WLDAP32.@)
 481  *
 482  * Get the next attribute for a given entry.
 483  *
 484  * PARAMS
 485  *  ld    [I]   Pointer to an LDAP context.
 486  *  entry [I]   Entry to retrieve attribute for.
 487  *  ptr   [I/O] Position pointer.
 488  *
 489  * RETURNS
 490  *  Success: The name of the next attribute.
 491  *  Failure: NULL
 492  *
 493  * NOTES
 494  *  Free the returned string after each iteration with ldap_memfree.
 495  *  When done iterating and when ptr != NULL, call ber_free( ptr, 0 ).
 496  */
 497 PWCHAR CDECL ldap_next_attributeW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry,
 498     WLDAP32_BerElement *ptr )
 499 {
 500     PWCHAR ret = NULL;
 501 #ifdef HAVE_LDAP
 502     char *retU;
 503
 504     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 505
 506     if (!ld || !entry || !ptr) return NULL;
 507     retU = ldap_next_attribute( ld, entry, ptr );
 508
 509     ret = strUtoW( retU );
 510     ldap_memfree( retU );
 511
 512 #endif
 513     return ret;
 514 }
 515
 516 /***********************************************************************
 517  *      ldap_next_entry     (WLDAP32.@)
 518  *
 519  * Get the next entry from a result message.
 520  *
 521  * PARAMS
 522  *  ld    [I] Pointer to an LDAP context.
 523  *  entry [I] Entry returned by a previous call.
 524  *
 525  * RETURNS
 526  *  Success: The next entry.
 527  *  Failure: NULL
 528  *
 529  * NOTES
 530  *  The returned entry will be freed when the message is freed.
 531  */
 532 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_entry( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry )
 533 {
 534 #ifdef HAVE_LDAP
 535
 536     TRACE( "(%p, %p)\n", ld, entry );
 537
 538     if (!ld || !entry) return NULL;
 539     return ldap_next_entry( ld, entry );
 540
 541 #else
 542     return NULL;
 543 #endif
 544 }
 545
 546 /***********************************************************************
 547  *      ldap_next_reference     (WLDAP32.@)
 548  *
 549  * Get the next reference from a result message.
 550  *
 551  * PARAMS
 552  *  ld    [I] Pointer to an LDAP context.
 553  *  entry [I] Entry returned by a previous call.
 554  *
 555  * RETURNS
 556  *  Success: The next reference.
 557  *  Failure: NULL
 558  *
 559  * NOTES
 560  *  The returned entry will be freed when the message is freed.
 561  */
 562 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_reference( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *entry )
 563 {
 564 #ifdef HAVE_LDAP_NEXT_REFERENCE
 565
 566     TRACE( "(%p, %p)\n", ld, entry );
 567
 568     if (!ld || !entry) return NULL;
 569     return ldap_next_reference( ld, entry );
 570
 571 #else
 572     return NULL;
 573 #endif
 574 }
 575
 576 /***********************************************************************
 577  *      ldap_result     (WLDAP32.@)
 578  *
 579  * Get the result of an asynchronous operation.
 580  *
 581  * PARAMS
 582  *  ld      [I] Pointer to an LDAP context.
 583  *  msgid   [I] Message ID of the operation.
 584  *  all     [I] How many results should be returned?
 585  *  timeout [I] How long to wait for the results?
 586  *  res     [O] Result message for the operation.
 587  *
 588  * RETURNS
 589  *  Success: One of the following values:
 590  *
 591  *   LDAP_RES_ADD
 592  *   LDAP_RES_BIND
 593  *   LDAP_RES_COMPARE
 594  *   LDAP_RES_DELETE
 595  *   LDAP_RES_EXTENDED
 596  *   LDAP_RES_MODIFY
 597  *   LDAP_RES_MODRDN
 598  *   LDAP_RES_REFERRAL
 599  *   LDAP_RES_SEARCH_ENTRY
 600  *   LDAP_RES_SEARCH_RESULT
 601  *
 602  *  Failure: ~0UL
 603  *
 604  *  This function returns 0 when the timeout has expired.
 605  *
 606  * NOTES
 607  *  A NULL timeout pointer causes the function to block waiting
 608  *  for results to arrive. A timeout value of 0 causes the function
 609  *  to immediately return any available results. Free returned results
 610  *  with ldap_msgfree.
 611  */
 612 ULONG CDECL WLDAP32_ldap_result( WLDAP32_LDAP *ld, ULONG msgid, ULONG all,
 613     struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
 614 {
 615     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 616 #ifdef HAVE_LDAP
 617
 618     TRACE( "(%p, 0x%08x, 0x%08x, %p, %p)\n", ld, msgid, all, timeout, res );
 619
 620     if (!ld || !res || msgid == ~0UL) return ~0UL;
 621     ret = ldap_result( ld, msgid, all, (struct timeval *)timeout, res );
 622
 623 #endif
 624     return ret;
 625 }
 626
 627 /***********************************************************************
 628  *      LdapUnicodeToUTF8     (WLDAP32.@)
 629  *
 630  * Convert a wide character string to a UTF8 string.
 631  *
 632  * PARAMS
 633  *  src    [I] Wide character string to convert.
 634  *  srclen [I] Size of string to convert, in characters.
 635  *  dst    [O] Pointer to a buffer that receives the converted string.
 636  *  dstlen [I] Size of the destination buffer in characters.
 637  *
 638  * RETURNS
 639  *  The number of characters written into the destination buffer.
 640  *
 641  * NOTES
 642  *  Set dstlen to zero to ask for the required buffer size.
 643  */
 644 int CDECL LdapUnicodeToUTF8( LPCWSTR src, int srclen, LPSTR dst, int dstlen )
 645 {
 646     return WideCharToMultiByte( CP_UTF8, 0, src, srclen, dst, dstlen, NULL, NULL );
 647 }
 648
 649 /***********************************************************************
 650  *      LdapUTF8ToUnicode     (WLDAP32.@)
 651  *
 652  * Convert a UTF8 string to a wide character string.
 653  *
 654  * PARAMS
 655  *  src    [I] UTF8 string to convert.
 656  *  srclen [I] Size of string to convert, in characters.
 657  *  dst    [O] Pointer to a buffer that receives the converted string.
 658  *  dstlen [I] Size of the destination buffer in characters.
 659  *
 660  * RETURNS
 661  *  The number of characters written into the destination buffer.
 662  *
 663  * NOTES
 664  *  Set dstlen to zero to ask for the required buffer size.
 665  */
 666 int CDECL LdapUTF8ToUnicode( LPCSTR src, int srclen, LPWSTR dst, int dstlen )
 667 {
 668     return MultiByteToWideChar( CP_UTF8, 0, src, srclen, dst, dstlen );
 669 }