ntdll: Fix a return code from RtlVerifyVersionInfo and change the FIXME to a TRACE...
[wine] / 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 #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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 CDECL 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 }