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
  27 #include "wine/debug.h"
  28 #include "winldap_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  31
  32 /***********************************************************************
  33  *      ber_alloc_t     (WLDAP32.@)
  34  */
  35 WLDAP32_BerElement * CDECL WLDAP32_ber_alloc_t( int options )
  36 {
  37     WLDAP32_BerElement *ret;
  38
  39     TRACE( "%d\n", options );
  40
  41     if (options != WLDAP32_LBER_USE_DER || !(ret = malloc( sizeof(*ret) ))) return NULL;
  42     if ((ret->opaque = (char *)ber_alloc_t( options ))) return ret;
  43     free( ret );
  44     return NULL;
  45 }
  46
  47 /***********************************************************************
  48  *      ber_bvdup     (WLDAP32.@)
  49  */
  50 BERVAL * CDECL WLDAP32_ber_bvdup( BERVAL *berval )
  51 {
  52     TRACE( "%p\n", berval );
  53     return bervalWtoW( berval );
  54 }
  55
  56 /***********************************************************************
  57  *      ber_bvecfree     (WLDAP32.@)
  58  */
  59 void CDECL WLDAP32_ber_bvecfree( BERVAL **berval )
  60 {
  61     TRACE( "%p\n", berval );
  62     bvarrayfreeW( berval );
  63 }
  64
  65 /***********************************************************************
  66  *      ber_bvfree     (WLDAP32.@)
  67  */
  68 void CDECL WLDAP32_ber_bvfree( BERVAL *berval )
  69 {
  70     TRACE( "berval\n" );
  71     free( berval );
  72 }
  73
  74 /***********************************************************************
  75  *      ber_first_element     (WLDAP32.@)
  76  */
  77 ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *ber, ULONG *len, char **opaque )
  78 {
  79     TRACE( "%p, %p, %p\n", ber, len, opaque );
  80     return ber_first_element( BER(ber), len, opaque );
  81 }
  82
  83 /***********************************************************************
  84  *      ber_flatten     (WLDAP32.@)
  85  */
  86 int CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *ber, BERVAL **berval )
  87 {
  88     struct berval *bervalU;
  89     struct WLDAP32_berval *bervalW;
  90
  91     TRACE( "%p, %p\n", ber, berval );
  92
  93     if (ber_flatten( BER(ber), &bervalU )) return WLDAP32_LBER_ERROR;
  94
  95     bervalW = bervalUtoW( bervalU );
  96     ber_bvfree( bervalU );
  97     if (!bervalW)
  98         return WLDAP32_LBER_ERROR;
  99
 100     *berval = bervalW;
 101     return 0;
 102 }
 103
 104 /***********************************************************************
 105  *      ber_free     (WLDAP32.@)
 106  */
 107 void CDECL WLDAP32_ber_free( WLDAP32_BerElement *ber, int freebuf )
 108 {
 109     TRACE( "%p, %d\n", ber, freebuf );
 110     ber_free( BER(ber), freebuf );
 111     free( ber );
 112 }
 113
 114 /***********************************************************************
 115  *      ber_init     (WLDAP32.@)
 116  */
 117 WLDAP32_BerElement * CDECL WLDAP32_ber_init( BERVAL *berval )
 118 {
 119     struct berval *bervalU;
 120     WLDAP32_BerElement *ret;
 121     BerElement *ber;
 122
 123     TRACE( "%p\n", berval );
 124
 125     if (!(ret = malloc( sizeof(*ret) ))) return NULL;
 126     if (!(bervalU = bervalWtoU( berval )))
 127     {
 128         free( ret );
 129         return NULL;
 130     }
 131
 132     ber = ber_init( bervalU );
 133     free( bervalU );
 134     if ((ret->opaque = (char *)ber)) return ret;
 135     free( ret );
 136     return NULL;
 137 }
 138
 139 /***********************************************************************
 140  *      ber_next_element     (WLDAP32.@)
 141  */
 142 ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *ber, ULONG *len, char *opaque )
 143 {
 144     TRACE( "%p, %p, %p\n", ber, len, opaque );
 145     return ber_next_element( BER(ber), len, opaque );
 146 }
 147
 148 /***********************************************************************
 149  *      ber_peek_tag     (WLDAP32.@)
 150  */
 151 ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *ber, ULONG *len )
 152 {
 153     TRACE( "%p, %p\n", ber, len );
 154     return ber_peek_tag( BER(ber), len );
 155 }
 156
 157 /***********************************************************************
 158  *      ber_skip_tag     (WLDAP32.@)
 159  */
 160 ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *ber, ULONG *len )
 161 {
 162     TRACE( "%p, %p\n", ber, len );
 163     return ber_skip_tag( BER(ber), len );
 164 }
 165
 166 /***********************************************************************
 167  *      ber_printf     (WLDAP32.@)
 168  */
 169 int WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *ber, char *fmt, ... )
 170 {
 171     va_list list;
 172     int ret = 0;
 173     char new_fmt[2];
 174
 175     TRACE( "%p(%p), %s\n", ber, ber->opaque, fmt );
 176
 177     new_fmt[1] = 0;
 178     va_start( list, fmt );
 179     while (*fmt)
 180     {
 181         new_fmt[0] = *fmt++;
 182         switch (new_fmt[0])
 183         {
 184         case 'b':
 185         case 'e':
 186         case 'i':
 187         {
 188             int arg = va_arg( list, int );
 189             ret = ber_printf( BER(ber), new_fmt, arg );
 190             break;
 191         }
 192         case 'o':
 193         case 's':
 194         {
 195             char *arg = va_arg( list, char * );
 196             ret = ber_printf( BER(ber), new_fmt, arg );
 197             break;
 198         }
 199         case 't':
 200         {
 201             unsigned int arg = va_arg( list, unsigned int );
 202             ret = ber_printf( BER(ber), new_fmt, arg );
 203             break;
 204         }
 205         case 'v':
 206         {
 207             char **arg = va_arg( list, char ** );
 208             ret = ber_printf( BER(ber), new_fmt, arg );
 209             break;
 210         }
 211         case 'V':
 212         {
 213             struct WLDAP32_berval **array = va_arg( list, struct WLDAP32_berval ** );
 214             struct berval **arrayU;
 215             if (!(arrayU = bvarrayWtoU( array )))
 216             {
 217                 ret = -1;
 218                 break;
 219             }
 220             ret = ber_printf( BER(ber), new_fmt, arrayU );
 221             bvarrayfreeU( arrayU );
 222             break;
 223         }
 224         case 'X':
 225         {
 226             char *arg = va_arg( list, char * );
 227             int arg2 = va_arg( list, int );
 228             new_fmt[0] = 'B';  /* 'X' is deprecated */
 229             ret = ber_printf( BER(ber), new_fmt, arg, arg2 );
 230             break;
 231         }
 232         case 'n':
 233         case '{':
 234         case '}':
 235         case '[':
 236         case ']':
 237             ret = ber_printf( BER(ber), new_fmt );
 238             break;
 239
 240         default:
 241             FIXME( "Unknown format '%c'\n", new_fmt[0] );
 242             ret = -1;
 243             break;
 244         }
 245         if (ret == -1) break;
 246     }
 247     va_end( list );
 248     return ret;
 249 }
 250
 251 /***********************************************************************
 252  *      ber_scanf     (WLDAP32.@)
 253  */
 254 ULONG WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *ber, char *fmt, ... )
 255 {
 256     va_list list;
 257     int ret = 0;
 258     char new_fmt[2];
 259
 260     TRACE( "%p, %s\n", ber, fmt );
 261
 262     new_fmt[1] = 0;
 263     va_start( list, fmt );
 264     while (*fmt)
 265     {
 266         new_fmt[0] = *fmt++;
 267         switch (new_fmt[0])
 268         {
 269         case 'a':
 270         {
 271             char *str, **ptr = va_arg( list, char ** );
 272             if ((ret = ber_scanf( BER(ber), new_fmt, &str )) == -1) break;
 273             *ptr = strdup( str );
 274             ldap_memfree( str );
 275             break;
 276         }
 277         case 'b':
 278         case 'e':
 279         case 'i':
 280         {
 281             int *arg = va_arg( list, int * );
 282             ret = ber_scanf( BER(ber), new_fmt, arg );
 283             break;
 284         }
 285         case 't':
 286         {
 287             unsigned int *arg = va_arg( list, unsigned int * );
 288             ret = ber_scanf( BER(ber), new_fmt, arg );
 289             break;
 290         }
 291         case 'v':
 292         {
 293             char *str, **arrayU, **ptr, ***array = va_arg( list, char *** );
 294             if ((ret = ber_scanf( BER(ber), new_fmt, &arrayU )) == -1) break;
 295             *array = strarrayUtoU( arrayU );
 296             ptr = arrayU;
 297             while ((str = *ptr))
 298             {
 299                 ldap_memfree( str );
 300                 ptr++;
 301             }
 302             ldap_memfree( arrayU );
 303             break;
 304         }
 305         case 'B':
 306         {
 307             char *strU, **str = va_arg( list, char ** );
 308             int *len = va_arg( list, int * );
 309             if ((ret = ber_scanf( BER(ber), new_fmt, &strU, len )) == -1) break;
 310             *str = malloc( *len );
 311             memcpy( *str, strU, *len );
 312             ldap_memfree( strU );
 313             break;
 314         }
 315         case 'O':
 316         {
 317             struct WLDAP32_berval **berval = va_arg( list, struct WLDAP32_berval ** );
 318             struct berval *bervalU;
 319             if ((ret = ber_scanf( BER(ber), new_fmt, &bervalU )) == -1) break;
 320             *berval = bervalUtoW( bervalU );
 321             ber_bvfree( bervalU );
 322             break;
 323         }
 324         case 'V':
 325         {
 326             struct WLDAP32_berval ***array = va_arg( list, struct WLDAP32_berval *** );
 327             struct berval **arrayU;
 328             if ((ret = ber_scanf( BER(ber), new_fmt, &arrayU )) == -1) break;
 329             *array = bvarrayUtoW( arrayU );
 330             ber_bvecfree( arrayU );
 331             break;
 332         }
 333         case 'n':
 334         case 'x':
 335         case '{':
 336         case '}':
 337         case '[':
 338         case ']':
 339             ret = ber_scanf( BER(ber), new_fmt );
 340             break;
 341
 342         default:
 343             FIXME( "Unknown format '%c'\n", new_fmt[0] );
 344             ret = -1;
 345             break;
 346         }
 347         if (ret == -1) break;
 348     }
 349     va_end( list );
 350     return ret;
 351 }