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