dlls/wldap32/ber.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 <stdarg.h>
  24 #ifdef HAVE_LDAP_H
  25 #include <ldap.h>
  26 #endif
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winldap_private.h"
  31 #include "wldap32.h"
  32 #include "wine/debug.h"
  33
  34 #ifdef HAVE_LDAP
  35 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  36 #endif
  37
  38 #define WLDAP32_LBER_ERROR (~0U)
  39
  40 /***********************************************************************
  41  *      ber_alloc_t     (WLDAP32.@)
  42  *
  43  * Allocate a berelement structure.
  44  *
  45  * PARAMS
  46  *  options [I] Must be LBER_USE_DER.
  47  *
  48  * RETURNS
  49  *  Success: Pointer to an allocated berelement structure.
  50  *  Failure: NULL
  51  *
  52  * NOTES
  53  *  Free the berelement structure with ber_free.
  54  */
  55 WLDAP32_BerElement * CDECL WLDAP32_ber_alloc_t( INT options )
  56 {
  57 #ifdef HAVE_LDAP
  58     return ber_alloc_t( options );
  59 #else
  60     return NULL;
  61 #endif
  62 }
  63
  64
  65 /***********************************************************************
  66  *      ber_bvdup     (WLDAP32.@)
  67  *
  68  * Copy a berval structure.
  69  *
  70  * PARAMS
  71  *  berval [I] Pointer to the berval structure to be copied.
  72  *
  73  * RETURNS
  74  *  Success: Pointer to a copy of the berval structure.
  75  *  Failure: NULL
  76  *
  77  * NOTES
  78  *  Free the copy with ber_bvfree.
  79  */
  80 BERVAL * CDECL WLDAP32_ber_bvdup( BERVAL *berval )
  81 {
  82     return bervalWtoW( berval );
  83 }
  84
  85
  86 /***********************************************************************
  87  *      ber_bvecfree     (WLDAP32.@)
  88  *
  89  * Free an array of berval structures.
  90  *
  91  * PARAMS
  92  *  berval [I] Pointer to an array of berval structures.
  93  *
  94  * RETURNS
  95  *  Nothing.
  96  *
  97  * NOTES
  98  *  Use this function only to free an array of berval structures
  99  *  returned by a call to ber_scanf with a 'V' in the format string.
 100  */
 101 void CDECL WLDAP32_ber_bvecfree( PBERVAL *berval )
 102 {
 103     bvarrayfreeW( berval );
 104 }
 105
 106
 107 /***********************************************************************
 108  *      ber_bvfree     (WLDAP32.@)
 109  *
 110  * Free a berval structure.
 111  *
 112  * PARAMS
 113  *  berval [I] Pointer to a berval structure.
 114  *
 115  * RETURNS
 116  *  Nothing.
 117  *
 118  * NOTES
 119  *  Use this function only to free berval structures allocated by
 120  *  an LDAP API.
 121  */
 122 void CDECL WLDAP32_ber_bvfree( BERVAL *berval )
 123 {
 124     heap_free( berval );
 125 }
 126
 127
 128 /***********************************************************************
 129  *      ber_first_element     (WLDAP32.@)
 130  *
 131  * Return the tag of the first element in a set or sequence.
 132  *
 133  * PARAMS
 134  *  berelement [I] Pointer to a berelement structure.
 135  *  len        [O] Receives the length of the first element.
 136  *  opaque     [O] Receives a pointer to a cookie.
 137  *
 138  * RETURNS
 139  *  Success: Tag of the first element.
 140  *  Failure: LBER_DEFAULT (no more data).
 141  *
 142  * NOTES
 143  *  len and cookie should be passed to ber_next_element.
 144  */
 145 ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *berelement, ULONG *ret_len, CHAR **opaque )
 146 {
 147 #ifdef HAVE_LDAP
 148     ber_len_t len;
 149     ber_tag_t ret;
 150
 151     if ((ret = ber_first_element( berelement, &len, opaque )) != LBER_ERROR)
 152     {
 153         if (len > ~0u)
 154         {
 155             ERR( "len too large\n" );
 156             return WLDAP32_LBER_ERROR;
 157         }
 158         *ret_len = len;
 159     }
 160     return ret;
 161
 162 #else
 163     return WLDAP32_LBER_ERROR;
 164 #endif
 165 }
 166
 167
 168 /***********************************************************************
 169  *      ber_flatten     (WLDAP32.@)
 170  *
 171  * Flatten a berelement structure into a berval structure.
 172  *
 173  * PARAMS
 174  *  berelement [I] Pointer to a berelement structure.
 175  *  berval    [O] Pointer to a berval structure.
 176  *
 177  * RETURNS
 178  *  Success: 0
 179  *  Failure: LBER_ERROR
 180  *
 181  * NOTES
 182  *  Free the berval structure with ber_bvfree.
 183  */
 184 INT CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *berelement, PBERVAL *berval )
 185 {
 186 #ifdef HAVE_LDAP
 187     struct berval *bervalU;
 188     struct WLDAP32_berval *bervalW;
 189
 190     if (ber_flatten( berelement, &bervalU )) return WLDAP32_LBER_ERROR;
 191
 192     bervalW = bervalUtoW( bervalU );
 193     ber_bvfree( bervalU );
 194     if (!bervalW) return WLDAP32_LBER_ERROR;
 195     *berval = bervalW;
 196     return 0;
 197
 198 #else
 199     return WLDAP32_LBER_ERROR;
 200 #endif
 201 }
 202
 203
 204 /***********************************************************************
 205  *      ber_free     (WLDAP32.@)
 206  *
 207  * Free a berelement structure.
 208  *
 209  * PARAMS
 210  *  berelement [I] Pointer to the berelement structure to be freed.
 211  *  buf       [I] Flag.
 212  *
 213  * RETURNS
 214  *  Nothing.
 215  *
 216  * NOTES
 217  *  Set buf to 0 if the berelement was allocated with ldap_first_attribute
 218  *  or ldap_next_attribute, otherwise set it to 1.
 219  */
 220 void CDECL WLDAP32_ber_free( WLDAP32_BerElement *berelement, INT buf )
 221 {
 222 #ifdef HAVE_LDAP
 223     ber_free( berelement, buf );
 224 #endif
 225 }
 226
 227
 228 /***********************************************************************
 229  *      ber_init     (WLDAP32.@)
 230  *
 231  * Initialise a berelement structure from a berval structure.
 232  *
 233  * PARAMS
 234  *  berval [I] Pointer to a berval structure.
 235  *
 236  * RETURNS
 237  *  Success: Pointer to a berelement structure.
 238  *  Failure: NULL
 239  *
 240  * NOTES
 241  *  Call ber_free to free the returned berelement structure.
 242  */
 243 WLDAP32_BerElement * CDECL WLDAP32_ber_init( BERVAL *berval )
 244 {
 245 #ifdef HAVE_LDAP
 246     struct berval *bervalU;
 247     WLDAP32_BerElement *ret;
 248
 249     if (!(bervalU = bervalWtoU( berval ))) return NULL;
 250     ret = ber_init( bervalU );
 251     heap_free( bervalU );
 252     return ret;
 253 #else
 254     return NULL;
 255 #endif
 256 }
 257
 258
 259 /***********************************************************************
 260  *      ber_next_element     (WLDAP32.@)
 261  *
 262  * Return the tag of the next element in a set or sequence.
 263  *
 264  * PARAMS
 265  *  berelement [I]   Pointer to a berelement structure.
 266  *  len        [I/O] Receives the length of the next element.
 267  *  opaque     [I/O] Pointer to a cookie.
 268  *
 269  * RETURNS
 270  *  Success: Tag of the next element.
 271  *  Failure: LBER_DEFAULT (no more data).
 272  *
 273  * NOTES
 274  *  len and cookie are initialized by ber_first_element and should
 275  *  be passed on in subsequent calls to ber_next_element.
 276  */
 277 ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *berelement, ULONG *ret_len, CHAR *opaque )
 278 {
 279 #ifdef HAVE_LDAP
 280     ber_len_t len;
 281     ber_tag_t ret;
 282
 283     if ((ret = ber_next_element( berelement, &len, opaque )) != LBER_ERROR)
 284     {
 285         if (len > ~0u)
 286         {
 287             ERR( "len too large\n" );
 288             return WLDAP32_LBER_ERROR;
 289         }
 290         *ret_len = len;
 291     }
 292     return ret;
 293
 294 #else
 295     return WLDAP32_LBER_ERROR;
 296 #endif
 297 }
 298
 299
 300 /***********************************************************************
 301  *      ber_peek_tag     (WLDAP32.@)
 302  *
 303  * Return the tag of the next element.
 304  *
 305  * PARAMS
 306  *  berelement [I] Pointer to a berelement structure.
 307  *  len        [O] Receives the length of the next element.
 308  *
 309  * RETURNS
 310  *  Success: Tag of the next element.
 311  *  Failure: LBER_DEFAULT (no more data).
 312  */
 313 ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *berelement, ULONG *ret_len )
 314 {
 315 #ifdef HAVE_LDAP
 316     ber_len_t len;
 317     ber_tag_t ret;
 318
 319     if ((ret = ber_peek_tag( berelement, &len )) != LBER_ERROR)
 320     {
 321         if (len > ~0u)
 322         {
 323             ERR( "len too large\n" );
 324             return WLDAP32_LBER_ERROR;
 325         }
 326         *ret_len = len;
 327     }
 328     return ret;
 329
 330 #else
 331     return WLDAP32_LBER_ERROR;
 332 #endif
 333 }
 334
 335
 336 /***********************************************************************
 337  *      ber_skip_tag     (WLDAP32.@)
 338  *
 339  * Skip the current tag and return the tag of the next element.
 340  *
 341  * PARAMS
 342  *  berelement [I] Pointer to a berelement structure.
 343  *  len        [O] Receives the length of the skipped element.
 344  *
 345  * RETURNS
 346  *  Success: Tag of the next element.
 347  *  Failure: LBER_DEFAULT (no more data).
 348  */
 349 ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *berelement, ULONG *ret_len )
 350 {
 351 #ifdef HAVE_LDAP
 352     ber_len_t len;
 353     ber_tag_t ret;
 354
 355     if ((ret = ber_skip_tag( berelement, &len )) != LBER_ERROR)
 356     {
 357         if (len > ~0u)
 358         {
 359             ERR( "len too large\n" );
 360             return WLDAP32_LBER_ERROR;
 361         }
 362         *ret_len = len;
 363     }
 364     return ret;
 365
 366 #else
 367     return WLDAP32_LBER_ERROR;
 368 #endif
 369 }
 370
 371
 372 /***********************************************************************
 373  *      ber_printf     (WLDAP32.@)
 374  *
 375  * Encode a berelement structure.
 376  *
 377  * PARAMS
 378  *  berelement [I/O] Pointer to a berelement structure.
 379  *  fmt        [I]   Format string.
 380  *  ...        [I]   Values to encode.
 381  *
 382  * RETURNS
 383  *  Success: Non-negative number.
 384  *  Failure: LBER_ERROR
 385  *
 386  * NOTES
 387  *  berelement must have been allocated with ber_alloc_t. This function
 388  *  can be called multiple times to append data.
 389  */
 390 INT WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *berelement, PCHAR fmt, ... )
 391 {
 392 #ifdef HAVE_LDAP
 393     __ms_va_list list;
 394     int ret = 0;
 395     char new_fmt[2];
 396
 397     new_fmt[1] = 0;
 398     __ms_va_start( list, fmt );
 399     while (*fmt)
 400     {
 401         new_fmt[0] = *fmt++;
 402         switch(new_fmt[0])
 403         {
 404         case 'b':
 405         case 'e':
 406         case 'i':
 407             {
 408                 int i = va_arg( list, int );
 409                 ret = ber_printf( berelement, new_fmt, i );
 410                 break;
 411             }
 412         case 'o':
 413         case 's':
 414             {
 415                 char *str = va_arg( list, char * );
 416                 ret = ber_printf( berelement, new_fmt, str );
 417                 break;
 418             }
 419         case 't':
 420             {
 421                 unsigned int tag = va_arg( list, unsigned int );
 422                 ret = ber_printf( berelement, new_fmt, tag );
 423                 break;
 424             }
 425         case 'v':
 426             {
 427                 char **array = va_arg( list, char ** );
 428                 ret = ber_printf( berelement, new_fmt, array );
 429                 break;
 430             }
 431         case 'V':
 432             {
 433                 struct WLDAP32_berval **array = va_arg( list, struct WLDAP32_berval ** );
 434                 struct berval **arrayU;
 435                 if (!(arrayU = bvarrayWtoU( array )))
 436                 {
 437                     ret = -1;
 438                     break;
 439                 }
 440                 ret = ber_printf( berelement, new_fmt, arrayU );
 441                 bvarrayfreeU( arrayU );
 442                 break;
 443             }
 444         case 'X':
 445             {
 446                 char *str = va_arg( list, char * );
 447                 int len = va_arg( list, int );
 448                 new_fmt[0] = 'B';  /* 'X' is deprecated */
 449                 ret = ber_printf( berelement, new_fmt, str, len );
 450                 break;
 451             }
 452         case 'n':
 453         case '{':
 454         case '}':
 455         case '[':
 456         case ']':
 457             ret = ber_printf( berelement, new_fmt );
 458             break;
 459         default:
 460             FIXME( "Unknown format '%c'\n", new_fmt[0] );
 461             ret = -1;
 462             break;
 463         }
 464         if (ret == -1) break;
 465     }
 466     __ms_va_end( list );
 467     return ret;
 468 #else
 469     return WLDAP32_LBER_ERROR;
 470 #endif
 471 }
 472
 473
 474 /***********************************************************************
 475  *      ber_scanf     (WLDAP32.@)
 476  *
 477  * Decode a berelement structure.
 478  *
 479  * PARAMS
 480  *  berelement [I/O] Pointer to a berelement structure.
 481  *  fmt        [I]   Format string.
 482  *  ...        [I]   Pointers to values to be decoded.
 483  *
 484  * RETURNS
 485  *  Success: Non-negative number.
 486  *  Failure: LBER_ERROR
 487  *
 488  * NOTES
 489  *  berelement must have been allocated with ber_init. This function
 490  *  can be called multiple times to decode data.
 491  */
 492 INT WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *berelement, PCHAR fmt, ... )
 493 {
 494 #ifdef HAVE_LDAP
 495     __ms_va_list list;
 496     int ret = 0;
 497     char new_fmt[2];
 498
 499     new_fmt[1] = 0;
 500     __ms_va_start( list, fmt );
 501     while (*fmt)
 502     {
 503         new_fmt[0] = *fmt++;
 504         switch(new_fmt[0])
 505         {
 506         case 'a':
 507             {
 508                 char **ptr = va_arg( list, char ** );
 509                 ret = ber_scanf( berelement, new_fmt, ptr );
 510                 break;
 511             }
 512         case 'b':
 513         case 'e':
 514         case 'i':
 515             {
 516                 int *i = va_arg( list, int * );
 517                 ret = ber_scanf( berelement, new_fmt, i );
 518                 break;
 519             }
 520         case 't':
 521             {
 522                 unsigned int *tag = va_arg( list, unsigned int * );
 523                 ret = ber_scanf( berelement, new_fmt, tag );
 524                 break;
 525             }
 526         case 'v':
 527             {
 528                 char ***array = va_arg( list, char *** );
 529                 ret = ber_scanf( berelement, new_fmt, array );
 530                 break;
 531             }
 532         case 'B':
 533             {
 534                 char **str = va_arg( list, char ** );
 535                 int *len = va_arg( list, int * );
 536                 ret = ber_scanf( berelement, new_fmt, str, len );
 537                 break;
 538             }
 539         case 'O':
 540             {
 541                 struct berval **ptr = va_arg( list, struct berval ** );
 542                 ret = ber_scanf( berelement, new_fmt, ptr );
 543                 break;
 544             }
 545         case 'V':
 546             {
 547                 struct WLDAP32_berval **arrayW, ***array = va_arg( list, struct WLDAP32_berval *** );
 548                 struct berval **arrayU;
 549                 if ((ret = ber_scanf( berelement, new_fmt, &arrayU )) == -1) break;
 550                 if ((arrayW = bvarrayUtoW( arrayU ))) *array = arrayW;
 551                 else ret = -1;
 552                 bvarrayfreeU( arrayU );
 553                 break;
 554             }
 555         case 'n':
 556         case 'x':
 557         case '{':
 558         case '}':
 559         case '[':
 560         case ']':
 561             ret = ber_scanf( berelement, new_fmt );
 562             break;
 563         default:
 564             FIXME( "Unknown format '%c'\n", new_fmt[0] );
 565             ret = -1;
 566             break;
 567         }
 568         if (ret == -1) break;
 569     }
 570     __ms_va_end( list );
 571     return ret;
 572 #else
 573     return WLDAP32_LBER_ERROR;
 574 #endif
 575 }