?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wldap32: Remove DECLSPEC_HIDDEN usage.
[wine.git] / dlls / wldap32 / winldap_private.h
blobe834f9d4e6f433a4b63d10fbfc32ea7a4d1c8cc9
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 <assert.h>
22 #include <stdlib.h>
23 #include "winternl.h"
24 #include "wincrypt.h"
25 #include "winnls.h"
26
27 #define LDAP_NEEDS_PROTOTYPES
28 #include <lber.h>
29 #include <ldap.h>
30
31 #define WLDAP32_LBER_ERROR (~0l)
32
33 typedef enum {
34 WLDAP32_LDAP_SUCCESS = 0x00,
35 WLDAP32_LDAP_OPERATIONS_ERROR = 0x01,
36 WLDAP32_LDAP_PROTOCOL_ERROR = 0x02,
37 WLDAP32_LDAP_TIMELIMIT_EXCEEDED = 0x03,
38 WLDAP32_LDAP_SIZELIMIT_EXCEEDED = 0x04,
39 WLDAP32_LDAP_COMPARE_FALSE = 0x05,
40 WLDAP32_LDAP_COMPARE_TRUE = 0x06,
41 WLDAP32_LDAP_AUTH_METHOD_NOT_SUPPORTED = 0x07,
42 WLDAP32_LDAP_STRONG_AUTH_REQUIRED = 0x08,
43 WLDAP32_LDAP_REFERRAL_V2 = 0x09,
44 WLDAP32_LDAP_PARTIAL_RESULTS = 0x09,
45 WLDAP32_LDAP_REFERRAL = 0x0a,
46 WLDAP32_LDAP_ADMIN_LIMIT_EXCEEDED = 0x0b,
47 WLDAP32_LDAP_UNAVAILABLE_CRIT_EXTENSION = 0x0c,
48 WLDAP32_LDAP_CONFIDENTIALITY_REQUIRED = 0x0d,
49 WLDAP32_LDAP_SASL_BIND_IN_PROGRESS = 0x0e,
50
51 WLDAP32_LDAP_NO_SUCH_ATTRIBUTE = 0x10,
52 WLDAP32_LDAP_UNDEFINED_TYPE = 0x11,
53 WLDAP32_LDAP_INAPPROPRIATE_MATCHING = 0x12,
54 WLDAP32_LDAP_CONSTRAINT_VIOLATION = 0x13,
55 WLDAP32_LDAP_ATTRIBUTE_OR_VALUE_EXISTS = 0x14,
56 WLDAP32_LDAP_INVALID_SYNTAX = 0x15,
57
58 WLDAP32_LDAP_NO_SUCH_OBJECT = 0x20,
59 WLDAP32_LDAP_ALIAS_PROBLEM = 0x21,
60 WLDAP32_LDAP_INVALID_DN_SYNTAX = 0x22,
61 WLDAP32_LDAP_IS_LEAF = 0x23,
62 WLDAP32_LDAP_ALIAS_DEREF_PROBLEM = 0x24,
63
64 WLDAP32_LDAP_INAPPROPRIATE_AUTH = 0x30,
65 WLDAP32_LDAP_INVALID_CREDENTIALS = 0x31,
66 WLDAP32_LDAP_INSUFFICIENT_RIGHTS = 0x32,
67 WLDAP32_LDAP_BUSY = 0x33,
68 WLDAP32_LDAP_UNAVAILABLE = 0x34,
69 WLDAP32_LDAP_UNWILLING_TO_PERFORM = 0x35,
70 WLDAP32_LDAP_LOOP_DETECT = 0x36,
71 WLDAP32_LDAP_SORT_CONTROL_MISSING = 0x3C,
72 WLDAP32_LDAP_OFFSET_RANGE_ERROR = 0x3D,
73
74 WLDAP32_LDAP_NAMING_VIOLATION = 0x40,
75 WLDAP32_LDAP_OBJECT_CLASS_VIOLATION = 0x41,
76 WLDAP32_LDAP_NOT_ALLOWED_ON_NONLEAF = 0x42,
77 WLDAP32_LDAP_NOT_ALLOWED_ON_RDN = 0x43,
78 WLDAP32_LDAP_ALREADY_EXISTS = 0x44,
79 WLDAP32_LDAP_NO_OBJECT_CLASS_MODS = 0x45,
80 WLDAP32_LDAP_RESULTS_TOO_LARGE = 0x46,
81 WLDAP32_LDAP_AFFECTS_MULTIPLE_DSAS = 0x47,
82
83 WLDAP32_LDAP_VIRTUAL_LIST_VIEW_ERROR = 0x4c,
84
85 WLDAP32_LDAP_OTHER = 0x50,
86 WLDAP32_LDAP_SERVER_DOWN = 0x51,
87 WLDAP32_LDAP_LOCAL_ERROR = 0x52,
88 WLDAP32_LDAP_ENCODING_ERROR = 0x53,
89 WLDAP32_LDAP_DECODING_ERROR = 0x54,
90 WLDAP32_LDAP_TIMEOUT = 0x55,
91 WLDAP32_LDAP_AUTH_UNKNOWN = 0x56,
92 WLDAP32_LDAP_FILTER_ERROR = 0x57,
93 WLDAP32_LDAP_USER_CANCELLED = 0x58,
94 WLDAP32_LDAP_PARAM_ERROR = 0x59,
95 WLDAP32_LDAP_NO_MEMORY = 0x5a,
96 WLDAP32_LDAP_CONNECT_ERROR = 0x5b,
97 WLDAP32_LDAP_NOT_SUPPORTED = 0x5c,
98 WLDAP32_LDAP_CONTROL_NOT_FOUND = 0x5d,
99 WLDAP32_LDAP_NO_RESULTS_RETURNED = 0x5e,
100 WLDAP32_LDAP_MORE_RESULTS_TO_RETURN = 0x5f,
101
102 WLDAP32_LDAP_CLIENT_LOOP = 0x60,
103 WLDAP32_LDAP_REFERRAL_LIMIT_EXCEEDED = 0x61
104 } WLDAP32_LDAP_RETCODE;
105
106 #define WLDAP32_LDAP_SCOPE_BASE 0x00
107 #define WLDAP32_LDAP_SCOPE_ONELEVEL 0x01
108 #define WLDAP32_LDAP_SCOPE_SUBTREE 0x02
109
110 #define WLDAP32_LBER_USE_DER 0x01
111
112 #define WLDAP32_LDAP_OPT_API_INFO 0x00
113 #define WLDAP32_LDAP_OPT_DESC 0x01
114 #define WLDAP32_LDAP_OPT_DEREF 0x02
115 #define WLDAP32_LDAP_OPT_SIZELIMIT 0x03
116 #define WLDAP32_LDAP_OPT_TIMELIMIT 0x04
117 #define WLDAP32_LDAP_OPT_THREAD_FN_PTRS 0x05
118 #define WLDAP32_LDAP_OPT_REBIND_FN 0x06
119 #define WLDAP32_LDAP_OPT_REBIND_ARG 0x07
120 #define WLDAP32_LDAP_OPT_REFERRALS 0x08
121 #define WLDAP32_LDAP_OPT_RESTART 0x09
122 #define WLDAP32_LDAP_OPT_SSL 0x0a
123 #define WLDAP32_LDAP_OPT_IO_FN_PTRS 0x0b
124 #define WLDAP32_LDAP_OPT_CACHE_FN_PTRS 0x0d
125 #define WLDAP32_LDAP_OPT_CACHE_STRATEGY 0x0e
126 #define WLDAP32_LDAP_OPT_CACHE_ENABLE 0x0f
127 #define WLDAP32_LDAP_OPT_REFERRAL_HOP_LIMIT 0x10
128 #define WLDAP32_LDAP_OPT_PROTOCOL_VERSION 0x11
129 #define WLDAP32_LDAP_OPT_VERSION 0x11
130 #define WLDAP32_LDAP_OPT_SERVER_CONTROLS 0x12
131 #define WLDAP32_LDAP_OPT_API_FEATURE_INFO 0x15
132 #define WLDAP32_LDAP_OPT_HOST_NAME 0x30
133 #define WLDAP32_LDAP_OPT_ERROR_NUMBER 0x31
134 #define WLDAP32_LDAP_OPT_ERROR_STRING 0x32
135 #define WLDAP32_LDAP_OPT_SERVER_ERROR 0x33
136 #define WLDAP32_LDAP_OPT_SERVER_EXT_ERROR 0x34
137 #define WLDAP32_LDAP_OPT_PING_KEEP_ALIVE 0x36
138 #define WLDAP32_LDAP_OPT_PING_WAIT_TIME 0x37
139 #define WLDAP32_LDAP_OPT_PING_LIMIT 0x38
140 #define WLDAP32_LDAP_OPT_DNSDOMAIN_NAME 0x3b
141 #define WLDAP32_LDAP_OPT_GETDSNAME_FLAGS 0x3d
142 #define WLDAP32_LDAP_OPT_HOST_REACHABLE 0x3e
143 #define WLDAP32_LDAP_OPT_PROMPT_CREDENTIALS 0x3f
144 #define WLDAP32_LDAP_OPT_TCP_KEEPALIVE 0x40
145 #define WLDAP32_LDAP_OPT_FAST_CONCURRENT_BIND 0x41
146 #define WLDAP32_LDAP_OPT_SEND_TIMEOUT 0x42
147 #define WLDAP32_LDAP_OPT_REFERRAL_CALLBACK 0x70
148 #define WLDAP32_LDAP_OPT_CLIENT_CERTIFICATE 0x80
149 #define WLDAP32_LDAP_OPT_SERVER_CERTIFICATE 0x81
150 #define WLDAP32_LDAP_OPT_AUTO_RECONNECT 0x91
151 #define WLDAP32_LDAP_OPT_SSPI_FLAGS 0x92
152 #define WLDAP32_LDAP_OPT_SSL_INFO 0x93
153 #define WLDAP32_LDAP_OPT_REF_DEREF_CONN_PER_MSG 0x94
154 #define WLDAP32_LDAP_OPT_TLS LDAP_OPT_SSL
155 #define WLDAP32_LDAP_OPT_TLS_INFO LDAP_OPT_SSL_INFO
156 #define WLDAP32_LDAP_OPT_SIGN 0x95
157 #define WLDAP32_LDAP_OPT_ENCRYPT 0x96
158 #define WLDAP32_LDAP_OPT_SASL_METHOD 0x97
159 #define WLDAP32_LDAP_OPT_AREC_EXCLUSIVE 0x98
160 #define WLDAP32_LDAP_OPT_SECURITY_CONTEXT 0x99
161 #define WLDAP32_LDAP_OPT_ROOTDSE_CACHE 0x9a
162
163 #define WLDAP32_LDAP_OPT_ON ((void *)1)
164 #define WLDAP32_LDAP_OPT_OFF ((void *)0)
165
166 #define WLDAP32_LDAP_VERSION1 1
167 #define WLDAP32_LDAP_VERSION2 2
168 #define WLDAP32_LDAP_VERSION3 3
169 #define WLDAP32_LDAP_VERSION WLDAP32_LDAP_VERSION2
170
171 #define LDAP_CHASE_SUBORDINATE_REFERRALS 0x20
172 #define LDAP_CHASE_EXTERNAL_REFERRALS 0x40
173
174 #define WLDAP32_LDAP_AUTH_SIMPLE 0x80
175 #define WLDAP32_LDAP_AUTH_SASL 0x83
176 #define WLDAP32_LDAP_AUTH_OTHERKIND 0x86
177
178 #define WLDAP32_LDAP_AUTH_EXTERNAL (WLDAP32_LDAP_AUTH_OTHERKIND | 0x0020)
179 #define WLDAP32_LDAP_AUTH_SICILY (WLDAP32_LDAP_AUTH_OTHERKIND | 0x0200)
180 #define WLDAP32_LDAP_AUTH_NEGOTIATE (WLDAP32_LDAP_AUTH_OTHERKIND | 0x0400)
181 #define WLDAP32_LDAP_AUTH_MSN (WLDAP32_LDAP_AUTH_OTHERKIND | 0x0800)
182 #define WLDAP32_LDAP_AUTH_NTLM (WLDAP32_LDAP_AUTH_OTHERKIND | 0x1000)
183 #define WLDAP32_LDAP_AUTH_DPA (WLDAP32_LDAP_AUTH_OTHERKIND | 0x2000)
184 #define WLDAP32_LDAP_AUTH_DIGEST (WLDAP32_LDAP_AUTH_OTHERKIND | 0x4000)
185
186 typedef struct WLDAP32_berval
187 {
188 ULONG bv_len;
189 char *bv_val;
190 } LDAP_BERVAL, *PLDAP_BERVAL, BERVAL, *PBERVAL;
191
192 typedef struct WLDAP32_berelement
193 {
194 char *opaque;
195 } WLDAP32_BerElement;
196
197 struct ld_sb
198 {
199 UINT_PTR sb_sd;
200 UCHAR Reserved1[41];
201 ULONG_PTR sb_naddr;
202 UCHAR Reserved2[24];
203 };
204
205 typedef struct ldap
206 {
207 struct ld_sb ld_sb;
208 char *ld_host;
209 ULONG ld_version;
210 UCHAR ld_lberoptions;
211 ULONG ld_deref;
212 ULONG ld_timelimit;
213 ULONG ld_sizelimit;
214 ULONG ld_errno;
215 char *ld_matched;
216 char *ld_error;
217 ULONG ld_msgid;
218 UCHAR Reserved3[25];
219 ULONG ld_cldaptries;
220 ULONG ld_cldaptimeout;
221 ULONG ld_refhoplimit;
222 ULONG ld_options;
223 } LDAP, *PLDAP;
224
225 typedef BOOLEAN (CDECL VERIFYSERVERCERT)(LDAP *, const CERT_CONTEXT **);
226
227 struct private_data
228 {
229 LDAP *ctx;
230 struct berval **server_ctrls;
231 VERIFYSERVERCERT *cert_callback;
232 BOOL connected;
233 };
234 C_ASSERT(sizeof(struct private_data) < FIELD_OFFSET(struct ld_sb, sb_naddr) - FIELD_OFFSET(struct ld_sb, Reserved1));
235
236 #define CTX(ld) (((struct private_data *)ld->ld_sb.Reserved1)->ctx)
237 #define SERVER_CTRLS(ld) (((struct private_data *)ld->ld_sb.Reserved1)->server_ctrls)
238 #define CERT_CALLBACK(ld) (((struct private_data *)ld->ld_sb.Reserved1)->cert_callback)
239 #define CONNECTED(ld) (((struct private_data *)ld->ld_sb.Reserved1)->connected)
240
241 #define MSG(entry) (entry->Request)
242 #define BER(ber) ((BerElement *)((ber)->opaque))
243
244 typedef struct l_timeval
245 {
246 LONG tv_sec;
247 LONG tv_usec;
248 } LDAP_TIMEVAL, *PLDAP_TIMEVAL;
249
250 #define LDAP_PAGED_RESULT_OID_STRING "1.2.840.113556.1.4.319"
251 #define LDAP_SERVER_RESP_SORT_OID "1.2.840.113556.1.4.474"
252 #define LDAP_CONTROL_VLVRESPONSE "2.16.840.1.113730.3.4.10"
253
254 #define LDAP_PAGED_RESULT_OID_STRING_W L"1.2.840.113556.1.4.319"
255 #define LDAP_SERVER_RESP_SORT_OID_W L"1.2.840.113556.1.4.474"
256 #define LDAP_CONTROL_VLVRESPONSE_W L"2.16.840.1.113730.3.4.10"
257
258 typedef struct ldapcontrolA
259 {
260 char *ldctl_oid;
261 struct WLDAP32_berval ldctl_value;
262 BOOLEAN ldctl_iscritical;
263 } LDAPControlA, *PLDAPControlA;
264
265 typedef struct ldapcontrolW
266 {
267 WCHAR *ldctl_oid;
268 struct WLDAP32_berval ldctl_value;
269 BOOLEAN ldctl_iscritical;
270 } LDAPControlW, *PLDAPControlW;
271
272 typedef struct ldapmodA {
273 ULONG mod_op;
274 char *mod_type;
275 union {
276 char **modv_strvals;
277 struct WLDAP32_berval **modv_bvals;
278 } mod_vals;
279 } LDAPModA, *PLDAPModA;
280
281 typedef struct ldapmodW {
282 ULONG mod_op;
283 WCHAR *mod_type;
284 union {
285 WCHAR **modv_strvals;
286 struct WLDAP32_berval **modv_bvals;
287 } mod_vals;
288 } LDAPModW, *PLDAPModW;
289
290 typedef struct ldapsortkeyA
291 {
292 char *sk_attrtype;
293 char *sk_matchruleoid;
294 BOOLEAN sk_reverseorder;
295 } LDAPSortKeyA, *PLDAPSortKeyA;
296
297 typedef struct ldapsortkeyW
298 {
299 WCHAR *sk_attrtype;
300 WCHAR *sk_matchruleoid;
301 BOOLEAN sk_reverseorder;
302 } LDAPSortKeyW, *PLDAPSortKeyW;
303
304 typedef struct WLDAP32_ldapvlvinfo
305 {
306 int ldvlv_version;
307 ULONG ldvlv_before_count;
308 ULONG ldvlv_after_count;
309 ULONG ldvlv_offset;
310 ULONG ldvlv_count;
311 BERVAL *ldvlv_attrvalue;
312 BERVAL *ldvlv_context;
313 void *ldvlv_extradata;
314 } WLDAP32_LDAPVLVInfo, *WLDAP32_PLDAPVLVInfo;
315
316 typedef struct ldapmsg
317 {
318 ULONG lm_msgid;
319 ULONG lm_msgtype;
320 void *lm_ber;
321 struct ldapmsg *lm_chain;
322 struct ldapmsg *lm_next;
323 ULONG lm_time;
324
325 LDAP *Connection;
326 void *Request;
327 ULONG lm_returncode;
328 USHORT lm_referral;
329 BOOLEAN lm_chased;
330 BOOLEAN lm_eom;
331 BOOLEAN ConnectionReferenced;
332 } WLDAP32_LDAPMessage, *WLDAP32_PLDAPMessage;
333
334 typedef struct ldap_version_info
335 {
336 ULONG lv_size;
337 ULONG lv_major;
338 ULONG lv_minor;
339 } LDAP_VERSION_INFO, *PLDAP_VERSION_INFO;
340
341 typedef struct ldap_apifeature_infoA
342 {
343 int ldapaif_info_version;
344 char *ldapaif_name;
345 int ldapaif_version;
346 } LDAPAPIFeatureInfoA;
347
348 typedef struct ldap_apifeature_infoW
349 {
350 int ldapaif_info_version;
351 WCHAR *ldapaif_name;
352 int ldapaif_version;
353 } LDAPAPIFeatureInfoW;
354
355 typedef struct ldapapiinfoA
356 {
357 int ldapai_info_version;
358 int ldapai_api_version;
359 int ldapai_protocol_version;
360 char **ldapai_extensions;
361 char *ldapai_vendor_name;
362 int ldapai_vendor_version;
363 } LDAPAPIInfoA;
364
365 typedef struct ldapapiinfoW
366 {
367 int ldapai_info_version;
368 int ldapai_api_version;
369 int ldapai_protocol_version;
370 WCHAR **ldapai_extensions;
371 WCHAR *ldapai_vendor_name;
372 int ldapai_vendor_version;
373 } LDAPAPIInfoW;
374
375 typedef struct ldapsearch
376 {
377 WCHAR *dn;
378 WCHAR *filter;
379 WCHAR **attrs;
380 ULONG scope;
381 ULONG attrsonly;
382 LDAPControlW **serverctrls;
383 LDAPControlW **clientctrls;
384 struct l_timeval timeout;
385 ULONG sizelimit;
386 struct WLDAP32_berval *cookie;
387 } LDAPSearch;
388
389 void CDECL WLDAP32_ber_bvecfree( BERVAL ** );
390 void CDECL WLDAP32_ber_bvfree( BERVAL * );
391 void CDECL WLDAP32_ber_free( WLDAP32_BerElement *, int );
392 WLDAP32_BerElement * CDECL WLDAP32_ber_alloc_t( int ) __WINE_DEALLOC(WLDAP32_ber_free);
393 BERVAL * CDECL WLDAP32_ber_bvdup( BERVAL * ) __WINE_DEALLOC(WLDAP32_ber_bvfree);
394 ULONG CDECL WLDAP32_ber_first_element( WLDAP32_BerElement *, ULONG *, char ** );
395 int CDECL WLDAP32_ber_flatten( WLDAP32_BerElement *, BERVAL ** );
396 WLDAP32_BerElement * CDECL WLDAP32_ber_init( BERVAL * ) __WINE_DEALLOC(WLDAP32_ber_free);
397 ULONG CDECL WLDAP32_ber_next_element( WLDAP32_BerElement *, ULONG *, char * );
398 ULONG CDECL WLDAP32_ber_peek_tag( WLDAP32_BerElement *, ULONG * );
399 ULONG CDECL WLDAP32_ber_skip_tag( WLDAP32_BerElement *, ULONG * );
400 int WINAPIV WLDAP32_ber_printf( WLDAP32_BerElement *, char *, ... );
401 ULONG WINAPIV WLDAP32_ber_scanf( WLDAP32_BerElement *, char *, ... );
402
403 void CDECL ldap_memfreeA( char * );
404 void CDECL ldap_memfreeW( WCHAR * );
405 ULONG CDECL ldap_value_freeA( char ** );
406 ULONG CDECL ldap_value_freeW( WCHAR ** );
407 ULONG CDECL WLDAP32_ldap_msgfree( WLDAP32_LDAPMessage * );
408 ULONG CDECL WLDAP32_ldap_value_free_len(struct WLDAP32_berval **);
409 ULONG CDECL ldap_addA( LDAP *, char *, LDAPModA ** );
410 ULONG CDECL ldap_addW( LDAP *, WCHAR *, LDAPModW ** );
411 ULONG CDECL ldap_add_extA( LDAP *, char *, LDAPModA **, LDAPControlA **, LDAPControlA **, ULONG * );
412 ULONG CDECL ldap_add_extW( LDAP *, WCHAR *, LDAPModW **, LDAPControlW **, LDAPControlW **, ULONG * );
413 ULONG CDECL ldap_add_ext_sA( LDAP *, char *, LDAPModA **, LDAPControlA **, LDAPControlA ** );
414 ULONG CDECL ldap_add_ext_sW( LDAP *, WCHAR *, LDAPModW **, LDAPControlW **, LDAPControlW ** );
415 ULONG CDECL ldap_add_sA( LDAP *, char *, LDAPModA ** );
416 ULONG CDECL ldap_add_sW( LDAP *, WCHAR *, LDAPModW ** );
417 ULONG CDECL ldap_bindA( LDAP *, char *, char *, ULONG );
418 ULONG CDECL ldap_bindW( LDAP *, WCHAR *, WCHAR *, ULONG );
419 ULONG CDECL ldap_bind_sA( LDAP *, char *, char *, ULONG );
420 ULONG CDECL ldap_bind_sW( LDAP *, WCHAR *, WCHAR *, ULONG );
421 ULONG CDECL ldap_sasl_bindA( LDAP *, const PCHAR, const PCHAR, const BERVAL *, LDAPControlA **,
422 LDAPControlA **, int * );
423 ULONG CDECL ldap_sasl_bindW( LDAP *, const PWCHAR, const PWCHAR, const BERVAL *, LDAPControlW **,
424 LDAPControlW **, int * );
425 ULONG CDECL ldap_sasl_bind_sA( LDAP *,const PCHAR, const PCHAR, const BERVAL *, LDAPControlA **,
426 LDAPControlA **, BERVAL ** );
427 ULONG CDECL ldap_sasl_bind_sW( LDAP *,const PWCHAR, const PWCHAR ,const BERVAL *, LDAPControlW **,
428 LDAPControlW **, BERVAL ** );
429 ULONG CDECL ldap_simple_bindA( LDAP *, char *, char * );
430 ULONG CDECL ldap_simple_bindW( LDAP *, WCHAR *, WCHAR * );
431 ULONG CDECL ldap_simple_bind_sA( LDAP *, char *, char * );
432 ULONG CDECL ldap_simple_bind_sW( LDAP *, WCHAR *, WCHAR * );
433 ULONG CDECL ldap_compareA( LDAP *, char *, char *, char * );
434 ULONG CDECL ldap_compareW( LDAP *, WCHAR *, WCHAR *, WCHAR * );
435 ULONG CDECL ldap_compare_extA( LDAP *, char *, char *, char *, struct WLDAP32_berval *, LDAPControlA **,
436 LDAPControlA **, ULONG* );
437 ULONG CDECL ldap_compare_extW( LDAP *, WCHAR *, WCHAR *, WCHAR *, struct WLDAP32_berval *, LDAPControlW **,
438 LDAPControlW **, ULONG * );
439 ULONG CDECL ldap_compare_ext_sA( LDAP *, char *, char *, char *, struct WLDAP32_berval *, LDAPControlA **,
440 LDAPControlA ** );
441 ULONG CDECL ldap_compare_ext_sW( LDAP *, WCHAR *, WCHAR *, WCHAR *, struct WLDAP32_berval *, LDAPControlW **,
442 LDAPControlW ** );
443 ULONG CDECL ldap_compare_sA( LDAP *, char *, char *, char * );
444 ULONG CDECL ldap_compare_sW( LDAP *, WCHAR *, WCHAR *, WCHAR * );
445 ULONG CDECL WLDAP32_ldap_connect( LDAP *, struct l_timeval * );
446 ULONG CDECL ldap_create_sort_controlA( LDAP *, LDAPSortKeyA **, UCHAR, LDAPControlA ** );
447 ULONG CDECL ldap_create_sort_controlW( LDAP *, LDAPSortKeyW **, UCHAR, LDAPControlW ** );
448 int CDECL ldap_create_vlv_controlA( LDAP *, WLDAP32_LDAPVLVInfo *, UCHAR, LDAPControlA ** );
449 int CDECL ldap_create_vlv_controlW( LDAP *, WLDAP32_LDAPVLVInfo *, UCHAR, LDAPControlW ** );
450 ULONG CDECL ldap_deleteA( LDAP *, char * );
451 ULONG CDECL ldap_deleteW( LDAP *, WCHAR * );
452 ULONG CDECL ldap_delete_extA( LDAP *, char *, LDAPControlA **, LDAPControlA **, ULONG * );
453 ULONG CDECL ldap_delete_extW( LDAP *, WCHAR *, LDAPControlW **, LDAPControlW **, ULONG * );
454 ULONG CDECL ldap_delete_ext_sA( LDAP *, char *, LDAPControlA **, LDAPControlA ** );
455 ULONG CDECL ldap_delete_ext_sW( LDAP *, WCHAR *, LDAPControlW **, LDAPControlW ** );
456 ULONG CDECL ldap_delete_sA( LDAP *, char * );
457 ULONG CDECL ldap_delete_sW( LDAP *, WCHAR * );
458 char * CDECL ldap_dn2ufnA( char * ) __WINE_DEALLOC(ldap_memfreeA) __WINE_MALLOC;
459 WCHAR * CDECL ldap_dn2ufnW( WCHAR * ) __WINE_DEALLOC(ldap_memfreeW) __WINE_MALLOC;
460 char ** CDECL ldap_explode_dnA( char *, ULONG ) __WINE_DEALLOC(ldap_value_freeA);
461 WCHAR ** CDECL ldap_explode_dnW( WCHAR *, ULONG ) __WINE_DEALLOC(ldap_value_freeW);
462 char * CDECL ldap_get_dnA( LDAP *, WLDAP32_LDAPMessage * ) __WINE_DEALLOC(ldap_memfreeA) __WINE_MALLOC;
463 WCHAR * CDECL ldap_get_dnW( LDAP *, WLDAP32_LDAPMessage * ) __WINE_DEALLOC(ldap_memfreeW) __WINE_MALLOC;
464 ULONG CDECL ldap_ufn2dnA( char *, char ** );
465 ULONG CDECL ldap_ufn2dnW( WCHAR *, WCHAR ** );
466 ULONG CDECL ldap_extended_operationA( LDAP *, char *, struct WLDAP32_berval *, LDAPControlA **, LDAPControlA **,
467 ULONG * );
468 ULONG CDECL ldap_extended_operationW( LDAP *, WCHAR *, struct WLDAP32_berval *, LDAPControlW **, LDAPControlW **,
469 ULONG * );
470 ULONG CDECL ldap_extended_operation_sA( LDAP *, char *, struct WLDAP32_berval *, LDAPControlA **, LDAPControlA **,
471 char **, struct WLDAP32_berval ** );
472 ULONG CDECL ldap_extended_operation_sW( LDAP *, WCHAR *, struct WLDAP32_berval *, LDAPControlW **, LDAPControlW **,
473 WCHAR **, struct WLDAP32_berval ** );
474 LDAP * CDECL cldap_openA( char *, ULONG );
475 LDAP * CDECL cldap_openW( WCHAR *, ULONG );
476 LDAP * CDECL ldap_initA( const PCHAR, ULONG );
477 LDAP * CDECL ldap_initW( const PWCHAR, ULONG );
478 LDAP * CDECL ldap_openA( char *, ULONG );
479 LDAP * CDECL ldap_openW( WCHAR *, ULONG );
480 LDAP * CDECL ldap_sslinitA( char *, ULONG, int );
481 LDAP * CDECL ldap_sslinitW( WCHAR *, ULONG, int );
482 ULONG CDECL ldap_start_tls_sA( LDAP *, ULONG *, WLDAP32_LDAPMessage **, LDAPControlA **, LDAPControlA ** );
483 ULONG CDECL ldap_start_tls_sW( LDAP *, ULONG *, WLDAP32_LDAPMessage **, LDAPControlW **, LDAPControlW ** );
484 ULONG CDECL ldap_check_filterA( LDAP *, char * );
485 ULONG CDECL ldap_check_filterW( LDAP *, WCHAR * );
486 char * CDECL ldap_first_attributeA( LDAP *, WLDAP32_LDAPMessage *,
487 WLDAP32_BerElement ** ) __WINE_DEALLOC(ldap_memfreeA) __WINE_MALLOC;
488 WCHAR * CDECL ldap_first_attributeW( LDAP *, WLDAP32_LDAPMessage *,
489 WLDAP32_BerElement ** ) __WINE_DEALLOC(ldap_memfreeW) __WINE_MALLOC;
490 char * CDECL ldap_next_attributeA( LDAP *, WLDAP32_LDAPMessage *,
491 WLDAP32_BerElement * ) __WINE_DEALLOC(ldap_memfreeA) __WINE_MALLOC;
492 WCHAR * CDECL ldap_next_attributeW( LDAP *, WLDAP32_LDAPMessage *,
493 WLDAP32_BerElement * ) __WINE_DEALLOC(ldap_memfreeW) __WINE_MALLOC;
494 ULONG CDECL WLDAP32_ldap_result( LDAP *, ULONG, ULONG, struct l_timeval *, WLDAP32_LDAPMessage ** );
495 ULONG CDECL ldap_modifyA( LDAP *, char *, LDAPModA ** );
496 ULONG CDECL ldap_modifyW( LDAP *, WCHAR *, LDAPModW ** );
497 ULONG CDECL ldap_modify_extA( LDAP *, char *, LDAPModA **, LDAPControlA **, LDAPControlA **, ULONG * );
498 ULONG CDECL ldap_modify_extW( LDAP *, WCHAR *, LDAPModW **, LDAPControlW **, LDAPControlW **, ULONG * );
499 ULONG CDECL ldap_modify_ext_sA( LDAP *, char *, LDAPModA **, LDAPControlA **, LDAPControlA ** );
500 ULONG CDECL ldap_modify_ext_sW( LDAP *, WCHAR *, LDAPModW **, LDAPControlW **, LDAPControlW ** );
501 ULONG CDECL ldap_modify_sA( LDAP *, char *, LDAPModA ** );
502 ULONG CDECL ldap_modify_sW( LDAP *, WCHAR *, LDAPModW ** );
503 ULONG CDECL ldap_modrdnA( LDAP *, char *, char * );
504 ULONG CDECL ldap_modrdnW( LDAP *, WCHAR *, WCHAR * );
505 ULONG CDECL ldap_modrdn2A( LDAP *, char *, char *, int );
506 ULONG CDECL ldap_modrdn2W( LDAP *, WCHAR *, WCHAR *, int );
507 ULONG CDECL ldap_modrdn2_sA( LDAP *, char *, char *, int );
508 ULONG CDECL ldap_modrdn2_sW( LDAP *, WCHAR *, WCHAR *, int );
509 ULONG CDECL ldap_modrdn_sA( LDAP *, char *, char * );
510 ULONG CDECL ldap_modrdn_sW( LDAP *, WCHAR *, WCHAR * );
511 ULONG CDECL ldap_get_optionA( LDAP *, int, void * );
512 ULONG CDECL ldap_get_optionW( LDAP *, int, void * );
513 ULONG CDECL ldap_set_optionA( LDAP *, int, void * );
514 ULONG CDECL ldap_set_optionW( LDAP *, int, void * );
515 ULONG CDECL ldap_create_page_controlA( LDAP *, ULONG, struct WLDAP32_berval *, UCHAR, LDAPControlA ** );
516 ULONG CDECL ldap_create_page_controlW( LDAP *, ULONG, struct WLDAP32_berval *, UCHAR, LDAPControlW ** );
517 ULONG CDECL ldap_control_freeA( LDAPControlA * );
518 ULONG CDECL ldap_control_freeW( LDAPControlW * );
519 ULONG CDECL ldap_search_ext_sA( LDAP *, char *, ULONG, char *, char **, ULONG, LDAPControlA **, LDAPControlA **,
520 struct l_timeval *, ULONG, WLDAP32_LDAPMessage ** );
521 ULONG CDECL ldap_search_ext_sW( LDAP *, WCHAR *, ULONG, WCHAR *, WCHAR **, ULONG, LDAPControlW **, LDAPControlW **,
522 struct l_timeval *, ULONG, WLDAP32_LDAPMessage ** );
523 ULONG CDECL ldap_get_paged_count( LDAP *, LDAPSearch *, ULONG *, WLDAP32_LDAPMessage * );
524 ULONG CDECL ldap_parse_resultA( LDAP *, WLDAP32_LDAPMessage *, ULONG *, char **, char **, char ***,
525 LDAPControlA ***, BOOLEAN );
526 ULONG CDECL ldap_parse_resultW( LDAP *, WLDAP32_LDAPMessage *, ULONG *, WCHAR **, WCHAR **, WCHAR ***,
527 LDAPControlW ***, BOOLEAN );
528 ULONG CDECL ldap_parse_page_controlA( LDAP *, LDAPControlA **, ULONG *, struct WLDAP32_berval ** );
529 ULONG CDECL ldap_parse_page_controlW( LDAP *, LDAPControlW **, ULONG *, struct WLDAP32_berval ** );
530 ULONG CDECL ldap_controls_freeA( LDAPControlA ** );
531 ULONG CDECL ldap_controls_freeW( LDAPControlW ** );
532 ULONG CDECL ldap_parse_extended_resultA( LDAP *, WLDAP32_LDAPMessage *, char **, struct WLDAP32_berval **, BOOLEAN );
533 ULONG CDECL ldap_parse_extended_resultW( LDAP *, WLDAP32_LDAPMessage *, WCHAR **, struct WLDAP32_berval **, BOOLEAN );
534 ULONG CDECL ldap_parse_referenceA( LDAP *, WLDAP32_LDAPMessage *, char *** );
535 ULONG CDECL ldap_parse_referenceW( LDAP *, WLDAP32_LDAPMessage *, WCHAR *** );
536 ULONG CDECL ldap_parse_sort_controlA( LDAP *, LDAPControlA **, ULONG *, char ** );
537 ULONG CDECL ldap_parse_sort_controlW( LDAP *, LDAPControlW **, ULONG *, WCHAR ** );
538 int CDECL ldap_parse_vlv_controlA( LDAP *, LDAPControlA **, ULONG *, ULONG *, struct WLDAP32_berval **, int * );
539 int CDECL ldap_parse_vlv_controlW( LDAP *, LDAPControlW **, ULONG *, ULONG *, struct WLDAP32_berval **, int * );
540 ULONG CDECL ldap_rename_extA( LDAP *, char *, char *, char *, int, LDAPControlA **, LDAPControlA **, ULONG * );
541 ULONG CDECL ldap_rename_extW( LDAP *, WCHAR *, WCHAR *, WCHAR *, int, LDAPControlW **, LDAPControlW **, ULONG * );
542 ULONG CDECL ldap_rename_ext_sA( LDAP *, char *, char *, char *, int, LDAPControlA **, LDAPControlA ** );
543 ULONG CDECL ldap_rename_ext_sW( LDAP *, WCHAR *, WCHAR *, WCHAR *, int, LDAPControlW **, LDAPControlW ** );
544 ULONG CDECL ldap_searchA( LDAP *, char *, ULONG, char *, char **, ULONG );
545 ULONG CDECL ldap_searchW( LDAP *, WCHAR *, ULONG, WCHAR *, WCHAR **, ULONG );
546 ULONG CDECL ldap_search_extA( LDAP *, char *, ULONG, char *, char **, ULONG, LDAPControlA **, LDAPControlA **,
547 ULONG, ULONG, ULONG * );
548 ULONG CDECL ldap_search_extW( LDAP *, PWCHAR, ULONG, PWCHAR, PWCHAR[], ULONG, LDAPControlW **, LDAPControlW **,
549 ULONG, ULONG, ULONG * );
550 ULONG CDECL ldap_search_sA( LDAP *, char *, ULONG, char *, char **, ULONG, WLDAP32_LDAPMessage ** );
551 ULONG CDECL ldap_search_sW( LDAP *, WCHAR *, ULONG, WCHAR *, WCHAR **, ULONG, WLDAP32_LDAPMessage ** );
552 ULONG CDECL ldap_search_stA( LDAP *, const PCHAR, ULONG, const PCHAR, char **, ULONG, struct l_timeval *,
553 WLDAP32_LDAPMessage ** );
554 ULONG CDECL ldap_search_stW( LDAP *, const PWCHAR, ULONG, const PWCHAR, WCHAR **, ULONG, struct l_timeval *,
555 WLDAP32_LDAPMessage ** );
556 char ** CDECL ldap_get_valuesA( LDAP *, WLDAP32_LDAPMessage *, char * ) __WINE_DEALLOC(ldap_value_freeA);
557 WCHAR ** CDECL ldap_get_valuesW( LDAP *, WLDAP32_LDAPMessage *, WCHAR * ) __WINE_DEALLOC(ldap_value_freeW);
558 struct WLDAP32_berval ** CDECL ldap_get_values_lenA( LDAP *, LDAPMessage *,
559 char * ) __WINE_DEALLOC(WLDAP32_ldap_value_free_len);
560 struct WLDAP32_berval ** CDECL ldap_get_values_lenW( LDAP *, LDAPMessage *,
561 WCHAR * ) __WINE_DEALLOC(WLDAP32_ldap_value_free_len);
562
563 ULONG map_error( int );
564
565 static inline char *strWtoU( const WCHAR *str )
566 {
567 char *ret = NULL;
568 if (str)
569 {
570 int len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
571 if ((ret = malloc( len ))) WideCharToMultiByte( CP_UTF8, 0, str, -1, ret, len, NULL, NULL );
572 }
573 return ret;
574 }
575
576 static inline char *strnWtoU( const WCHAR *str, DWORD in_len, DWORD *out_len )
577 {
578 char *ret = NULL;
579 *out_len = 0;
580 if (str)
581 {
582 DWORD len = WideCharToMultiByte( CP_UTF8, 0, str, in_len, NULL, 0, NULL, NULL );
583 if ((ret = malloc( len + 1 )))
584 {
585 WideCharToMultiByte( CP_UTF8, 0, str, in_len, ret, len, NULL, NULL );
586 ret[len] = 0;
587 *out_len = len;
588 }
589 }
590 return ret;
591 }
592
593 static inline WCHAR *strAtoW( const char *str )
594 {
595 WCHAR *ret = NULL;
596 if (str)
597 {
598 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
599 if ((ret = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
600 }
601 return ret;
602 }
603
604 static inline WCHAR *strnAtoW( const char *str, DWORD in_len, DWORD *out_len )
605 {
606 WCHAR *ret = NULL;
607 *out_len = 0;
608 if (str)
609 {
610 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, in_len, NULL, 0 );
611 if ((ret = malloc( (len + 1) * sizeof(WCHAR) )))
612 {
613 MultiByteToWideChar( CP_ACP, 0, str, in_len, ret, len );
614 ret[len] = 0;
615 *out_len = len;
616 }
617 }
618 return ret;
619 }
620
621 static inline char *strreplace( const char *s, const char *before, const char *after )
622 {
623 char *ret = malloc( strlen( s ) + strlen( after ) / strlen( before ) + 1 );
624 char *cur, *prev = ret;
625 if (ret)
626 {
627 ret[0] = 0;
628 for (cur = strstr( s, before ); cur; cur = strstr( prev, before ))
629 {
630 strncat( ret, prev, cur - prev );
631 strcat( ret, after );
632 prev = cur + strlen( before );
633 }
634 strncat( ret, prev, cur - prev );
635 }
636 return ret;
637 }
638
639 static inline DWORD bvarraylenW( struct WLDAP32_berval **bv )
640 {
641 struct WLDAP32_berval **p = bv;
642 while (*p) p++;
643 return p - bv;
644 }
645
646 static inline DWORD strarraylenW( WCHAR **strarray )
647 {
648 WCHAR **p = strarray;
649 while (*p) p++;
650 return p - strarray;
651 }
652
653 static inline char **strarrayWtoU( WCHAR **strarray )
654 {
655 char **ret = NULL;
656 DWORD size;
657
658 if (strarray)
659 {
660 size = sizeof(char *) * (strarraylenW( strarray ) + 1);
661 if ((ret = malloc( size )))
662 {
663 WCHAR **p = strarray;
664 char **q = ret;
665
666 while (*p) *q++ = strWtoU( *p++ );
667 *q = NULL;
668 }
669 }
670 return ret;
671 }
672
673 static inline WCHAR **strarraydupW( WCHAR **strarray )
674 {
675 WCHAR **ret = NULL;
676 DWORD size;
677
678 if (strarray)
679 {
680 size = sizeof(WCHAR *) * (strarraylenW( strarray ) + 1);
681 if ((ret = malloc( size )))
682 {
683 WCHAR **p = strarray, **q = ret;
684
685 while (*p) *q++ = wcsdup( *p++ );
686 *q = NULL;
687 }
688 }
689 return ret;
690 }
691
692 static inline char *strWtoA( const WCHAR *str )
693 {
694 char *ret = NULL;
695 if (str)
696 {
697 DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
698 if ((ret = malloc( len ))) WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
699 }
700 return ret;
701 }
702
703 static inline char **strarrayWtoA( WCHAR **strarray )
704 {
705 char **ret = NULL;
706 DWORD size;
707
708 if (strarray)
709 {
710 size = sizeof(char *) * (strarraylenW( strarray ) + 1);
711 if ((ret = malloc( size )))
712 {
713 WCHAR **p = strarray;
714 char **q = ret;
715
716 while (*p) *q++ = strWtoA( *p++ );
717 *q = NULL;
718 }
719 }
720 return ret;
721 }
722
723 static inline DWORD modarraylenW( LDAPModW **modarray )
724 {
725 LDAPModW **p = modarray;
726 while (*p) p++;
727 return p - modarray;
728 }
729
730 static inline struct berval *bervalWtoU( const struct WLDAP32_berval *bv )
731 {
732 struct berval *ret;
733 DWORD size = sizeof(*ret) + bv->bv_len;
734
735 if ((ret = malloc( size )))
736 {
737 char *val = (char *)(ret + 1);
738
739 ret->bv_len = bv->bv_len;
740 ret->bv_val = val;
741 memcpy( val, bv->bv_val, bv->bv_len );
742 }
743 return ret;
744 }
745
746 static inline DWORD bvarraylenU( struct berval **bv )
747 {
748 struct berval **p = bv;
749 while (*p) p++;
750 return p - bv;
751 }
752
753 static inline struct WLDAP32_berval *bervalUtoW( const struct berval *bv )
754 {
755 struct WLDAP32_berval *ret;
756 DWORD size = sizeof(*ret) + bv->bv_len;
757
758 assert( bv->bv_len <= ~0u );
759
760 if ((ret = malloc( size )))
761 {
762 char *val = (char *)(ret + 1);
763
764 ret->bv_len = bv->bv_len;
765 ret->bv_val = val;
766 memcpy( val, bv->bv_val, bv->bv_len );
767 }
768 return ret;
769 }
770
771 static inline struct WLDAP32_berval **bvarrayUtoW( struct berval **bv )
772 {
773 struct WLDAP32_berval **ret = NULL;
774 DWORD size;
775
776 if (bv)
777 {
778 size = sizeof(*ret) * (bvarraylenU( bv ) + 1);
779 if ((ret = malloc( size )))
780 {
781 struct berval **p = bv;
782 struct WLDAP32_berval **q = ret;
783
784 while (*p) *q++ = bervalUtoW( *p++ );
785 *q = NULL;
786 }
787 }
788 return ret;
789 }
790
791 static inline struct berval **bvarrayWtoU( struct WLDAP32_berval **bv )
792 {
793 struct berval **ret = NULL;
794 DWORD size;
795
796 if (bv)
797 {
798 size = sizeof(*ret) * (bvarraylenW( bv ) + 1);
799 if ((ret = malloc( size )))
800 {
801 struct WLDAP32_berval **p = bv;
802 struct berval **q = ret;
803
804 while (*p) *q++ = bervalWtoU( *p++ );
805 *q = NULL;
806 }
807 }
808 return ret;
809 }
810
811 static inline LDAPMod *modWtoU( const LDAPModW *mod )
812 {
813 LDAPMod *ret;
814
815 if ((ret = malloc( sizeof(*ret) )))
816 {
817 ret->mod_op = mod->mod_op;
818 ret->mod_type = strWtoU( mod->mod_type );
819
820 if (mod->mod_op & LDAP_MOD_BVALUES)
821 ret->mod_vals.modv_bvals = bvarrayWtoU( mod->mod_vals.modv_bvals );
822 else
823 ret->mod_vals.modv_strvals = strarrayWtoU( mod->mod_vals.modv_strvals );
824 }
825 return ret;
826 }
827
828 static inline LDAPMod **modarrayWtoU( LDAPModW **modarray )
829 {
830 LDAPMod **ret = NULL;
831 DWORD size;
832
833 if (modarray)
834 {
835 size = sizeof(*ret) * (modarraylenW( modarray ) + 1);
836 if ((ret = malloc( size )))
837 {
838 LDAPModW **p = modarray;
839 LDAPMod **q = ret;
840
841 while (*p) *q++ = modWtoU( *p++ );
842 *q = NULL;
843 }
844 }
845 return ret;
846 }
847
848 static inline void bvarrayfreeU( struct berval **bv )
849 {
850 struct berval **p = bv;
851 while (*p) free( *p++ );
852 free( bv );
853 }
854
855 static inline void strarrayfreeU( char **strarray )
856 {
857 if (strarray)
858 {
859 char **p = strarray;
860 while (*p) free( *p++ );
861 free( strarray );
862 }
863 }
864
865 static inline void modfreeU( LDAPMod *mod )
866 {
867 if (mod->mod_op & LDAP_MOD_BVALUES)
868 bvarrayfreeU( mod->mod_vals.modv_bvals );
869 else
870 strarrayfreeU( mod->mod_vals.modv_strvals );
871 free( mod );
872 }
873
874 static inline void modarrayfreeU( LDAPMod **modarray )
875 {
876 if (modarray)
877 {
878 LDAPMod **p = modarray;
879 while (*p) modfreeU( *p++ );
880 free( modarray );
881 }
882 }
883
884 static inline DWORD modarraylenA( LDAPModA **modarray )
885 {
886 LDAPModA **p = modarray;
887 while (*p) p++;
888 return p - modarray;
889 }
890
891 static inline struct WLDAP32_berval *bervalWtoW( const struct WLDAP32_berval *bv )
892 {
893 struct WLDAP32_berval *ret;
894 DWORD size = sizeof(*ret) + bv->bv_len;
895
896 if ((ret = malloc( size )))
897 {
898 char *val = (char *)(ret + 1);
899
900 ret->bv_len = bv->bv_len;
901 ret->bv_val = val;
902 memcpy( val, bv->bv_val, bv->bv_len );
903 }
904 return ret;
905 }
906
907 static inline struct WLDAP32_berval **bvarrayWtoW( struct WLDAP32_berval **bv )
908 {
909 struct WLDAP32_berval **ret = NULL;
910 DWORD size;
911
912 if (bv)
913 {
914 size = sizeof(*ret) * (bvarraylenW( bv ) + 1);
915 if ((ret = malloc( size )))
916 {
917 struct WLDAP32_berval **p = bv, **q = ret;
918
919 while (*p) *q++ = bervalWtoW( *p++ );
920 *q = NULL;
921 }
922 }
923 return ret;
924 }
925
926 static inline DWORD strarraylenA( char **strarray )
927 {
928 char **p = strarray;
929 while (*p) p++;
930 return p - strarray;
931 }
932
933 static inline WCHAR **strarrayAtoW( char **strarray )
934 {
935 WCHAR **ret = NULL;
936 DWORD size;
937
938 if (strarray)
939 {
940 size = sizeof(*ret) * (strarraylenA( strarray ) + 1);
941 if ((ret = malloc( size )))
942 {
943 char **p = strarray;
944 WCHAR **q = ret;
945
946 while (*p) *q++ = strAtoW( *p++ );
947 *q = NULL;
948 }
949 }
950 return ret;
951 }
952
953 static inline LDAPModW *modAtoW( const LDAPModA *mod )
954 {
955 LDAPModW *ret;
956
957 if ((ret = malloc( sizeof(*ret) )))
958 {
959 ret->mod_op = mod->mod_op;
960 ret->mod_type = strAtoW( mod->mod_type );
961
962 if (mod->mod_op & LDAP_MOD_BVALUES)
963 ret->mod_vals.modv_bvals = bvarrayWtoW( mod->mod_vals.modv_bvals );
964 else
965 ret->mod_vals.modv_strvals = strarrayAtoW( mod->mod_vals.modv_strvals );
966 }
967 return ret;
968 }
969
970 static inline LDAPModW **modarrayAtoW( LDAPModA **modarray )
971 {
972 LDAPModW **ret = NULL;
973 DWORD size;
974
975 if (modarray)
976 {
977 size = sizeof(*ret) * (modarraylenA( modarray ) + 1);
978 if ((ret = malloc( size )))
979 {
980 LDAPModA **p = modarray;
981 LDAPModW **q = ret;
982
983 while (*p) *q++ = modAtoW( *p++ );
984 *q = NULL;
985 }
986 }
987 return ret;
988 }
989
990 static inline void bvarrayfreeW( struct WLDAP32_berval **bv )
991 {
992 struct WLDAP32_berval **p = bv;
993 while (*p) free( *p++ );
994 free( bv );
995 }
996
997 static inline void strarrayfreeW( WCHAR **strarray )
998 {
999 if (strarray)
1000 {
1001 WCHAR **p = strarray;
1002 while (*p) free( *p++ );
1003 free( strarray );
1004 }
1005 }
1006
1007 static inline void modfreeW( LDAPModW *mod )
1008 {
1009 if (mod->mod_op & LDAP_MOD_BVALUES)
1010 bvarrayfreeW( mod->mod_vals.modv_bvals );
1011 else
1012 strarrayfreeW( mod->mod_vals.modv_strvals );
1013 free( mod );
1014 }
1015
1016 static inline void modarrayfreeW( LDAPModW **modarray )
1017 {
1018 if (modarray)
1019 {
1020 LDAPModW **p = modarray;
1021 while (*p) modfreeW( *p++ );
1022 free( modarray );
1023 }
1024 }
1025
1026 static inline DWORD controlarraylenA( LDAPControlA **controlarray )
1027 {
1028 LDAPControlA **p = controlarray;
1029 while (*p) p++;
1030 return p - controlarray;
1031 }
1032
1033 static inline LDAPControlW *controlAtoW( const LDAPControlA *control )
1034 {
1035 LDAPControlW *ret;
1036 DWORD len = control->ldctl_value.bv_len;
1037 char *val = NULL;
1038
1039 if (control->ldctl_value.bv_val)
1040 {
1041 if (!(val = malloc( len ))) return NULL;
1042 memcpy( val, control->ldctl_value.bv_val, len );
1043 }
1044
1045 if (!(ret = malloc( sizeof(*ret) )))
1046 {
1047 free( val );
1048 return NULL;
1049 }
1050
1051 ret->ldctl_oid = strAtoW( control->ldctl_oid );
1052 ret->ldctl_value.bv_len = len;
1053 ret->ldctl_value.bv_val = val;
1054 ret->ldctl_iscritical = control->ldctl_iscritical;
1055
1056 return ret;
1057 }
1058
1059 static inline LDAPControlW **controlarrayAtoW( LDAPControlA **controlarray )
1060 {
1061 LDAPControlW **ret = NULL;
1062 DWORD size;
1063
1064 if (controlarray)
1065 {
1066 size = sizeof(*ret) * (controlarraylenA( controlarray ) + 1);
1067 if ((ret = malloc( size )))
1068 {
1069 LDAPControlA **p = controlarray;
1070 LDAPControlW **q = ret;
1071
1072 while (*p) *q++ = controlAtoW( *p++ );
1073 *q = NULL;
1074 }
1075 }
1076 return ret;
1077 }
1078
1079 static inline void controlfreeW( LDAPControlW *control )
1080 {
1081 if (control)
1082 {
1083 free( control->ldctl_oid );
1084 free( control->ldctl_value.bv_val );
1085 free( control );
1086 }
1087 }
1088
1089 static inline void controlarrayfreeW( LDAPControlW **controlarray )
1090 {
1091 if (controlarray)
1092 {
1093 LDAPControlW **p = controlarray;
1094 while (*p) controlfreeW( *p++ );
1095 free( controlarray );
1096 }
1097 }
1098
1099 static inline DWORD controlarraylenW( LDAPControlW **controlarray )
1100 {
1101 LDAPControlW **p = controlarray;
1102 while (*p) p++;
1103 return p - controlarray;
1104 }
1105
1106 static inline LDAPControlA *controlWtoA( const LDAPControlW *control )
1107 {
1108 LDAPControlA *ret;
1109 DWORD len = control->ldctl_value.bv_len;
1110 char *val = NULL;
1111
1112 if (control->ldctl_value.bv_val)
1113 {
1114 if (!(val = malloc( len ))) return NULL;
1115 memcpy( val, control->ldctl_value.bv_val, len );
1116 }
1117
1118 if (!(ret = malloc( sizeof(*ret) )))
1119 {
1120 free( val );
1121 return NULL;
1122 }
1123
1124 ret->ldctl_oid = strWtoA( control->ldctl_oid );
1125 ret->ldctl_value.bv_len = len;
1126 ret->ldctl_value.bv_val = val;
1127 ret->ldctl_iscritical = control->ldctl_iscritical;
1128
1129 return ret;
1130 }
1131
1132 static inline void strarrayfreeA( char **strarray )
1133 {
1134 if (strarray)
1135 {
1136 char **p = strarray;
1137 while (*p) free( *p++ );
1138 free( strarray );
1139 }
1140 }
1141
1142 static inline void controlfreeA( LDAPControlA *control )
1143 {
1144 if (control)
1145 {
1146 free( control->ldctl_oid );
1147 free( control->ldctl_value.bv_val );
1148 free( control );
1149 }
1150 }
1151
1152 static inline void controlarrayfreeA( LDAPControlA **controlarray )
1153 {
1154 if (controlarray)
1155 {
1156 LDAPControlA **p = controlarray;
1157 while (*p) controlfreeA( *p++ );
1158 free( controlarray );
1159 }
1160 }
1161
1162 static inline LDAPControl *controlWtoU( const LDAPControlW *control )
1163 {
1164 LDAPControl *ret;
1165 DWORD len = control->ldctl_value.bv_len;
1166 char *val = NULL;
1167
1168 if (control->ldctl_value.bv_val)
1169 {
1170 if (!(val = malloc( len ))) return NULL;
1171 memcpy( val, control->ldctl_value.bv_val, len );
1172 }
1173
1174 if (!(ret = malloc( sizeof(*ret) )))
1175 {
1176 free( val );
1177 return NULL;
1178 }
1179
1180 ret->ldctl_oid = strWtoU( control->ldctl_oid );
1181 ret->ldctl_value.bv_len = len;
1182 ret->ldctl_value.bv_val = val;
1183 ret->ldctl_iscritical = control->ldctl_iscritical;
1184
1185 return ret;
1186 }
1187
1188 static inline LDAPControl **controlarrayWtoU( LDAPControlW **controlarray )
1189 {
1190 LDAPControl **ret = NULL;
1191 DWORD size;
1192
1193 if (controlarray)
1194 {
1195 size = sizeof(*ret) * (controlarraylenW( controlarray ) + 1);
1196 if ((ret = malloc( size )))
1197 {
1198 LDAPControlW **p = controlarray;
1199 LDAPControl **q = ret;
1200
1201 while (*p) *q++ = controlWtoU( *p++ );
1202 *q = NULL;
1203 }
1204 }
1205 return ret;
1206 }
1207
1208 static inline void controlfreeU( LDAPControl *control )
1209 {
1210 if (control)
1211 {
1212 free( control->ldctl_oid );
1213 free( control->ldctl_value.bv_val );
1214 free( control );
1215 }
1216 }
1217
1218 static inline void controlarrayfreeU( LDAPControl **controlarray )
1219 {
1220 if (controlarray)
1221 {
1222 LDAPControl **p = controlarray;
1223 while (*p) controlfreeU( *p++ );
1224 free( controlarray );
1225 }
1226 }
1227
1228 static inline DWORD controlarraylenU( LDAPControl **controlarray )
1229 {
1230 LDAPControl **p = controlarray;
1231 while (*p) p++;
1232 return p - controlarray;
1233 }
1234
1235 static inline LDAPControlW *controldupW( LDAPControlW *control )
1236 {
1237 LDAPControlW *ret;
1238 DWORD len = control->ldctl_value.bv_len;
1239 char *val = NULL;
1240
1241 if (control->ldctl_value.bv_val)
1242 {
1243 if (!(val = malloc( len ))) return NULL;
1244 memcpy( val, control->ldctl_value.bv_val, len );
1245 }
1246
1247 if (!(ret = malloc( sizeof(*ret) )))
1248 {
1249 free( val );
1250 return NULL;
1251 }
1252
1253 ret->ldctl_oid = wcsdup( control->ldctl_oid );
1254 ret->ldctl_value.bv_len = len;
1255 ret->ldctl_value.bv_val = val;
1256 ret->ldctl_iscritical = control->ldctl_iscritical;
1257
1258 return ret;
1259 }
1260
1261 static inline LDAPControlW **controlarraydupW( LDAPControlW **controlarray )
1262 {
1263 LDAPControlW **ret = NULL;
1264 DWORD size;
1265
1266 if (controlarray)
1267 {
1268 size = sizeof(*ret) * (controlarraylenW( controlarray ) + 1);
1269 if ((ret = malloc( size )))
1270 {
1271 LDAPControlW **p = controlarray, **q = ret;
1272
1273 while (*p) *q++ = controldupW( *p++ );
1274 *q = NULL;
1275 }
1276 }
1277 return ret;
1278 }
1279
1280 static inline LDAPControlA **controlarrayWtoA( LDAPControlW **controlarray )
1281 {
1282 LDAPControlA **ret = NULL;
1283 DWORD size;
1284
1285 if (controlarray)
1286 {
1287 size = sizeof(*ret) * (controlarraylenW( controlarray ) + 1);
1288 if ((ret = malloc( size )))
1289 {
1290 LDAPControlW **p = controlarray;
1291 LDAPControlA **q = ret;
1292
1293 while (*p) *q++ = controlWtoA( *p++ );
1294 *q = NULL;
1295 }
1296 }
1297 return ret;
1298 }
1299
1300 static inline WCHAR *strUtoW( const char *str )
1301 {
1302 WCHAR *ret = NULL;
1303 if (str)
1304 {
1305 DWORD len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 );
1306 if ((ret = malloc( len * sizeof(WCHAR) ))) MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len );
1307 }
1308 return ret;
1309 }
1310
1311 static inline DWORD strarraylenU( char **strarray )
1312 {
1313 char **p = strarray;
1314 while (*p) p++;
1315 return p - strarray;
1316 }
1317
1318 static inline WCHAR **strarrayUtoW( char **strarray )
1319 {
1320 WCHAR **ret = NULL;
1321 DWORD size;
1322
1323 if (strarray)
1324 {
1325 size = sizeof(*ret) * (strarraylenU( strarray ) + 1);
1326 if ((ret = malloc( size )))
1327 {
1328 char **p = strarray;
1329 WCHAR **q = ret;
1330
1331 while (*p) *q++ = strUtoW( *p++ );
1332 *q = NULL;
1333 }
1334 }
1335 return ret;
1336 }
1337
1338 static inline char **strarrayUtoU( char **strarray )
1339 {
1340 char **ret = NULL;
1341 DWORD size;
1342
1343 if (strarray)
1344 {
1345 size = sizeof(*ret) * (strarraylenU( strarray ) + 1);
1346 if ((ret = malloc( size )))
1347 {
1348 char **p = strarray, **q = ret;
1349
1350 while (*p) *q++ = strdup( *p++ );
1351 *q = NULL;
1352 }
1353 }
1354 return ret;
1355 }
1356
1357 static inline LDAPControlW *controlUtoW( const LDAPControl *control )
1358 {
1359 LDAPControlW *ret;
1360 DWORD len = control->ldctl_value.bv_len;
1361 char *val = NULL;
1362
1363 if (control->ldctl_value.bv_val)
1364 {
1365 if (!(val = malloc( len ))) return NULL;
1366 memcpy( val, control->ldctl_value.bv_val, len );
1367 }
1368
1369 if (!(ret = malloc( sizeof(*ret) )))
1370 {
1371 free( val );
1372 return NULL;
1373 }
1374
1375 ret->ldctl_oid = strUtoW( control->ldctl_oid );
1376 ret->ldctl_value.bv_len = len;
1377 ret->ldctl_value.bv_val = val;
1378 ret->ldctl_iscritical = control->ldctl_iscritical;
1379
1380 return ret;
1381 }
1382
1383 static inline LDAPControlW **controlarrayUtoW( LDAPControl **controlarray )
1384 {
1385 LDAPControlW **ret = NULL;
1386 DWORD size;
1387
1388 if (controlarray)
1389 {
1390 size = sizeof(*ret) * (controlarraylenU( controlarray ) + 1);
1391 if ((ret = malloc( size )))
1392 {
1393 LDAPControl **p = controlarray;
1394 LDAPControlW **q = ret;
1395
1396 while (*p) *q++ = controlUtoW( *p++ );
1397 *q = NULL;
1398 }
1399 }
1400 return ret;
1401 }
1402
1403 static inline DWORD sortkeyarraylenA( LDAPSortKeyA **sortkeyarray )
1404 {
1405 LDAPSortKeyA **p = sortkeyarray;
1406 while (*p) p++;
1407 return p - sortkeyarray;
1408 }
1409
1410 static inline LDAPSortKeyW *sortkeyAtoW( const LDAPSortKeyA *sortkey )
1411 {
1412 LDAPSortKeyW *ret;
1413
1414 if ((ret = malloc( sizeof(*ret) )))
1415 {
1416 ret->sk_attrtype = strAtoW( sortkey->sk_attrtype );
1417 ret->sk_matchruleoid = strAtoW( sortkey->sk_matchruleoid );
1418 ret->sk_reverseorder = sortkey->sk_reverseorder;
1419 }
1420 return ret;
1421 }
1422
1423 static inline LDAPSortKeyW **sortkeyarrayAtoW( LDAPSortKeyA **sortkeyarray )
1424 {
1425 LDAPSortKeyW **ret = NULL;
1426 DWORD size;
1427
1428 if (sortkeyarray)
1429 {
1430 size = sizeof(*ret) * (sortkeyarraylenA( sortkeyarray ) + 1);
1431 if ((ret = malloc( size )))
1432 {
1433 LDAPSortKeyA **p = sortkeyarray;
1434 LDAPSortKeyW **q = ret;
1435
1436 while (*p) *q++ = sortkeyAtoW( *p++ );
1437 *q = NULL;
1438 }
1439 }
1440 return ret;
1441 }
1442
1443 static inline void sortkeyfreeW( LDAPSortKeyW *sortkey )
1444 {
1445 if (sortkey)
1446 {
1447 free( sortkey->sk_attrtype );
1448 free( sortkey->sk_matchruleoid );
1449 free( sortkey );
1450 }
1451 }
1452
1453 static inline void sortkeyarrayfreeW( LDAPSortKeyW **sortkeyarray )
1454 {
1455 if (sortkeyarray)
1456 {
1457 LDAPSortKeyW **p = sortkeyarray;
1458 while (*p) sortkeyfreeW( *p++ );
1459 free( sortkeyarray );
1460 }
1461 }
1462
1463 static inline DWORD sortkeyarraylenW( LDAPSortKeyW **sortkeyarray )
1464 {
1465 LDAPSortKeyW **p = sortkeyarray;
1466 while (*p) p++;
1467 return p - sortkeyarray;
1468 }
1469
1470 static inline LDAPSortKey *sortkeyWtoU( const LDAPSortKeyW *sortkey )
1471 {
1472 LDAPSortKey *ret;
1473
1474 if ((ret = malloc( sizeof(*ret) )))
1475 {
1476 ret->attributeType = strWtoU( sortkey->sk_attrtype );
1477 ret->orderingRule = strWtoU( sortkey->sk_matchruleoid );
1478 ret->reverseOrder = sortkey->sk_reverseorder;
1479 }
1480 return ret;
1481 }
1482
1483 static inline LDAPSortKey **sortkeyarrayWtoU( LDAPSortKeyW **sortkeyarray )
1484 {
1485 LDAPSortKey **ret = NULL;
1486 DWORD size;
1487
1488 if (sortkeyarray)
1489 {
1490 size = sizeof(*ret) * (sortkeyarraylenW( sortkeyarray ) + 1);
1491 if ((ret = malloc( size )))
1492 {
1493 LDAPSortKeyW **p = sortkeyarray;
1494 LDAPSortKey **q = ret;
1495
1496 while (*p) *q++ = sortkeyWtoU( *p++ );
1497 *q = NULL;
1498 }
1499 }
1500 return ret;
1501 }
1502
1503 static inline void sortkeyfreeU( LDAPSortKey *sortkey )
1504 {
1505 if (sortkey)
1506 {
1507 free( sortkey->attributeType );
1508 free( sortkey->orderingRule );
1509 free( sortkey );
1510 }
1511 }
1512
1513 static inline void sortkeyarrayfreeU( LDAPSortKey **sortkeyarray )
1514 {
1515 if (sortkeyarray)
1516 {
1517 LDAPSortKey **p = sortkeyarray;
1518 while (*p) sortkeyfreeU( *p++ );
1519 free( sortkeyarray );
1520 }
1521 }
1522
1523 static inline LDAPVLVInfo *vlvinfoWtoU( const WLDAP32_LDAPVLVInfo *info )
1524 {
1525 LDAPVLVInfo *ret;
1526
1527 if ((ret = malloc( sizeof(*ret) )))
1528 {
1529 ret->ldvlv_version = info->ldvlv_version;
1530 ret->ldvlv_before_count = info->ldvlv_before_count;
1531 ret->ldvlv_after_count = info->ldvlv_after_count;
1532 ret->ldvlv_offset = info->ldvlv_offset;
1533 ret->ldvlv_count = info->ldvlv_count;
1534 if (!(ret->ldvlv_attrvalue = bervalWtoU( info->ldvlv_attrvalue )))
1535 {
1536 free( ret );
1537 return NULL;
1538 }
1539 if (!(ret->ldvlv_context = bervalWtoU( info->ldvlv_context )))
1540 {
1541 free( ret->ldvlv_attrvalue );
1542 free( ret );
1543 return NULL;
1544 }
1545 ret->ldvlv_extradata = info->ldvlv_extradata;
1546 }
1547 return ret;
1548 }
1549
1550 static inline void vlvinfofreeU( LDAPVLVInfo *info )
1551 {
1552 free( info->ldvlv_attrvalue );
1553 free( info->ldvlv_context );
1554 free( info );
1555 }
Windows API implementation