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 <stdarg.h>
  22 #include <stdlib.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winnls.h"
  26 #include "winsock2.h"
  27
  28 #include "wine/debug.h"
  29 #include "winldap_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  32
  33 /***********************************************************************
  34  *      ldap_abandon     (WLDAP32.@)
  35  */
  36 ULONG CDECL WLDAP32_ldap_abandon( LDAP *ld, ULONG msgid )
  37 {
  38     TRACE( "(%p, %#lx)\n", ld, msgid );
  39
  40     if (!ld) return ~0u;
  41     return map_error( ldap_abandon_ext( CTX(ld), msgid, NULL, NULL ) );
  42 }
  43
  44 /***********************************************************************
  45  *      ldap_check_filterA     (WLDAP32.@)
  46  */
  47 ULONG CDECL ldap_check_filterA( LDAP *ld, char *filter )
  48 {
  49     ULONG ret;
  50     WCHAR *filterW = NULL;
  51
  52     TRACE( "(%p, %s)\n", ld, debugstr_a(filter) );
  53
  54     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  55     if (filter && !(filterW = strAtoW( filter ))) return WLDAP32_LDAP_NO_MEMORY;
  56
  57     ret = ldap_check_filterW( ld, filterW );
  58
  59     free( filterW );
  60     return ret;
  61 }
  62
  63 /***********************************************************************
  64  *      ldap_check_filterW     (WLDAP32.@)
  65  */
  66 ULONG CDECL ldap_check_filterW( LDAP *ld, WCHAR *filter )
  67 {
  68     TRACE( "(%p, %s)\n", ld, debugstr_w(filter) );
  69
  70     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  71     return WLDAP32_LDAP_SUCCESS; /* FIXME: do some checks */
  72 }
  73
  74 /***********************************************************************
  75  *      ldap_cleanup     (WLDAP32.@)
  76  */
  77 ULONG CDECL ldap_cleanup( HANDLE instance )
  78 {
  79     TRACE( "(%p)\n", instance );
  80     return WLDAP32_LDAP_SUCCESS;
  81 }
  82
  83 /***********************************************************************
  84  *      ldap_conn_from_msg     (WLDAP32.@)
  85  */
  86 LDAP * CDECL ldap_conn_from_msg( LDAP *ld, WLDAP32_LDAPMessage *res )
  87 {
  88     TRACE( "(%p, %p)\n", ld, res );
  89
  90     if (!ld || !res) return NULL;
  91     return ld; /* FIXME: not always correct */
  92 }
  93
  94 /***********************************************************************
  95  *      ldap_count_entries     (WLDAP32.@)
  96  */
  97 ULONG CDECL WLDAP32_ldap_count_entries( LDAP *ld, WLDAP32_LDAPMessage *res )
  98 {
  99     TRACE( "(%p, %p)\n", ld, res );
 100
 101     if (!res) return 0;
 102     if (!ld) return ~0u;
 103     return ldap_count_entries( CTX(ld), MSG(res) );
 104 }
 105
 106 /***********************************************************************
 107  *      ldap_count_references     (WLDAP32.@)
 108  */
 109 ULONG CDECL WLDAP32_ldap_count_references( LDAP *ld, WLDAP32_LDAPMessage *res )
 110 {
 111     TRACE( "(%p, %p)\n", ld, res );
 112
 113     if (!ld) return 0;
 114     return ldap_count_references( CTX(ld), MSG(res) );
 115 }
 116
 117 static ULONG get_escape_size( PCHAR src, ULONG srclen )
 118 {
 119     ULONG i, size = 0;
 120
 121     if (src)
 122     {
 123         for (i = 0; i < srclen; i++)
 124         {
 125             if ((src[i] >= '0' && src[i] <= '9') ||
 126                 (src[i] >= 'A' && src[i] <= 'Z') ||
 127                 (src[i] >= 'a' && src[i] <= 'z'))
 128                 size++;
 129             else
 130                 size += 3;
 131         }
 132     }
 133     return size + 1;
 134 }
 135
 136 static void escape_filter_element( char *src, ULONG srclen, char *dst )
 137 {
 138     ULONG i;
 139     static const char fmt[] = "\\%02X";
 140     char *d = dst;
 141
 142     for (i = 0; i < srclen; i++)
 143     {
 144         if ((src[i] >= '0' && src[i] <= '9') ||
 145             (src[i] >= 'A' && src[i] <= 'Z') ||
 146             (src[i] >= 'a' && src[i] <= 'z'))
 147             *d++ = src[i];
 148         else
 149             d += sprintf( d, fmt, (unsigned char)src[i] );
 150     }
 151     *++d = 0;
 152 }
 153
 154 /***********************************************************************
 155  *      ldap_escape_filter_elementA     (WLDAP32.@)
 156  */
 157 ULONG CDECL ldap_escape_filter_elementA( char *src, ULONG srclen, char *dst, ULONG dstlen )
 158 {
 159     ULONG len = get_escape_size( src, srclen );
 160
 161     TRACE( "(%p, %#lx, %p, %#lx)\n", src, srclen, dst, dstlen );
 162
 163     if (!dst) return len;
 164     if (!src || dstlen < len) return WLDAP32_LDAP_PARAM_ERROR;
 165
 166     escape_filter_element( src, srclen, dst );
 167     return WLDAP32_LDAP_SUCCESS;
 168 }
 169
 170 /***********************************************************************
 171  *      ldap_escape_filter_elementW     (WLDAP32.@)
 172  */
 173 ULONG CDECL ldap_escape_filter_elementW( char *src, ULONG srclen, WCHAR *dst, ULONG dstlen )
 174 {
 175     ULONG len = get_escape_size( src, srclen );
 176
 177     TRACE( "(%p, %#lx, %p, %#lx)\n", src, srclen, dst, dstlen );
 178
 179     if (!dst) return len;
 180
 181     /* no matter what you throw at it, this is what native returns */
 182     return WLDAP32_LDAP_PARAM_ERROR;
 183 }
 184
 185 /***********************************************************************
 186  *      ldap_first_attributeA     (WLDAP32.@)
 187  */
 188 char * CDECL ldap_first_attributeA( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement **ber )
 189 {
 190     char *ret = NULL;
 191     WCHAR *retW;
 192
 193     TRACE( "(%p, %p, %p)\n", ld, entry, ber );
 194
 195     if (!ld || !entry) return NULL;
 196
 197     retW = ldap_first_attributeW( ld, entry, ber );
 198     if (retW)
 199     {
 200         ret = strWtoA( retW );
 201         ldap_memfreeW( retW );
 202     }
 203
 204     return ret;
 205 }
 206
 207 /***********************************************************************
 208  *      ldap_first_attributeW     (WLDAP32.@)
 209  */
 210 WCHAR * CDECL ldap_first_attributeW( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement **ptr )
 211 {
 212     WCHAR *ret = NULL;
 213     WLDAP32_BerElement *ber;
 214     char *retU;
 215     BerElement *berU;
 216
 217     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 218
 219     if (ld && entry) retU = ldap_first_attribute( CTX(ld), MSG(entry), &berU );
 220     else return NULL;
 221
 222     if (!retU)
 223         return NULL;
 224
 225     if (!(ber = malloc( sizeof(*ber) )))
 226     {
 227         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 228         ldap_memfree( retU );
 229         return NULL;
 230     }
 231
 232     ber->opaque = (char *)berU;
 233     *ptr = ber;
 234     ret = strUtoW( retU );
 235     ldap_memfree( retU );
 236     return ret;
 237 }
 238
 239 /***********************************************************************
 240  *      ldap_first_entry     (WLDAP32.@)
 241 */
 242 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_entry( LDAP *ld, WLDAP32_LDAPMessage *res )
 243 {
 244     LDAPMessage *msgU;
 245
 246     TRACE( "(%p, %p)\n", ld, res );
 247
 248     if (ld && res && (msgU = ldap_first_entry( CTX(ld), MSG(res) )))
 249     {
 250         assert( msgU == MSG(res) );
 251         return res;
 252     }
 253     return NULL;
 254 }
 255
 256 /***********************************************************************
 257  *      ldap_first_reference     (WLDAP32.@)
 258  */
 259 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_reference( LDAP *ld, WLDAP32_LDAPMessage *res )
 260 {
 261     LDAPMessage *msgU;
 262
 263     TRACE( "(%p, %p)\n", ld, res );
 264
 265     if (ld && (msgU = ldap_first_reference( CTX(ld), MSG(res) )))
 266     {
 267         assert( msgU == MSG(res) );
 268         return res;
 269     }
 270     return NULL;
 271 }
 272
 273 /***********************************************************************
 274  *      ldap_memfreeA     (WLDAP32.@)
 275  */
 276 void CDECL ldap_memfreeA( char *block )
 277 {
 278     TRACE( "(%p)\n", block );
 279     free( block );
 280 }
 281
 282 /***********************************************************************
 283  *      ldap_memfreeW     (WLDAP32.@)
 284  */
 285 void CDECL ldap_memfreeW( WCHAR *block )
 286 {
 287     TRACE( "(%p)\n", block );
 288     free( block );
 289 }
 290
 291 /***********************************************************************
 292  *      ldap_msgfree     (WLDAP32.@)
 293  */
 294 ULONG CDECL WLDAP32_ldap_msgfree( WLDAP32_LDAPMessage *res )
 295 {
 296     WLDAP32_LDAPMessage *entry, *list = res;
 297
 298     TRACE( "(%p)\n", res );
 299
 300     if (!res) return WLDAP32_LDAP_SUCCESS;
 301
 302     ldap_msgfree( MSG(res) );
 303     while (list)
 304     {
 305         entry = list;
 306         list = entry->lm_next;
 307         free( entry );
 308     }
 309
 310     return WLDAP32_LDAP_SUCCESS;
 311 }
 312
 313 /***********************************************************************
 314  *      ldap_next_attributeA     (WLDAP32.@)
 315  */
 316 char * CDECL ldap_next_attributeA( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement *ptr )
 317 {
 318     char *ret = NULL;
 319     WCHAR *retW;
 320
 321     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 322
 323     if (!ld || !entry || !ptr) return NULL;
 324
 325     retW = ldap_next_attributeW( ld, entry, ptr );
 326     if (retW)
 327     {
 328         ret = strWtoA( retW );
 329         ldap_memfreeW( retW );
 330     }
 331
 332     return ret;
 333 }
 334
 335 /***********************************************************************
 336  *      ldap_next_attributeW     (WLDAP32.@)
 337  */
 338 WCHAR * CDECL ldap_next_attributeW( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement *ptr )
 339 {
 340     WCHAR *ret = NULL;
 341     char *retU;
 342
 343     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 344
 345     if (ld && entry && ptr && (retU = ldap_next_attribute( CTX(ld), MSG(entry), BER(ptr) )))
 346     {
 347         ret = strUtoW( retU );
 348         ldap_memfree( retU );
 349     }
 350     return ret;
 351 }
 352
 353 /***********************************************************************
 354  *      ldap_next_entry     (WLDAP32.@)
 355  */
 356 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_entry( LDAP *ld, WLDAP32_LDAPMessage *entry )
 357 {
 358     WLDAP32_LDAPMessage *msg = NULL;
 359     LDAPMessage *msgU;
 360
 361     TRACE( "(%p, %p)\n", ld, entry );
 362
 363     if (!ld || !entry) return NULL;
 364
 365     if (entry->lm_next) return entry->lm_next;
 366
 367     msgU = ldap_next_entry( CTX(ld), MSG(entry) );
 368
 369     if (!msgU)
 370         return NULL;
 371
 372     if (!(msg = calloc( 1, sizeof(*msg) )))
 373     {
 374         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 375         return NULL;
 376     }
 377
 378     MSG(msg) = msgU;
 379     entry->lm_next = msg;
 380     return msg;
 381 }
 382
 383 /***********************************************************************
 384  *      ldap_next_reference     (WLDAP32.@)
 385  */
 386 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_reference( LDAP *ld, WLDAP32_LDAPMessage *entry )
 387 {
 388     WLDAP32_LDAPMessage *msg = NULL;
 389     LDAPMessage *msgU;
 390
 391     TRACE( "(%p, %p)\n", ld, entry );
 392
 393     if (!ld || !entry) return NULL;
 394
 395     if (entry->lm_next) return entry->lm_next;
 396
 397     msgU = ldap_next_reference( CTX(ld), MSG(entry) );
 398
 399     if (!msgU)
 400         return NULL;
 401
 402     if (!(msg = calloc( 1, sizeof(*msg) )))
 403     {
 404         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 405         return NULL;
 406     }
 407
 408     MSG(msg) = msgU;
 409     entry->lm_next = msg;
 410     return msg;
 411 }
 412
 413 /***********************************************************************
 414  *      ldap_result     (WLDAP32.@)
 415  */
 416 ULONG CDECL WLDAP32_ldap_result( LDAP *ld, ULONG msgid, ULONG all, struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
 417 {
 418     WLDAP32_LDAPMessage *msg;
 419     struct timeval timeval;
 420     LDAPMessage *msgU = NULL;
 421     ULONG ret = ~0u;
 422
 423     TRACE( "(%p, %#lx, %#lx, %p, %p)\n", ld, msgid, all, timeout, res );
 424
 425     if (ld && res && msgid != ~0u)
 426     {
 427         if (timeout)
 428         {
 429             timeval.tv_sec = timeout->tv_sec;
 430             timeval.tv_usec = timeout->tv_usec;
 431         }
 432
 433         ret = ldap_result( CTX(ld), msgid, all, timeout ? &timeval : NULL, &msgU );
 434     }
 435
 436     if (!msgU)
 437         return ret;
 438
 439     if (!(msg = calloc( 1, sizeof(*msg) )))
 440     {
 441         free( msgU );
 442         return WLDAP32_LDAP_NO_MEMORY;
 443     }
 444
 445     MSG(msg) = msgU;
 446     *res = msg;
 447     return ret;
 448 }
 449
 450 /***********************************************************************
 451  *      ldap_set_dbg_flags     (WLDAP32.@)
 452  */
 453 ULONG CDECL ldap_set_dbg_flags( ULONG flags )
 454 {
 455     FIXME( "(0x%lx) stub\n", flags );
 456     return 0;
 457 }
 458
 459 /***********************************************************************
 460  *      LdapUnicodeToUTF8     (WLDAP32.@)
 461  */
 462 int CDECL LdapUnicodeToUTF8( const WCHAR *src, int srclen, char *dst, int dstlen )
 463 {
 464     return WideCharToMultiByte( CP_UTF8, 0, src, srclen, dst, dstlen, NULL, NULL );
 465 }
 466
 467 /***********************************************************************
 468  *      LdapUTF8ToUnicode     (WLDAP32.@)
 469  */
 470 int CDECL LdapUTF8ToUnicode( const char *src, int srclen, WCHAR *dst, int dstlen )
 471 {
 472     return MultiByteToWideChar( CP_UTF8, 0, src, srclen, dst, dstlen );
 473 }