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