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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 #endif
  35
  36 #include "winldap_private.h"
  37 #include "wldap32.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  40
  41 /***********************************************************************
  42  *      ldap_parse_extended_resultA     (WLDAP32.@)
  43  *
  44  * See ldap_parse_extended_resultW.
  45  */
  46 ULONG CDECL ldap_parse_extended_resultA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
  47     PCHAR *oid, struct WLDAP32_berval **data, BOOLEAN free )
  48 {
  49     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
  50 #ifdef HAVE_LDAP
  51     WCHAR *oidW = NULL;
  52
  53     TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
  54
  55     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
  56     if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
  57
  58     ret = ldap_parse_extended_resultW( ld, result, &oidW, data, free );
  59
  60     if (oid) {
  61         *oid = strWtoA( oidW );
  62         if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
  63         ldap_memfreeW( oidW );
  64     }
  65
  66 #endif
  67     return ret;
  68 }
  69
  70 /***********************************************************************
  71  *      ldap_parse_extended_resultW     (WLDAP32.@)
  72  *
  73  * Parse the result of an extended operation.
  74  *
  75  * PARAMS
  76  *  ld      [I] Pointer to an LDAP context.
  77  *  result  [I] Result message from an extended operation.
  78  *  oid     [O] OID of the extended operation.
  79  *  data    [O] Result data.
  80  *  free    [I] Free the result message?
  81  *
  82  * RETURNS
  83  *  Success: LDAP_SUCCESS
  84  *  Failure: An LDAP error code.
  85  *
  86  * NOTES
  87  *  Free the OID and result data with ldap_memfree. Pass a nonzero
  88  *  value for 'free' or call ldap_msgfree to free the result message.
  89  */
  90 ULONG CDECL ldap_parse_extended_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
  91     PWCHAR *oid, struct WLDAP32_berval **data, BOOLEAN free )
  92 {
  93     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
  94 #ifdef HAVE_LDAP
  95     char *oidU = NULL;
  96
  97     TRACE( "(%p, %p, %p, %p, 0x%02x)\n", ld, result, oid, data, free );
  98
  99     if (!ld) return WLDAP32_LDAP_PARAM_ERROR;
 100     if (!result) return WLDAP32_LDAP_NO_RESULTS_RETURNED;
 101
 102     ret = ldap_parse_extended_result( ld, result, &oidU, (struct berval **)data, free );
 103
 104     if (oid) {
 105         *oid = strUtoW( oidU );
 106         if (!*oid) ret = WLDAP32_LDAP_NO_MEMORY;
 107         ldap_memfree( oidU );
 108     }
 109
 110 #endif
 111     return ret;
 112 }
 113
 114 /***********************************************************************
 115  *      ldap_parse_referenceA     (WLDAP32.@)
 116  *
 117  * See ldap_parse_referenceW.
 118  */
 119 ULONG CDECL ldap_parse_referenceA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *message,
 120     PCHAR **referrals )
 121 {
 122     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 123 #ifdef HAVE_LDAP
 124     WCHAR **referralsW = NULL;
 125
 126     TRACE( "(%p, %p, %p)\n", ld, message, referrals );
 127
 128     if (!ld) return ~0UL;
 129
 130     ret = ldap_parse_referenceW( ld, message, &referralsW );
 131
 132     *referrals = strarrayWtoA( referralsW );
 133     ldap_value_freeW( referralsW );
 134
 135 #endif
 136     return ret;
 137 }
 138
 139 /***********************************************************************
 140  *      ldap_parse_referenceW     (WLDAP32.@)
 141  *
 142  * Return any referrals from a result message.
 143  *
 144  * PARAMS
 145  *  ld         [I] Pointer to an LDAP context.
 146  *  result     [I] Result message.
 147  *  referrals  [O] Array of referral URLs.
 148  *
 149  * RETURNS
 150  *  Success: LDAP_SUCCESS
 151  *  Failure: An LDAP error code.
 152  *
 153  * NOTES
 154  *  Free the referrals with ldap_value_free.
 155  */
 156 ULONG CDECL ldap_parse_referenceW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *message,
 157     PWCHAR **referrals )
 158 {
 159     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 160 #ifdef HAVE_LDAP_PARSE_REFERENCE
 161     char **referralsU = NULL;
 162
 163     TRACE( "(%p, %p, %p)\n", ld, message, referrals );
 164
 165     if (!ld) return ~0UL;
 166
 167     ret = ldap_parse_reference( ld, message, &referralsU, NULL, 0 );
 168
 169     *referrals = strarrayUtoW( referralsU );
 170     ldap_memfree( referralsU );
 171
 172 #endif
 173     return ret;
 174 }
 175
 176 /***********************************************************************
 177  *      ldap_parse_resultA     (WLDAP32.@)
 178  *
 179  * See ldap_parse_resultW.
 180  */
 181 ULONG CDECL ldap_parse_resultA( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
 182     ULONG *retcode, PCHAR *matched, PCHAR *error, PCHAR **referrals,
 183     PLDAPControlA **serverctrls, BOOLEAN free )
 184 {
 185     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 186 #ifdef HAVE_LDAP
 187     WCHAR **matchedW = NULL, **errorW = NULL, **referralsW = NULL;
 188     LDAPControlW **serverctrlsW = NULL;
 189
 190     TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
 191            matched, error, referrals, serverctrls, free );
 192
 193     if (!ld) return ~0UL;
 194
 195     ret = ldap_parse_resultW( ld, result, retcode, matchedW, errorW,
 196                               &referralsW, &serverctrlsW, free );
 197
 198     matched = strarrayWtoA( matchedW );
 199     error = strarrayWtoA( errorW );
 200
 201     *referrals = strarrayWtoA( referralsW );
 202     *serverctrls = controlarrayWtoA( serverctrlsW );
 203
 204     ldap_value_freeW( matchedW );
 205     ldap_value_freeW( errorW );
 206     ldap_value_freeW( referralsW );
 207     ldap_controls_freeW( serverctrlsW );
 208
 209 #endif
 210     return ret;
 211 }
 212
 213 /***********************************************************************
 214  *      ldap_parse_resultW     (WLDAP32.@)
 215  *
 216  * Parse a result message.
 217  *
 218  * PARAMS
 219  *  ld           [I] Pointer to an LDAP context.
 220  *  result       [I] Result message.
 221  *  retcode      [O] Return code for the server operation.
 222  *  matched      [O] DNs matched in the operation.
 223  *  error        [O] Error message for the operation.
 224  *  referrals    [O] Referrals found in the result message.
 225  *  serverctrls  [O] Controls used in the operation.
 226  *  free         [I] Free the result message?
 227  *
 228  * RETURNS
 229  *  Success: LDAP_SUCCESS
 230  *  Failure: An LDAP error code.
 231  *
 232  * NOTES
 233  *  Free the DNs and error message with ldap_memfree. Free
 234  *  the referrals with ldap_value_free and the controls with
 235  *  ldap_controls_free. Pass a nonzero value for 'free' or call
 236  *  ldap_msgfree to free the result message.
 237  */
 238 ULONG CDECL ldap_parse_resultW( WLDAP32_LDAP *ld, WLDAP32_LDAPMessage *result,
 239     ULONG *retcode, PWCHAR *matched, PWCHAR *error, PWCHAR **referrals,
 240     PLDAPControlW **serverctrls, BOOLEAN free )
 241 {
 242     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 243 #ifdef HAVE_LDAP
 244     char **matchedU = NULL, **errorU = NULL, **referralsU = NULL;
 245     LDAPControl **serverctrlsU = NULL;
 246
 247     TRACE( "(%p, %p, %p, %p, %p, %p, %p, 0x%02x)\n", ld, result, retcode,
 248            matched, error, referrals, serverctrls, free );
 249
 250     if (!ld) return ~0UL;
 251
 252     ret = ldap_parse_result( ld, result, (int *)retcode, matchedU, errorU,
 253                              &referralsU, &serverctrlsU, free );
 254
 255     matched = strarrayUtoW( matchedU );
 256     error = strarrayUtoW( errorU );
 257
 258     *referrals = strarrayUtoW( referralsU );
 259     *serverctrls = controlarrayUtoW( serverctrlsU );
 260
 261     ldap_memfree( matchedU );
 262     ldap_memfree( errorU );
 263     ldap_memfree( referralsU );
 264     ldap_controls_free( serverctrlsU );
 265
 266 #endif
 267     return ret;
 268 }
 269
 270 /***********************************************************************
 271  *      ldap_parse_sort_controlA     (WLDAP32.@)
 272  *
 273  * See ldap_parse_sort_controlW.
 274  */
 275 ULONG CDECL ldap_parse_sort_controlA( WLDAP32_LDAP *ld, PLDAPControlA *control,
 276     ULONG *result, PCHAR *attr )
 277 {
 278     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 279 #ifdef HAVE_LDAP
 280     WCHAR *attrW = NULL;
 281     LDAPControlW **controlW = NULL;
 282
 283     TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 284
 285     if (!ld) return ~0UL;
 286
 287     if (control) {
 288         controlW = controlarrayAtoW( control );
 289         if (!controlW) return WLDAP32_LDAP_NO_MEMORY;
 290     }
 291
 292     ret = ldap_parse_sort_controlW( ld, controlW, result, &attrW );
 293
 294     *attr = strWtoA( attrW );
 295     controlarrayfreeW( controlW );
 296
 297 #endif
 298     return ret;
 299 }
 300
 301 /***********************************************************************
 302  *      ldap_parse_sort_controlW     (WLDAP32.@)
 303  *
 304  * Parse a sort control.
 305  *
 306  * PARAMS
 307  *  ld       [I] Pointer to an LDAP context.
 308  *  control  [I] Control obtained from a result message.
 309  *  result   [O] Result code.
 310  *  attr     [O] Failing attribute.
 311  *
 312  * RETURNS
 313  *  Success: LDAP_SUCCESS
 314  *  Failure: An LDAP error code.
 315  *
 316  * NOTES
 317  *  If the function fails, free the failing attribute with ldap_memfree.
 318  */
 319 ULONG CDECL ldap_parse_sort_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control,
 320     ULONG *result, PWCHAR *attr )
 321 {
 322     ULONG ret = WLDAP32_LDAP_NOT_SUPPORTED;
 323 #ifdef HAVE_LDAP
 324     char *attrU = NULL;
 325     LDAPControl **controlU = NULL;
 326 #ifdef HAVE_LDAP_PARSE_SORT_CONTROL
 327     unsigned long res;
 328 #elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL)
 329     ber_int_t res;
 330     LDAPControl *sortcontrol = NULL;
 331     unsigned int i;
 332 #endif
 333
 334     TRACE( "(%p, %p, %p, %p)\n", ld, control, result, attr );
 335
 336     if (!ld) return ~0UL;
 337
 338     if (control) {
 339         controlU = controlarrayWtoU( control );
 340         if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
 341     }
 342
 343 #ifdef HAVE_LDAP_PARSE_SORT_CONTROL
 344     if (!(ret = ldap_parse_sort_control( ld, controlU, &res, &attrU )))
 345     {
 346         *result = res;
 347         *attr = strUtoW( attrU );
 348     }
 349 #elif defined(HAVE_LDAP_PARSE_SORTRESPONSE_CONTROL)
 350     for (i = 0; controlU[i]; i++)
 351     {
 352         if (!strcmp( LDAP_SERVER_RESP_SORT_OID, controlU[i]->ldctl_oid ))
 353             sortcontrol = controlU[i];
 354     }
 355     if (!sortcontrol)
 356     {
 357         controlarrayfreeU( controlU );
 358         return WLDAP32_LDAP_CONTROL_NOT_FOUND;
 359     }
 360     if (!(ret = ldap_parse_sortresponse_control( ld, sortcontrol, &res, &attrU )))
 361     {
 362         *result = res;
 363         *attr = strUtoW( attrU );
 364     }
 365 #endif
 366     controlarrayfreeU( controlU );
 367
 368 #endif
 369     return ret;
 370 }
 371
 372 /***********************************************************************
 373  *      ldap_parse_vlv_controlA     (WLDAP32.@)
 374  *
 375  * See ldap_parse_vlv_controlW.
 376  */
 377 INT CDECL ldap_parse_vlv_controlA( WLDAP32_LDAP *ld, PLDAPControlA *control,
 378     PULONG targetpos, PULONG listcount,
 379     struct WLDAP32_berval **context, PINT errcode )
 380 {
 381     int ret = WLDAP32_LDAP_NOT_SUPPORTED;
 382 #ifdef HAVE_LDAP
 383     LDAPControlW **controlW = NULL;
 384
 385     TRACE( "(%p, %p, %p, %p, %p, %p)\n", ld, control, targetpos,
 386            listcount, context, errcode );
 387
 388     if (!ld) return ~0UL;
 389
 390     if (control) {
 391         controlW = controlarrayAtoW( control );
 392         if (!controlW) return WLDAP32_LDAP_NO_MEMORY;
 393     }
 394
 395     ret = ldap_parse_vlv_controlW( ld, controlW, targetpos, listcount,
 396                                    context, errcode );
 397
 398     controlarrayfreeW( controlW );
 399
 400 #endif
 401     return ret;
 402 }
 403
 404 /***********************************************************************
 405  *      ldap_parse_vlv_controlW     (WLDAP32.@)
 406  *
 407  * Parse a virtual list view control.
 408  *
 409  * PARAMS
 410  *  ld         [I] Pointer to an LDAP context.
 411  *  control    [I] Controls obtained from a result message.
 412  *  targetpos  [O] Position of the target in the result list.
 413  *  listcount  [O] Estimate of the number of results in the list.
 414  *  context    [O] Server side context.
 415  *  errcode    [O] Error code from the listview operation.
 416  *
 417  * RETURNS
 418  *  Success: LDAP_SUCCESS
 419  *  Failure: An LDAP error code.
 420  *
 421  * NOTES
 422  *  Free the server context with ber_bvfree.
 423  */
 424 INT CDECL ldap_parse_vlv_controlW( WLDAP32_LDAP *ld, PLDAPControlW *control,
 425     PULONG targetpos, PULONG listcount,
 426     struct WLDAP32_berval **context, PINT errcode )
 427 {
 428     int ret = WLDAP32_LDAP_NOT_SUPPORTED;
 429 #ifdef HAVE_LDAP
 430     LDAPControl **controlU = NULL;
 431 #ifdef HAVE_LDAP_PARSE_VLV_CONTROL
 432     unsigned long pos, count;
 433 #elif defined(HAVE_LDAP_PARSE_VLVRESPONSE_CONTROL)
 434     ber_int_t pos, count;
 435     LDAPControl *vlvcontrol = NULL;
 436     unsigned int i;
 437 #endif
 438
 439     TRACE( "(%p, %p, %p, %p, %p, %p)\n", ld, control, targetpos,
 440            listcount, context, errcode );
 441
 442     if (!ld) return ~0UL;
 443
 444     if (control) {
 445         controlU = controlarrayWtoU( control );
 446         if (!controlU) return WLDAP32_LDAP_NO_MEMORY;
 447     }
 448
 449 #ifdef HAVE_LDAP_PARSE_VLV_CONTROL
 450     if (!(ret = ldap_parse_vlv_control( ld, controlU, &pos, &count,
 451                                         (struct berval **)context, errcode )))
 452     {
 453         *targetpos = pos;
 454         *listcount = count;
 455     }
 456 #elif defined(HAVE_LDAP_PARSE_VLVRESPONSE_CONTROL)
 457     for (i = 0; controlU[i]; i++)
 458     {
 459         if (!strcmp( LDAP_CONTROL_VLVRESPONSE, controlU[i]->ldctl_oid ))
 460             vlvcontrol = controlU[i];
 461     }
 462     if (!vlvcontrol)
 463     {
 464         controlarrayfreeU( controlU );
 465         return WLDAP32_LDAP_CONTROL_NOT_FOUND;
 466     }
 467     if (!(ret = ldap_parse_vlvresponse_control( ld, vlvcontrol, &pos, &count,
 468                                                 (struct berval **)context, errcode )))
 469     {
 470         *targetpos = pos;
 471         *listcount = count;
 472     }
 473 #endif
 474     controlarrayfreeU( controlU );
 475
 476 #endif
 477     return ret;
 478 }