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 (!ld) return ~0u;
 102     return ldap_count_entries( CTX(ld), MSG(res) );
 103 }
 104
 105 /***********************************************************************
 106  *      ldap_count_references     (WLDAP32.@)
 107  */
 108 ULONG CDECL WLDAP32_ldap_count_references( LDAP *ld, WLDAP32_LDAPMessage *res )
 109 {
 110     TRACE( "(%p, %p)\n", ld, res );
 111
 112     if (!ld) return 0;
 113     return ldap_count_references( CTX(ld), MSG(res) );
 114 }
 115
 116 static ULONG get_escape_size( PCHAR src, ULONG srclen )
 117 {
 118     ULONG i, size = 0;
 119
 120     if (src)
 121     {
 122         for (i = 0; i < srclen; i++)
 123         {
 124             if ((src[i] >= '0' && src[i] <= '9') ||
 125                 (src[i] >= 'A' && src[i] <= 'Z') ||
 126                 (src[i] >= 'a' && src[i] <= 'z'))
 127                 size++;
 128             else
 129                 size += 3;
 130         }
 131     }
 132     return size + 1;
 133 }
 134
 135 static void escape_filter_element( char *src, ULONG srclen, char *dst )
 136 {
 137     ULONG i;
 138     static const char fmt[] = "\\%02X";
 139     char *d = dst;
 140
 141     for (i = 0; i < srclen; i++)
 142     {
 143         if ((src[i] >= '0' && src[i] <= '9') ||
 144             (src[i] >= 'A' && src[i] <= 'Z') ||
 145             (src[i] >= 'a' && src[i] <= 'z'))
 146             *d++ = src[i];
 147         else
 148             d += sprintf( d, fmt, (unsigned char)src[i] );
 149     }
 150     *++d = 0;
 151 }
 152
 153 /***********************************************************************
 154  *      ldap_escape_filter_elementA     (WLDAP32.@)
 155  */
 156 ULONG CDECL ldap_escape_filter_elementA( char *src, ULONG srclen, char *dst, ULONG dstlen )
 157 {
 158     ULONG len = get_escape_size( src, srclen );
 159
 160     TRACE( "(%p, %#lx, %p, %#lx)\n", src, srclen, dst, dstlen );
 161
 162     if (!dst) return len;
 163     if (!src || dstlen < len) return WLDAP32_LDAP_PARAM_ERROR;
 164
 165     escape_filter_element( src, srclen, dst );
 166     return WLDAP32_LDAP_SUCCESS;
 167 }
 168
 169 /***********************************************************************
 170  *      ldap_escape_filter_elementW     (WLDAP32.@)
 171  */
 172 ULONG CDECL ldap_escape_filter_elementW( char *src, ULONG srclen, WCHAR *dst, ULONG dstlen )
 173 {
 174     ULONG len = get_escape_size( src, srclen );
 175
 176     TRACE( "(%p, %#lx, %p, %#lx)\n", src, srclen, dst, dstlen );
 177
 178     if (!dst) return len;
 179
 180     /* no matter what you throw at it, this is what native returns */
 181     return WLDAP32_LDAP_PARAM_ERROR;
 182 }
 183
 184 /***********************************************************************
 185  *      ldap_first_attributeA     (WLDAP32.@)
 186  */
 187 char * CDECL ldap_first_attributeA( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement **ber )
 188 {
 189     char *ret = NULL;
 190     WCHAR *retW;
 191
 192     TRACE( "(%p, %p, %p)\n", ld, entry, ber );
 193
 194     if (!ld || !entry) return NULL;
 195
 196     retW = ldap_first_attributeW( ld, entry, ber );
 197     if (retW)
 198     {
 199         ret = strWtoA( retW );
 200         ldap_memfreeW( retW );
 201     }
 202
 203     return ret;
 204 }
 205
 206 /***********************************************************************
 207  *      ldap_first_attributeW     (WLDAP32.@)
 208  */
 209 WCHAR * CDECL ldap_first_attributeW( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement **ptr )
 210 {
 211     WCHAR *ret = NULL;
 212     WLDAP32_BerElement *ber;
 213     char *retU;
 214     BerElement *berU;
 215
 216     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 217
 218     if (ld && entry) retU = ldap_first_attribute( CTX(ld), MSG(entry), &berU );
 219     else return NULL;
 220
 221     if (!retU)
 222         return NULL;
 223
 224     if (!(ber = malloc( sizeof(*ber) )))
 225     {
 226         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 227         ldap_memfree( retU );
 228         return NULL;
 229     }
 230
 231     ber->opaque = (char *)berU;
 232     *ptr = ber;
 233     ret = strUtoW( retU );
 234     ldap_memfree( retU );
 235     return ret;
 236 }
 237
 238 /***********************************************************************
 239  *      ldap_first_entry     (WLDAP32.@)
 240 */
 241 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_entry( LDAP *ld, WLDAP32_LDAPMessage *res )
 242 {
 243     LDAPMessage *msgU;
 244
 245     TRACE( "(%p, %p)\n", ld, res );
 246
 247     if (ld && res && (msgU = ldap_first_entry( CTX(ld), MSG(res) )))
 248     {
 249         assert( msgU == MSG(res) );
 250         return res;
 251     }
 252     return NULL;
 253 }
 254
 255 /***********************************************************************
 256  *      ldap_first_reference     (WLDAP32.@)
 257  */
 258 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_first_reference( LDAP *ld, WLDAP32_LDAPMessage *res )
 259 {
 260     LDAPMessage *msgU;
 261
 262     TRACE( "(%p, %p)\n", ld, res );
 263
 264     if (ld && (msgU = ldap_first_reference( CTX(ld), MSG(res) )))
 265     {
 266         assert( msgU == MSG(res) );
 267         return res;
 268     }
 269     return NULL;
 270 }
 271
 272 /***********************************************************************
 273  *      ldap_memfreeA     (WLDAP32.@)
 274  */
 275 void CDECL ldap_memfreeA( char *block )
 276 {
 277     TRACE( "(%p)\n", block );
 278     free( block );
 279 }
 280
 281 /***********************************************************************
 282  *      ldap_memfreeW     (WLDAP32.@)
 283  */
 284 void CDECL ldap_memfreeW( WCHAR *block )
 285 {
 286     TRACE( "(%p)\n", block );
 287     free( block );
 288 }
 289
 290 /***********************************************************************
 291  *      ldap_msgfree     (WLDAP32.@)
 292  */
 293 ULONG CDECL WLDAP32_ldap_msgfree( WLDAP32_LDAPMessage *res )
 294 {
 295     WLDAP32_LDAPMessage *entry, *list = res;
 296
 297     TRACE( "(%p)\n", res );
 298
 299     if (!res) return WLDAP32_LDAP_SUCCESS;
 300
 301     ldap_msgfree( MSG(res) );
 302     while (list)
 303     {
 304         entry = list;
 305         list = entry->lm_next;
 306         free( entry );
 307     }
 308
 309     return WLDAP32_LDAP_SUCCESS;
 310 }
 311
 312 /***********************************************************************
 313  *      ldap_next_attributeA     (WLDAP32.@)
 314  */
 315 char * CDECL ldap_next_attributeA( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement *ptr )
 316 {
 317     char *ret = NULL;
 318     WCHAR *retW;
 319
 320     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 321
 322     if (!ld || !entry || !ptr) return NULL;
 323
 324     retW = ldap_next_attributeW( ld, entry, ptr );
 325     if (retW)
 326     {
 327         ret = strWtoA( retW );
 328         ldap_memfreeW( retW );
 329     }
 330
 331     return ret;
 332 }
 333
 334 /***********************************************************************
 335  *      ldap_next_attributeW     (WLDAP32.@)
 336  */
 337 WCHAR * CDECL ldap_next_attributeW( LDAP *ld, WLDAP32_LDAPMessage *entry, WLDAP32_BerElement *ptr )
 338 {
 339     WCHAR *ret = NULL;
 340     char *retU;
 341
 342     TRACE( "(%p, %p, %p)\n", ld, entry, ptr );
 343
 344     if (ld && entry && ptr && (retU = ldap_next_attribute( CTX(ld), MSG(entry), BER(ptr) )))
 345     {
 346         ret = strUtoW( retU );
 347         ldap_memfree( retU );
 348     }
 349     return ret;
 350 }
 351
 352 /***********************************************************************
 353  *      ldap_next_entry     (WLDAP32.@)
 354  */
 355 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_entry( LDAP *ld, WLDAP32_LDAPMessage *entry )
 356 {
 357     WLDAP32_LDAPMessage *msg = NULL;
 358     LDAPMessage *msgU;
 359
 360     TRACE( "(%p, %p)\n", ld, entry );
 361
 362     if (!ld || !entry) return NULL;
 363
 364     if (entry->lm_next) return entry->lm_next;
 365
 366     msgU = ldap_next_entry( CTX(ld), MSG(entry) );
 367
 368     if (!msgU)
 369         return NULL;
 370
 371     if (!(msg = calloc( 1, sizeof(*msg) )))
 372     {
 373         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 374         return NULL;
 375     }
 376
 377     MSG(msg) = msgU;
 378     entry->lm_next = msg;
 379     return msg;
 380 }
 381
 382 /***********************************************************************
 383  *      ldap_next_reference     (WLDAP32.@)
 384  */
 385 WLDAP32_LDAPMessage * CDECL WLDAP32_ldap_next_reference( LDAP *ld, WLDAP32_LDAPMessage *entry )
 386 {
 387     WLDAP32_LDAPMessage *msg = NULL;
 388     LDAPMessage *msgU;
 389
 390     TRACE( "(%p, %p)\n", ld, entry );
 391
 392     if (!ld || !entry) return NULL;
 393
 394     if (entry->lm_next) return entry->lm_next;
 395
 396     msgU = ldap_next_reference( CTX(ld), MSG(entry) );
 397
 398     if (!msgU)
 399         return NULL;
 400
 401     if (!(msg = calloc( 1, sizeof(*msg) )))
 402     {
 403         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 404         return NULL;
 405     }
 406
 407     MSG(msg) = msgU;
 408     entry->lm_next = msg;
 409     return msg;
 410 }
 411
 412 /***********************************************************************
 413  *      ldap_result     (WLDAP32.@)
 414  */
 415 ULONG CDECL WLDAP32_ldap_result( LDAP *ld, ULONG msgid, ULONG all, struct l_timeval *timeout, WLDAP32_LDAPMessage **res )
 416 {
 417     WLDAP32_LDAPMessage *msg;
 418     struct timeval timeval;
 419     LDAPMessage *msgU = NULL;
 420     ULONG ret = ~0u;
 421
 422     TRACE( "(%p, %#lx, %#lx, %p, %p)\n", ld, msgid, all, timeout, res );
 423
 424     if (ld && res && msgid != ~0u)
 425     {
 426         if (timeout)
 427         {
 428             timeval.tv_sec = timeout->tv_sec;
 429             timeval.tv_usec = timeout->tv_usec;
 430         }
 431
 432         ret = ldap_result( CTX(ld), msgid, all, timeout ? &timeval : NULL, &msgU );
 433     }
 434
 435     if (!msgU)
 436         return ret;
 437
 438     if (!(msg = calloc( 1, sizeof(*msg) )))
 439     {
 440         free( msgU );
 441         return WLDAP32_LDAP_NO_MEMORY;
 442     }
 443
 444     MSG(msg) = msgU;
 445     *res = msg;
 446     return ret;
 447 }
 448
 449 /***********************************************************************
 450  *      LdapUnicodeToUTF8     (WLDAP32.@)
 451  */
 452 int CDECL LdapUnicodeToUTF8( const WCHAR *src, int srclen, char *dst, int dstlen )
 453 {
 454     return WideCharToMultiByte( CP_UTF8, 0, src, srclen, dst, dstlen, NULL, NULL );
 455 }
 456
 457 /***********************************************************************
 458  *      LdapUTF8ToUnicode     (WLDAP32.@)
 459  */
 460 int CDECL LdapUTF8ToUnicode( const char *src, int srclen, WCHAR *dst, int dstlen )
 461 {
 462     return MultiByteToWideChar( CP_UTF8, 0, src, srclen, dst, dstlen );
 463 }