dlls/wldap32/page.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 <limits.h>
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winnls.h"
  27
  28 #include "wine/debug.h"
  29 #include "winldap_private.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(wldap32);
  32
  33 static struct WLDAP32_berval null_cookieW = { 0, NULL };
  34
  35 /***********************************************************************
  36  *      ldap_create_page_controlA     (WLDAP32.@)
  37  */
  38 ULONG CDECL ldap_create_page_controlA( LDAP *ld, ULONG pagesize, struct WLDAP32_berval *cookie, UCHAR critical,
  39                                        LDAPControlA **control )
  40 {
  41     ULONG ret;
  42     LDAPControlW *controlW = NULL;
  43
  44     TRACE( "(%p, %#lx, %p, 0x%02x, %p)\n", ld, pagesize, cookie, critical, control );
  45
  46     if (!ld || !control || pagesize > INT_MAX) return WLDAP32_LDAP_PARAM_ERROR;
  47
  48     ret = ldap_create_page_controlW( ld, pagesize, cookie, critical, &controlW );
  49     if (ret == WLDAP32_LDAP_SUCCESS)
  50     {
  51         *control = controlWtoA( controlW );
  52         ldap_control_freeW( controlW );
  53     }
  54     return ret;
  55 }
  56
  57 /* create a page control by hand */
  58 static ULONG create_page_control( ULONG pagesize, struct WLDAP32_berval *cookie, UCHAR critical,
  59                                   LDAPControlW **control )
  60 {
  61     LDAPControlW *ctrl;
  62     WLDAP32_BerElement *ber;
  63     struct WLDAP32_berval *berval, *vec[2];
  64     int ret, len;
  65     char *val;
  66
  67     if (!(ber = WLDAP32_ber_alloc_t( WLDAP32_LBER_USE_DER ))) return WLDAP32_LDAP_NO_MEMORY;
  68
  69     vec[1] = NULL;
  70     if (cookie)
  71         vec[0] = cookie;
  72     else
  73         vec[0] = &null_cookieW;
  74     len = WLDAP32_ber_printf( ber, (char *)"{iV}", pagesize, vec );
  75
  76     ret = WLDAP32_ber_flatten( ber, &berval );
  77     WLDAP32_ber_free( ber, 1 );
  78
  79     if (len == WLDAP32_LBER_ERROR) return WLDAP32_LDAP_ENCODING_ERROR;
  80     if (ret == -1) return WLDAP32_LDAP_NO_MEMORY;
  81
  82     /* copy the berval so it can be properly freed by the caller */
  83     if (!(val = malloc( berval->bv_len ))) return WLDAP32_LDAP_NO_MEMORY;
  84
  85     len = berval->bv_len;
  86     memcpy( val, berval->bv_val, len );
  87     WLDAP32_ber_bvfree( berval );
  88
  89     if (!(ctrl = malloc( sizeof(*ctrl) )))
  90     {
  91         free( val );
  92         return WLDAP32_LDAP_NO_MEMORY;
  93     }
  94     if (!(ctrl->ldctl_oid = strAtoW( LDAP_PAGED_RESULT_OID_STRING )))
  95     {
  96         free( val );
  97         free( ctrl );
  98         return WLDAP32_LDAP_NO_MEMORY;
  99     }
 100     ctrl->ldctl_value.bv_len = len;
 101     ctrl->ldctl_value.bv_val = val;
 102     ctrl->ldctl_iscritical   = critical;
 103
 104     *control = ctrl;
 105     return WLDAP32_LDAP_SUCCESS;
 106 }
 107
 108 /***********************************************************************
 109  *      ldap_create_page_controlW     (WLDAP32.@)
 110  */
 111 ULONG CDECL ldap_create_page_controlW( LDAP *ld, ULONG pagesize, struct WLDAP32_berval *cookie, UCHAR critical,
 112                                        LDAPControlW **control )
 113 {
 114     TRACE( "(%p, %#lx, %p, 0x%02x, %p)\n", ld, pagesize, cookie, critical, control );
 115
 116     if (!ld || !control || pagesize > INT_MAX) return WLDAP32_LDAP_PARAM_ERROR;
 117     return create_page_control( pagesize, cookie, critical, control );
 118 }
 119
 120 ULONG CDECL ldap_get_next_page( LDAP *ld, LDAPSearch *search, ULONG pagesize, ULONG *message )
 121 {
 122     FIXME( "(%p, %p, %#lx, %p)\n", ld, search, pagesize, message );
 123
 124     if (!ld) return ~0u;
 125     return WLDAP32_LDAP_NOT_SUPPORTED;
 126 }
 127
 128 ULONG CDECL ldap_get_next_page_s( LDAP *ld, LDAPSearch *search, struct l_timeval *timeout, ULONG pagesize,
 129                                   ULONG *count, WLDAP32_LDAPMessage **results )
 130 {
 131     ULONG ret;
 132
 133     TRACE( "(%p, %p, %p, %lu, %p, %p)\n", ld, search, timeout, pagesize, count, results );
 134
 135     if (!ld || !search || !count || !results) return ~0u;
 136
 137     if (search->cookie && !search->cookie->bv_len)
 138     {
 139         /* end of paged results */
 140         *count = 0;
 141         *results = NULL;
 142         return WLDAP32_LDAP_NO_RESULTS_RETURNED;
 143     }
 144
 145     if (search->serverctrls[0])
 146     {
 147         controlfreeW( search->serverctrls[0] );
 148         search->serverctrls[0] = NULL;
 149     }
 150
 151     TRACE("search->cookie: %s\n", search->cookie ? debugstr_an(search->cookie->bv_val, search->cookie->bv_len) : "NULL");
 152     ret = ldap_create_page_controlW( ld, pagesize, search->cookie, 1, &search->serverctrls[0] );
 153     if (ret != WLDAP32_LDAP_SUCCESS) return ret;
 154
 155     ret = ldap_search_ext_sW( ld, search->dn, search->scope, search->filter, search->attrs, search->attrsonly,
 156                               search->serverctrls, search->clientctrls,
 157                               search->timeout.tv_sec ? &search->timeout : NULL, search->sizelimit, results );
 158     if (ret != WLDAP32_LDAP_SUCCESS) return ret;
 159
 160     return ldap_get_paged_count( ld, search, count, *results );
 161 }
 162
 163 ULONG CDECL ldap_get_paged_count( LDAP *ld, LDAPSearch *search, ULONG *count, WLDAP32_LDAPMessage *results )
 164 {
 165     ULONG ret;
 166     LDAPControlW **server_ctrls = NULL;
 167
 168     TRACE( "(%p, %p, %p, %p)\n", ld, search, count, results );
 169
 170     if (!ld || !count || !results) return WLDAP32_LDAP_PARAM_ERROR;
 171
 172     *count = 0;
 173
 174     ret = ldap_parse_resultW( ld, results, NULL, NULL, NULL, NULL, &server_ctrls, 0 );
 175     if (ret != WLDAP32_LDAP_SUCCESS) return ret;
 176
 177     if (!server_ctrls) /* assume end of paged results */
 178     {
 179         search->cookie = &null_cookieW;
 180         return WLDAP32_LDAP_SUCCESS;
 181     }
 182
 183     free( search->cookie );
 184     search->cookie = NULL;
 185
 186     ret = ldap_parse_page_controlW( ld, server_ctrls, count, &search->cookie );
 187     if (ret == WLDAP32_LDAP_SUCCESS)
 188         TRACE( "new search->cookie: %s, count %lu\n",
 189                debugstr_an(search->cookie->bv_val, search->cookie->bv_len), *count );
 190
 191     ldap_controls_freeW( server_ctrls );
 192     return ret;
 193 }
 194
 195 /***********************************************************************
 196  *      ldap_parse_page_controlA      (WLDAP32.@)
 197  */
 198 ULONG CDECL ldap_parse_page_controlA( LDAP *ld, LDAPControlA **ctrls, ULONG *count, struct WLDAP32_berval **cookie )
 199 {
 200     ULONG ret;
 201     LDAPControlW **ctrlsW = NULL;
 202
 203     TRACE( "(%p, %p, %p, %p)\n", ld, ctrls, count, cookie );
 204
 205     if (!ld || !ctrls || !count || !cookie) return WLDAP32_LDAP_PARAM_ERROR;
 206
 207     if (!(ctrlsW = controlarrayAtoW( ctrls ))) return WLDAP32_LDAP_NO_MEMORY;
 208     ret = ldap_parse_page_controlW( ld, ctrlsW, count, cookie );
 209     controlarrayfreeW( ctrlsW );
 210     return ret;
 211 }
 212
 213 /***********************************************************************
 214  *      ldap_parse_page_controlW      (WLDAP32.@)
 215  */
 216 ULONG CDECL ldap_parse_page_controlW( LDAP *ld, LDAPControlW **ctrls, ULONG *ret_count,
 217                                       struct WLDAP32_berval **ret_cookie )
 218 {
 219     ULONG ret, count;
 220     LDAPControlW *control = NULL;
 221     WLDAP32_BerElement *ber;
 222     struct WLDAP32_berval *cookie = NULL;
 223     int tag;
 224     ULONG i;
 225
 226     TRACE( "(%p, %p, %p, %p)\n", ld, ctrls, ret_count, ret_cookie );
 227
 228     if (!ld || !ctrls || !ret_count || !ret_cookie) return WLDAP32_LDAP_PARAM_ERROR;
 229
 230     for (i = 0; ctrls[i]; i++)
 231     {
 232         if (!wcscmp( LDAP_PAGED_RESULT_OID_STRING_W, ctrls[i]->ldctl_oid ))
 233             control = ctrls[i];
 234     }
 235     if (!control) return WLDAP32_LDAP_CONTROL_NOT_FOUND;
 236
 237     if (!(ber = WLDAP32_ber_init( &control->ldctl_value ))) return WLDAP32_LDAP_NO_MEMORY;
 238
 239     tag = WLDAP32_ber_scanf( ber, (char *)"{iO}", &count, &cookie );
 240     if (tag == WLDAP32_LBER_ERROR) ret = WLDAP32_LDAP_DECODING_ERROR;
 241     else
 242     {
 243         *ret_count = count;
 244         *ret_cookie = cookie;
 245         ret = WLDAP32_LDAP_SUCCESS;
 246     }
 247
 248     WLDAP32_ber_free( ber, 1 );
 249     return ret;
 250 }
 251
 252 ULONG CDECL ldap_search_abandon_page( LDAP *ld, LDAPSearch *search )
 253 {
 254     LDAPControlW **ctrls;
 255
 256     TRACE( "(%p, %p)\n", ld, search );
 257
 258     if (!ld || !search) return ~0u;
 259
 260     free( search->dn );
 261     free( search->filter );
 262     strarrayfreeW( search->attrs );
 263     ctrls = search->serverctrls;
 264     controlfreeW( ctrls[0] ); /* page control */
 265     ctrls++;
 266     while (*ctrls) controlfreeW( *ctrls++ );
 267     free( search->serverctrls );
 268     controlarrayfreeW( search->clientctrls );
 269     if (search->cookie && search->cookie != &null_cookieW) free( search->cookie );
 270     free( search );
 271
 272     return WLDAP32_LDAP_SUCCESS;
 273 }
 274
 275 LDAPSearch * CDECL ldap_search_init_pageA( LDAP *ld, char *dn, ULONG scope, char *filter, char **attrs,
 276                                            ULONG attrsonly, LDAPControlA **serverctrls, LDAPControlA **clientctrls,
 277                                            ULONG timelimit, ULONG sizelimit, LDAPSortKeyA **sortkeys )
 278 {
 279     FIXME( "(%p, %s, %#lx, %s, %p, %#lx, %p, %p, %#lx, %#lx, %p)\n", ld, debugstr_a(dn), scope,
 280            debugstr_a(filter), attrs, attrsonly, serverctrls, clientctrls, timelimit, sizelimit, sortkeys );
 281     return NULL;
 282 }
 283
 284 LDAPSearch * CDECL ldap_search_init_pageW( LDAP *ld, WCHAR *dn, ULONG scope, WCHAR *filter, WCHAR **attrs,
 285                                            ULONG attrsonly, LDAPControlW **serverctrls, LDAPControlW **clientctrls,
 286                                            ULONG timelimit, ULONG sizelimit, LDAPSortKeyW **sortkeys )
 287 {
 288     LDAPSearch *search;
 289     DWORD i, len;
 290
 291     TRACE( "(%p, %s, %#lx, %s, %p, %#lx, %p, %p, %#lx, %#lx, %p)\n", ld, debugstr_w(dn), scope,
 292            debugstr_w(filter), attrs, attrsonly, serverctrls, clientctrls, timelimit, sizelimit, sortkeys );
 293
 294     if (!(search = calloc( 1, sizeof(*search) )))
 295     {
 296         ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 297         return NULL;
 298     }
 299
 300     if (dn && !(search->dn = wcsdup( dn ))) goto fail;
 301     if (filter && !(search->filter = wcsdup( filter ))) goto fail;
 302     if (attrs && !(search->attrs = strarraydupW( attrs ))) goto fail;
 303
 304     len = serverctrls ? controlarraylenW( serverctrls ) : 0;
 305     if (!(search->serverctrls = malloc( sizeof(LDAPControlW *) * (len + 2) ))) goto fail;
 306     search->serverctrls[0] = NULL; /* reserve 0 for page control */
 307     for (i = 0; i < len; i++)
 308     {
 309         if (!(search->serverctrls[i + 1] = controldupW( serverctrls[i] )))
 310         {
 311             for (; i > 0; i--) controlfreeW( search->serverctrls[i] );
 312             goto fail;
 313         }
 314     }
 315     search->serverctrls[len + 1] = NULL;
 316
 317     if (clientctrls && !(search->clientctrls = controlarraydupW( clientctrls )))
 318     {
 319         for (i = 0; i < len; i++) controlfreeW( search->serverctrls[i] );
 320         goto fail;
 321     }
 322
 323     search->scope           = scope;
 324     search->attrsonly       = attrsonly;
 325     search->timeout.tv_sec  = timelimit;
 326     search->timeout.tv_usec = 0;
 327     search->sizelimit       = sizelimit;
 328     search->cookie          = NULL;
 329     return search;
 330
 331 fail:
 332     ldap_search_abandon_page( ld, search );
 333     ld->ld_errno = WLDAP32_LDAP_NO_MEMORY;
 334     return NULL;
 335 }