git.oblomov.eu Git - wine/blob - dlls/wldap32/parse.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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "wine/port.h"
  24 #include "wine/debug.h"
  25
  26 #include <stdarg.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winnls.h"
  31
  32 #ifdef HAVE_LDAP_H
  33 #include <ldap.h>
  34 #else
  35 #define LDAP_NOT_SUPPORTED  0x5c
  36 #endif
  37
  38 #include "winldap_private.h"
  39 #include "wldap32.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  42
  43 ULONG ldap_parse_extended_resultA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
  44     PCHAR *oid, struct WLDAP32_berval **data, BOOLEAN free )
  45 {
  46     ULONG ret = LDAP_NOT_SUPPORTED;
  47 #ifdef HAVE_LDAP
  48     WCHAR *oidW = NULL;
  49
  50     TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
  51
  52     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  53     if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
  54
  55     ret = ldap_parse_extended_resultW( ld, result, &oidW, data, free );
  56
  57     if (oid) {
  58         *oid = strWtoA( oidW );
  59         if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
  60         ldap_memfreeW( oidW );
  61     }
  62
  63 #endif
  64     return ret;
  65 }
  66
  67 ULONG ldap_parse_extended_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
  68     PWCHAR *oid, struct WLDAP32_berval **data, BOOLEAN free )
  69 {
  70     ULONG ret = LDAP_NOT_SUPPORTED;
  71 #ifdef HAVE_LDAP
  72     char *oidU = NULL;
  73
  74     TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
  75
  76     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  77     if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
  78
  79     ret = ldap_parse_extended_result( ld, result, &oidU, (struct berval **)data, free );
  80
  81     if (oid) {
  82         *oid = strUtoW( oidU );
  83         if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
  84         ldap_memfree( oidU );
  85     }
  86
  87 #endif
  88     return ret;
  89 }
  90
  91 ULONG ldap_parse_referenceA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *message,
  92     PCHAR **referrals )
  93 {
  94     ULONG ret = LDAP_NOT_SUPPORTED;
  95 #ifdef HAVE_LDAP
  96     WCHAR **referralsW = NULL;
  97
  98     TRACE( "(%p, %p, %p)\n", ld, message, referrals );
  99
 100     if (!ld) return ~0UL;
 101
 102     ret = ldap_parse_referenceW( ld, message, &referralsW );
 103
 104     *referrals = strarrayWtoA( referralsW );
 105     ldap_value_freeW( referralsW );
 106
 107 #endif
 108     return ret;
 109 }
 110
 111 ULONG ldap_parse_referenceW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *message,
 112     PWCHAR **referrals )
 113 {
 114     ULONG ret = LDAP_NOT_SUPPORTED;
 115 #ifdef HAVE_LDAP_PARSE_REFERENCE
 116     char **referralsU = NULL;
 117
 118     TRACE( "(%p, %p, %p)\n", ld, message, referrals );
 119
 120     if (!ld) return ~0UL;
 121
 122     ret = ldap_parse_reference( ld, message, &referralsU, NULL, 0 );
 123
 124     *referrals = strarrayUtoW( referralsU );
 125     ldap_memfree( referralsU );
 126
 127 #endif
 128     return ret;
 129 }
 130
 131 ULONG ldap_parse_resultA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
 132     ULONG *retcode, PCHAR *matched, PCHAR *error, PCHAR **referrals,
 133     PLDAPControlA **serverctrls, BOOLEAN free )
 134 {
 135     ULONG ret = LDAP_NOT_SUPPORTED;
 136 #ifdef HAVE_LDAP
 137     WCHAR **matchedW = NULL, **errorW = NULL, **referralsW = NULL;
 138     LDAPControlW **serverctrlsW = NULL;
 139
 140     TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
 141            matched, error, referrals, serverctrls, free );
 142
 143     if (!ld) return ~0UL;
 144
 145     ret = ldap_parse_resultW( ld, result, retcode, matchedW, errorW,
 146                               &referralsW, &serverctrlsW, free );
 147
 148     matched = strarrayWtoA( matchedW );
 149     error = strarrayWtoA( errorW );
 150
 151     *referrals = strarrayWtoA( referralsW );
 152     *serverctrls = controlarrayWtoA( serverctrlsW );
 153
 154     ldap_value_freeW( matchedW );
 155     ldap_value_freeW( errorW );
 156     ldap_value_freeW( referralsW );
 157     ldap_controls_freeW( serverctrlsW );
 158
 159 #endif
 160     return ret;
 161 }
 162
 163 ULONG ldap_parse_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
 164     ULONG *retcode, PWCHAR *matched, PWCHAR *error, PWCHAR **referrals,
 165     PLDAPControlW **serverctrls, BOOLEAN free )
 166 {
 167     ULONG ret = LDAP_NOT_SUPPORTED;
 168 #ifdef HAVE_LDAP
 169     char **matchedU = NULL, **errorU = NULL, **referralsU = NULL;
 170     LDAPControl **serverctrlsU = NULL;
 171
 172     TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
 173            matched, error, referrals, serverctrls, free );
 174
 175     if (!ld) return ~0UL;
 176
 177     ret = ldap_parse_result( ld, result, (int *)retcode, matchedU, errorU,
 178                              &referralsU, &serverctrlsU, free );
 179
 180     matched = strarrayUtoW( matchedU );
 181     error = strarrayUtoW( errorU );
 182
 183     *referrals = strarrayUtoW( referralsU );
 184     *serverctrls = controlarrayUtoW( serverctrlsU );
 185
 186     ldap_memfree( matchedU );
 187     ldap_memfree( errorU );
 188     ldap_memfree( referralsU );
 189     ldap_controls_free( serverctrlsU );
 190
 191 #endif
 192     return ret;
 193 }
 194
 195 ULONG ldap_parse_sort_controlA( WLDAP32_LDAP *ld, PLDAPControlA *control,
 196     ULONG *result, PCHAR *attr )
 197 {
 198     ULONG ret = LDAP_NOT_SUPPORTED;
 199 #ifdef HAVE_LDAP
 200     WCHAR *attrW = NULL;
 201     LDAPControlW **controlW = NULL;
 202
 203     TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 204
 205     if (!ld) return ~0UL;
 206
 207     if (control) {
 208         controlW = controlarrayAtoW( control );
 209         if (!controlW) return WLDAP32_LDAP_NO_MEMORY;
 210     }
 211
 212     ret = ldap_parse_sort_controlW( ld, controlW, result, &attrW );
 213
 214     *attr = strWtoA( attrW );
 215     controlarrayfreeW( controlW );
 216
 217 #endif
 218     return ret;
 219 }
 220
 221 ULONG ldap_parse_sort_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control,
 222     ULONG *result, PWCHAR *attr )
 223 {
 224     ULONG ret = LDAP_NOT_SUPPORTED;
 225 #ifdef HAVE_LDAP
 226     char *attrU = NULL;
 227     LDAPControl **controlU = NULL;
 228
 229     TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 230
 231     if (!ld) return ~0UL;
 232
 233     if (control) {
 234         controlU = controlarrayWtoU( control );
 235         if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
 236     }
 237
 238     ret = ldap_parse_sort_control( ld, controlU, result, &attrU );
 239
 240     *attr = strUtoW( attrU );
 241     controlarrayfreeU( controlU );
 242
 243 #endif
 244     return ret;
 245 }
 246
 247 INT ldap_parse_vlv_controlA( WLDAP32_LDAP *ld, PLDAPControlA *control,
 248     PULONG targetpos, PULONG listcount,
 249     struct WLDAP32_berval **context, PINT errcode )
 250 {
 251     int ret = LDAP_NOT_SUPPORTED;
 252 #ifdef HAVE_LDAP
 253     LDAPControlW **controlW = NULL;
 254
 255     TRACE( "(%p, %p, %p, %p, %p, %p)\n", ld, control, targetpos,
 256            listcount, context, errcode );
 257
 258     if (!ld) return ~0UL;
 259
 260     if (control) {
 261         controlW = controlarrayAtoW( control );
 262         if (!controlW) return WLDAP32_LDAP_NO_MEMORY;
 263     }
 264
 265     ret = ldap_parse_vlv_controlW( ld, controlW, targetpos, listcount,
 266                                    context, errcode );
 267
 268     controlarrayfreeW( controlW );
 269
 270 #endif
 271     return ret;
 272 }
 273
 274 INT ldap_parse_vlv_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control,
 275     PULONG targetpos, PULONG listcount,
 276     struct WLDAP32_berval **context, PINT errcode )
 277 {
 278     int ret = LDAP_NOT_SUPPORTED;
 279 #ifdef HAVE_LDAP
 280     LDAPControl **controlU = NULL;
 281
 282     TRACE( "(%p, %p, %p, %p, %p, %p)\n", ld, control, targetpos,
 283            listcount, context, errcode );
 284
 285     if (!ld) return ~0UL;
 286
 287     if (control) {
 288         controlU = controlarrayWtoU( control );
 289         if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
 290     }
 291
 292     ret = ldap_parse_vlv_control( ld, controlU, targetpos, listcount,
 293                                   (struct berval **)context, errcode );
 294
 295     controlarrayfreeU( controlU );
 296
 297 #endif
 298     return ret;
 299 }