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