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 #pragma once
22
23 #include "wine/heap.h"
24 #include "wine/unicode.h"
25
26 extern HINSTANCE hwldap32 DECLSPEC_HIDDEN;
27
28 ULONG map_error( int ) DECLSPEC_HIDDEN;
29
30 /* A set of helper functions to convert LDAP data structures
31 * to and from ansi (A), wide character (W) and utf8 (U) encodings.
32 */
33
strdupU(const char * src)34 static inline char *strdupU( const char *src )
35 {
36 char *dst;
37 if (!src) return NULL;
38 if ((dst = heap_alloc( (strlen( src ) + 1) * sizeof(char) ))) strcpy( dst, src );
39 return dst;
40 }
41
strdupW(const WCHAR * src)42 static inline WCHAR *strdupW( const WCHAR *src )
43 {
44 WCHAR *dst;
45 if (!src) return NULL;
46 if ((dst = heap_alloc( (strlenW( src ) + 1) * sizeof(WCHAR) ))) strcpyW( dst, src );
47 return dst;
48 }
49
strAtoW(LPCSTR str)50 static inline LPWSTR strAtoW( LPCSTR str )
51 {
52 LPWSTR ret = NULL;
53 if (str)
54 {
55 DWORD len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
56 if ((ret = heap_alloc( len * sizeof(WCHAR) )))
57 MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
58 }
59 return ret;
60 }
61
strWtoA(LPCWSTR str)62 static inline LPSTR strWtoA( LPCWSTR str )
63 {
64 LPSTR ret = NULL;
65 if (str)
66 {
67 DWORD len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
68 if ((ret = heap_alloc( len )))
69 WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
70 }
71 return ret;
72 }
73
strWtoU(LPCWSTR str)74 static inline char *strWtoU( LPCWSTR str )
75 {
76 LPSTR ret = NULL;
77 if (str)
78 {
79 DWORD len = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
80 if ((ret = heap_alloc( len )))
81 WideCharToMultiByte( CP_UTF8, 0, str, -1, ret, len, NULL, NULL );
82 }
83 return ret;
84 }
85
strUtoW(char * str)86 static inline LPWSTR strUtoW( char *str )
87 {
88 LPWSTR ret = NULL;
89 if (str)
90 {
91 DWORD len = MultiByteToWideChar( CP_UTF8, 0, str, -1, NULL, 0 );
92 if ((ret = heap_alloc( len * sizeof(WCHAR) )))
93 MultiByteToWideChar( CP_UTF8, 0, str, -1, ret, len );
94 }
95 return ret;
96 }
97
strfreeA(LPSTR str)98 static inline void strfreeA( LPSTR str )
99 {
100 heap_free( str );
101 }
102
strfreeW(LPWSTR str)103 static inline void strfreeW( LPWSTR str )
104 {
105 heap_free( str );
106 }
107
strfreeU(char * str)108 static inline void strfreeU( char *str )
109 {
110 heap_free( str );
111 }
112
strarraylenA(LPSTR * strarray)113 static inline DWORD strarraylenA( LPSTR *strarray )
114 {
115 LPSTR *p = strarray;
116 while (*p) p++;
117 return p - strarray;
118 }
119
strarraylenW(LPWSTR * strarray)120 static inline DWORD strarraylenW( LPWSTR *strarray )
121 {
122 LPWSTR *p = strarray;
123 while (*p) p++;
124 return p - strarray;
125 }
126
strarraylenU(char ** strarray)127 static inline DWORD strarraylenU( char **strarray )
128 {
129 char **p = strarray;
130 while (*p) p++;
131 return p - strarray;
132 }
133
strarrayAtoW(LPSTR * strarray)134 static inline LPWSTR *strarrayAtoW( LPSTR *strarray )
135 {
136 LPWSTR *strarrayW = NULL;
137 DWORD size;
138
139 if (strarray)
140 {
141 size = sizeof(WCHAR*) * (strarraylenA( strarray ) + 1);
142 if ((strarrayW = heap_alloc( size )))
143 {
144 LPSTR *p = strarray;
145 LPWSTR *q = strarrayW;
146
147 while (*p) *q++ = strAtoW( *p++ );
148 *q = NULL;
149 }
150 }
151 return strarrayW;
152 }
153
strarrayWtoA(LPWSTR * strarray)154 static inline LPSTR *strarrayWtoA( LPWSTR *strarray )
155 {
156 LPSTR *strarrayA = NULL;
157 DWORD size;
158
159 if (strarray)
160 {
161 size = sizeof(LPSTR) * (strarraylenW( strarray ) + 1);
162 if ((strarrayA = heap_alloc( size )))
163 {
164 LPWSTR *p = strarray;
165 LPSTR *q = strarrayA;
166
167 while (*p) *q++ = strWtoA( *p++ );
168 *q = NULL;
169 }
170 }
171 return strarrayA;
172 }
173
strarrayWtoU(LPWSTR * strarray)174 static inline char **strarrayWtoU( LPWSTR *strarray )
175 {
176 char **strarrayU = NULL;
177 DWORD size;
178
179 if (strarray)
180 {
181 size = sizeof(char*) * (strarraylenW( strarray ) + 1);
182 if ((strarrayU = heap_alloc( size )))
183 {
184 LPWSTR *p = strarray;
185 char **q = strarrayU;
186
187 while (*p) *q++ = strWtoU( *p++ );
188 *q = NULL;
189 }
190 }
191 return strarrayU;
192 }
193
strarrayUtoW(char ** strarray)194 static inline LPWSTR *strarrayUtoW( char **strarray )
195 {
196 LPWSTR *strarrayW = NULL;
197 DWORD size;
198
199 if (strarray)
200 {
201 size = sizeof(WCHAR*) * (strarraylenU( strarray ) + 1);
202 if ((strarrayW = heap_alloc( size )))
203 {
204 char **p = strarray;
205 LPWSTR *q = strarrayW;
206
207 while (*p) *q++ = strUtoW( *p++ );
208 *q = NULL;
209 }
210 }
211 return strarrayW;
212 }
213
strarrayfreeA(LPSTR * strarray)214 static inline void strarrayfreeA( LPSTR *strarray )
215 {
216 if (strarray)
217 {
218 LPSTR *p = strarray;
219 while (*p) strfreeA( *p++ );
220 heap_free( strarray );
221 }
222 }
223
strarrayfreeW(LPWSTR * strarray)224 static inline void strarrayfreeW( LPWSTR *strarray )
225 {
226 if (strarray)
227 {
228 LPWSTR *p = strarray;
229 while (*p) strfreeW( *p++ );
230 heap_free( strarray );
231 }
232 }
233
strarrayfreeU(char ** strarray)234 static inline void strarrayfreeU( char **strarray )
235 {
236 if (strarray)
237 {
238 char **p = strarray;
239 while (*p) strfreeU( *p++ );
240 heap_free( strarray );
241 }
242 }
243
244 #ifdef HAVE_LDAP
245
bvdup(struct berval * bv)246 static inline struct berval *bvdup( struct berval *bv )
247 {
248 struct berval *berval;
249 DWORD size = sizeof(struct berval) + bv->bv_len;
250
251 if ((berval = heap_alloc( size )))
252 {
253 char *val = (char *)berval + sizeof(struct berval);
254
255 berval->bv_len = bv->bv_len;
256 berval->bv_val = val;
257 memcpy( val, bv->bv_val, bv->bv_len );
258 }
259 return berval;
260 }
261
bvarraylen(struct berval ** bv)262 static inline DWORD bvarraylen( struct berval **bv )
263 {
264 struct berval **p = bv;
265 while (*p) p++;
266 return p - bv;
267 }
268
bvarraydup(struct berval ** bv)269 static inline struct berval **bvarraydup( struct berval **bv )
270 {
271 struct berval **berval = NULL;
272 DWORD size;
273
274 if (bv)
275 {
276 size = sizeof(struct berval *) * (bvarraylen( bv ) + 1);
277 if ((berval = heap_alloc( size )))
278 {
279 struct berval **p = bv;
280 struct berval **q = berval;
281
282 while (*p) *q++ = bvdup( *p++ );
283 *q = NULL;
284 }
285 }
286 return berval;
287 }
288
bvarrayfree(struct berval ** bv)289 static inline void bvarrayfree( struct berval **bv )
290 {
291 struct berval **p = bv;
292 while (*p) heap_free( *p++ );
293 heap_free( bv );
294 }
295
modAtoW(LDAPModA * mod)296 static inline LDAPModW *modAtoW( LDAPModA *mod )
297 {
298 LDAPModW *modW;
299
300 if ((modW = heap_alloc( sizeof(LDAPModW) )))
301 {
302 modW->mod_op = mod->mod_op;
303 modW->mod_type = strAtoW( mod->mod_type );
304
305 if (mod->mod_op & LDAP_MOD_BVALUES)
306 modW->mod_vals.modv_bvals = bvarraydup( mod->mod_vals.modv_bvals );
307 else
308 modW->mod_vals.modv_strvals = strarrayAtoW( mod->mod_vals.modv_strvals );
309 }
310 return modW;
311 }
312
modWtoU(LDAPModW * mod)313 static inline LDAPMod *modWtoU( LDAPModW *mod )
314 {
315 LDAPMod *modU;
316
317 if ((modU = heap_alloc( sizeof(LDAPMod) )))
318 {
319 modU->mod_op = mod->mod_op;
320 modU->mod_type = strWtoU( mod->mod_type );
321
322 if (mod->mod_op & LDAP_MOD_BVALUES)
323 modU->mod_vals.modv_bvals = bvarraydup( mod->mod_vals.modv_bvals );
324 else
325 modU->mod_vals.modv_strvals = strarrayWtoU( mod->mod_vals.modv_strvals );
326 }
327 return modU;
328 }
329
modfreeW(LDAPModW * mod)330 static inline void modfreeW( LDAPModW *mod )
331 {
332 if (mod->mod_op & LDAP_MOD_BVALUES)
333 bvarrayfree( mod->mod_vals.modv_bvals );
334 else
335 strarrayfreeW( mod->mod_vals.modv_strvals );
336 heap_free( mod );
337 }
338
modfreeU(LDAPMod * mod)339 static inline void modfreeU( LDAPMod *mod )
340 {
341 if (mod->mod_op & LDAP_MOD_BVALUES)
342 bvarrayfree( mod->mod_vals.modv_bvals );
343 else
344 strarrayfreeU( mod->mod_vals.modv_strvals );
345 heap_free( mod );
346 }
347
modarraylenA(LDAPModA ** modarray)348 static inline DWORD modarraylenA( LDAPModA **modarray )
349 {
350 LDAPModA **p = modarray;
351 while (*p) p++;
352 return p - modarray;
353 }
354
modarraylenW(LDAPModW ** modarray)355 static inline DWORD modarraylenW( LDAPModW **modarray )
356 {
357 LDAPModW **p = modarray;
358 while (*p) p++;
359 return p - modarray;
360 }
361
modarrayAtoW(LDAPModA ** modarray)362 static inline LDAPModW **modarrayAtoW( LDAPModA **modarray )
363 {
364 LDAPModW **modarrayW = NULL;
365 DWORD size;
366
367 if (modarray)
368 {
369 size = sizeof(LDAPModW*) * (modarraylenA( modarray ) + 1);
370 if ((modarrayW = heap_alloc( size )))
371 {
372 LDAPModA **p = modarray;
373 LDAPModW **q = modarrayW;
374
375 while (*p) *q++ = modAtoW( *p++ );
376 *q = NULL;
377 }
378 }
379 return modarrayW;
380 }
381
modarrayWtoU(LDAPModW ** modarray)382 static inline LDAPMod **modarrayWtoU( LDAPModW **modarray )
383 {
384 LDAPMod **modarrayU = NULL;
385 DWORD size;
386
387 if (modarray)
388 {
389 size = sizeof(LDAPMod*) * (modarraylenW( modarray ) + 1);
390 if ((modarrayU = heap_alloc( size )))
391 {
392 LDAPModW **p = modarray;
393 LDAPMod **q = modarrayU;
394
395 while (*p) *q++ = modWtoU( *p++ );
396 *q = NULL;
397 }
398 }
399 return modarrayU;
400 }
401
modarrayfreeW(LDAPModW ** modarray)402 static inline void modarrayfreeW( LDAPModW **modarray )
403 {
404 if (modarray)
405 {
406 LDAPModW **p = modarray;
407 while (*p) modfreeW( *p++ );
408 heap_free( modarray );
409 }
410 }
411
modarrayfreeU(LDAPMod ** modarray)412 static inline void modarrayfreeU( LDAPMod **modarray )
413 {
414 if (modarray)
415 {
416 LDAPMod **p = modarray;
417 while (*p) modfreeU( *p++ );
418 heap_free( modarray );
419 }
420 }
421
controlAtoW(LDAPControlA * control)422 static inline LDAPControlW *controlAtoW( LDAPControlA *control )
423 {
424 LDAPControlW *controlW;
425 DWORD len = control->ldctl_value.bv_len;
426 char *val = NULL;
427
428 if (control->ldctl_value.bv_val)
429 {
430 if (!(val = heap_alloc( len ))) return NULL;
431 memcpy( val, control->ldctl_value.bv_val, len );
432 }
433
434 if (!(controlW = heap_alloc( sizeof(LDAPControlW) )))
435 {
436 heap_free( val );
437 return NULL;
438 }
439
440 controlW->ldctl_oid = strAtoW( control->ldctl_oid );
441 controlW->ldctl_value.bv_len = len;
442 controlW->ldctl_value.bv_val = val;
443 controlW->ldctl_iscritical = control->ldctl_iscritical;
444
445 return controlW;
446 }
447
controlWtoA(LDAPControlW * control)448 static inline LDAPControlA *controlWtoA( LDAPControlW *control )
449 {
450 LDAPControlA *controlA;
451 DWORD len = control->ldctl_value.bv_len;
452 char *val = NULL;
453
454 if (control->ldctl_value.bv_val)
455 {
456 if (!(val = heap_alloc( len ))) return NULL;
457 memcpy( val, control->ldctl_value.bv_val, len );
458 }
459
460 if (!(controlA = heap_alloc( sizeof(LDAPControlA) )))
461 {
462 heap_free( val );
463 return NULL;
464 }
465
466 controlA->ldctl_oid = strWtoA( control->ldctl_oid );
467 controlA->ldctl_value.bv_len = len;
468 controlA->ldctl_value.bv_val = val;
469 controlA->ldctl_iscritical = control->ldctl_iscritical;
470
471 return controlA;
472 }
473
controlWtoU(LDAPControlW * control)474 static inline LDAPControl *controlWtoU( LDAPControlW *control )
475 {
476 LDAPControl *controlU;
477 DWORD len = control->ldctl_value.bv_len;
478 char *val = NULL;
479
480 if (control->ldctl_value.bv_val)
481 {
482 if (!(val = heap_alloc( len ))) return NULL;
483 memcpy( val, control->ldctl_value.bv_val, len );
484 }
485
486 if (!(controlU = heap_alloc( sizeof(LDAPControl) )))
487 {
488 heap_free( val );
489 return NULL;
490 }
491
492 controlU->ldctl_oid = strWtoU( control->ldctl_oid );
493 controlU->ldctl_value.bv_len = len;
494 controlU->ldctl_value.bv_val = val;
495 controlU->ldctl_iscritical = control->ldctl_iscritical;
496
497 return controlU;
498 }
499
controlUtoW(LDAPControl * control)500 static inline LDAPControlW *controlUtoW( LDAPControl *control )
501 {
502 LDAPControlW *controlW;
503 DWORD len = control->ldctl_value.bv_len;
504 char *val = NULL;
505
506 if (control->ldctl_value.bv_val)
507 {
508 if (!(val = heap_alloc( len ))) return NULL;
509 memcpy( val, control->ldctl_value.bv_val, len );
510 }
511
512 if (!(controlW = heap_alloc( sizeof(LDAPControlW) )))
513 {
514 heap_free( val );
515 return NULL;
516 }
517
518 controlW->ldctl_oid = strUtoW( control->ldctl_oid );
519 controlW->ldctl_value.bv_len = len;
520 controlW->ldctl_value.bv_val = val;
521 controlW->ldctl_iscritical = control->ldctl_iscritical;
522
523 return controlW;
524 }
525
controlfreeA(LDAPControlA * control)526 static inline void controlfreeA( LDAPControlA *control )
527 {
528 if (control)
529 {
530 strfreeA( control->ldctl_oid );
531 heap_free( control->ldctl_value.bv_val );
532 heap_free( control );
533 }
534 }
535
controlfreeW(LDAPControlW * control)536 static inline void controlfreeW( LDAPControlW *control )
537 {
538 if (control)
539 {
540 strfreeW( control->ldctl_oid );
541 heap_free( control->ldctl_value.bv_val );
542 heap_free( control );
543 }
544 }
545
controlfreeU(LDAPControl * control)546 static inline void controlfreeU( LDAPControl *control )
547 {
548 if (control)
549 {
550 strfreeU( control->ldctl_oid );
551 heap_free( control->ldctl_value.bv_val );
552 heap_free( control );
553 }
554 }
555
controlarraylenA(LDAPControlA ** controlarray)556 static inline DWORD controlarraylenA( LDAPControlA **controlarray )
557 {
558 LDAPControlA **p = controlarray;
559 while (*p) p++;
560 return p - controlarray;
561 }
562
controlarraylenW(LDAPControlW ** controlarray)563 static inline DWORD controlarraylenW( LDAPControlW **controlarray )
564 {
565 LDAPControlW **p = controlarray;
566 while (*p) p++;
567 return p - controlarray;
568 }
569
controlarraylenU(LDAPControl ** controlarray)570 static inline DWORD controlarraylenU( LDAPControl **controlarray )
571 {
572 LDAPControl **p = controlarray;
573 while (*p) p++;
574 return p - controlarray;
575 }
576
controlarrayAtoW(LDAPControlA ** controlarray)577 static inline LDAPControlW **controlarrayAtoW( LDAPControlA **controlarray )
578 {
579 LDAPControlW **controlarrayW = NULL;
580 DWORD size;
581
582 if (controlarray)
583 {
584 size = sizeof(LDAPControlW*) * (controlarraylenA( controlarray ) + 1);
585 if ((controlarrayW = heap_alloc( size )))
586 {
587 LDAPControlA **p = controlarray;
588 LDAPControlW **q = controlarrayW;
589
590 while (*p) *q++ = controlAtoW( *p++ );
591 *q = NULL;
592 }
593 }
594 return controlarrayW;
595 }
596
controlarrayWtoA(LDAPControlW ** controlarray)597 static inline LDAPControlA **controlarrayWtoA( LDAPControlW **controlarray )
598 {
599 LDAPControlA **controlarrayA = NULL;
600 DWORD size;
601
602 if (controlarray)
603 {
604 size = sizeof(LDAPControl*) * (controlarraylenW( controlarray ) + 1);
605 if ((controlarrayA = heap_alloc( size )))
606 {
607 LDAPControlW **p = controlarray;
608 LDAPControlA **q = controlarrayA;
609
610 while (*p) *q++ = controlWtoA( *p++ );
611 *q = NULL;
612 }
613 }
614 return controlarrayA;
615 }
616
controlarrayWtoU(LDAPControlW ** controlarray)617 static inline LDAPControl **controlarrayWtoU( LDAPControlW **controlarray )
618 {
619 LDAPControl **controlarrayU = NULL;
620 DWORD size;
621
622 if (controlarray)
623 {
624 size = sizeof(LDAPControl*) * (controlarraylenW( controlarray ) + 1);
625 if ((controlarrayU = heap_alloc( size )))
626 {
627 LDAPControlW **p = controlarray;
628 LDAPControl **q = controlarrayU;
629
630 while (*p) *q++ = controlWtoU( *p++ );
631 *q = NULL;
632 }
633 }
634 return controlarrayU;
635 }
636
controlarrayUtoW(LDAPControl ** controlarray)637 static inline LDAPControlW **controlarrayUtoW( LDAPControl **controlarray )
638 {
639 LDAPControlW **controlarrayW = NULL;
640 DWORD size;
641
642 if (controlarray)
643 {
644 size = sizeof(LDAPControlW*) * (controlarraylenU( controlarray ) + 1);
645 if ((controlarrayW = heap_alloc( size )))
646 {
647 LDAPControl **p = controlarray;
648 LDAPControlW **q = controlarrayW;
649
650 while (*p) *q++ = controlUtoW( *p++ );
651 *q = NULL;
652 }
653 }
654 return controlarrayW;
655 }
656
controlarrayfreeA(LDAPControlA ** controlarray)657 static inline void controlarrayfreeA( LDAPControlA **controlarray )
658 {
659 if (controlarray)
660 {
661 LDAPControlA **p = controlarray;
662 while (*p) controlfreeA( *p++ );
663 heap_free( controlarray );
664 }
665 }
666
controlarrayfreeW(LDAPControlW ** controlarray)667 static inline void controlarrayfreeW( LDAPControlW **controlarray )
668 {
669 if (controlarray)
670 {
671 LDAPControlW **p = controlarray;
672 while (*p) controlfreeW( *p++ );
673 heap_free( controlarray );
674 }
675 }
676
controlarrayfreeU(LDAPControl ** controlarray)677 static inline void controlarrayfreeU( LDAPControl **controlarray )
678 {
679 if (controlarray)
680 {
681 LDAPControl **p = controlarray;
682 while (*p) controlfreeU( *p++ );
683 heap_free( controlarray );
684 }
685 }
686
sortkeyAtoW(LDAPSortKeyA * sortkey)687 static inline LDAPSortKeyW *sortkeyAtoW( LDAPSortKeyA *sortkey )
688 {
689 LDAPSortKeyW *sortkeyW;
690
691 if ((sortkeyW = heap_alloc( sizeof(LDAPSortKeyW) )))
692 {
693 sortkeyW->sk_attrtype = strAtoW( sortkey->sk_attrtype );
694 sortkeyW->sk_matchruleoid = strAtoW( sortkey->sk_matchruleoid );
695 sortkeyW->sk_reverseorder = sortkey->sk_reverseorder;
696 }
697 return sortkeyW;
698 }
699
sortkeyWtoA(LDAPSortKeyW * sortkey)700 static inline LDAPSortKeyA *sortkeyWtoA( LDAPSortKeyW *sortkey )
701 {
702 LDAPSortKeyA *sortkeyA;
703
704 if ((sortkeyA = heap_alloc( sizeof(LDAPSortKeyA) )))
705 {
706 sortkeyA->sk_attrtype = strWtoA( sortkey->sk_attrtype );
707 sortkeyA->sk_matchruleoid = strWtoA( sortkey->sk_matchruleoid );
708 sortkeyA->sk_reverseorder = sortkey->sk_reverseorder;
709 }
710 return sortkeyA;
711 }
712
sortkeyWtoU(LDAPSortKeyW * sortkey)713 static inline LDAPSortKey *sortkeyWtoU( LDAPSortKeyW *sortkey )
714 {
715 LDAPSortKey *sortkeyU;
716
717 if ((sortkeyU = heap_alloc( sizeof(LDAPSortKey) )))
718 {
719 sortkeyU->attributeType = strWtoU( sortkey->sk_attrtype );
720 sortkeyU->orderingRule = strWtoU( sortkey->sk_matchruleoid );
721 sortkeyU->reverseOrder = sortkey->sk_reverseorder;
722 }
723 return sortkeyU;
724 }
725
sortkeyfreeA(LDAPSortKeyA * sortkey)726 static inline void sortkeyfreeA( LDAPSortKeyA *sortkey )
727 {
728 if (sortkey)
729 {
730 strfreeA( sortkey->sk_attrtype );
731 strfreeA( sortkey->sk_matchruleoid );
732 heap_free( sortkey );
733 }
734 }
735
sortkeyfreeW(LDAPSortKeyW * sortkey)736 static inline void sortkeyfreeW( LDAPSortKeyW *sortkey )
737 {
738 if (sortkey)
739 {
740 strfreeW( sortkey->sk_attrtype );
741 strfreeW( sortkey->sk_matchruleoid );
742 heap_free( sortkey );
743 }
744 }
745
sortkeyfreeU(LDAPSortKey * sortkey)746 static inline void sortkeyfreeU( LDAPSortKey *sortkey )
747 {
748 if (sortkey)
749 {
750 strfreeU( sortkey->attributeType );
751 strfreeU( sortkey->orderingRule );
752 heap_free( sortkey );
753 }
754 }
755
sortkeyarraylenA(LDAPSortKeyA ** sortkeyarray)756 static inline DWORD sortkeyarraylenA( LDAPSortKeyA **sortkeyarray )
757 {
758 LDAPSortKeyA **p = sortkeyarray;
759 while (*p) p++;
760 return p - sortkeyarray;
761 }
762
sortkeyarraylenW(LDAPSortKeyW ** sortkeyarray)763 static inline DWORD sortkeyarraylenW( LDAPSortKeyW **sortkeyarray )
764 {
765 LDAPSortKeyW **p = sortkeyarray;
766 while (*p) p++;
767 return p - sortkeyarray;
768 }
769
sortkeyarrayAtoW(LDAPSortKeyA ** sortkeyarray)770 static inline LDAPSortKeyW **sortkeyarrayAtoW( LDAPSortKeyA **sortkeyarray )
771 {
772 LDAPSortKeyW **sortkeyarrayW = NULL;
773 DWORD size;
774
775 if (sortkeyarray)
776 {
777 size = sizeof(LDAPSortKeyW*) * (sortkeyarraylenA( sortkeyarray ) + 1);
778 if ((sortkeyarrayW = heap_alloc( size )))
779 {
780 LDAPSortKeyA **p = sortkeyarray;
781 LDAPSortKeyW **q = sortkeyarrayW;
782
783 while (*p) *q++ = sortkeyAtoW( *p++ );
784 *q = NULL;
785 }
786 }
787 return sortkeyarrayW;
788 }
789
sortkeyarrayWtoU(LDAPSortKeyW ** sortkeyarray)790 static inline LDAPSortKey **sortkeyarrayWtoU( LDAPSortKeyW **sortkeyarray )
791 {
792 LDAPSortKey **sortkeyarrayU = NULL;
793 DWORD size;
794
795 if (sortkeyarray)
796 {
797 size = sizeof(LDAPSortKey*) * (sortkeyarraylenW( sortkeyarray ) + 1);
798 if ((sortkeyarrayU = heap_alloc( size )))
799 {
800 LDAPSortKeyW **p = sortkeyarray;
801 LDAPSortKey **q = sortkeyarrayU;
802
803 while (*p) *q++ = sortkeyWtoU( *p++ );
804 *q = NULL;
805 }
806 }
807 return sortkeyarrayU;
808 }
809
sortkeyarrayfreeW(LDAPSortKeyW ** sortkeyarray)810 static inline void sortkeyarrayfreeW( LDAPSortKeyW **sortkeyarray )
811 {
812 if (sortkeyarray)
813 {
814 LDAPSortKeyW **p = sortkeyarray;
815 while (*p) sortkeyfreeW( *p++ );
816 heap_free( sortkeyarray );
817 }
818 }
819
sortkeyarrayfreeU(LDAPSortKey ** sortkeyarray)820 static inline void sortkeyarrayfreeU( LDAPSortKey **sortkeyarray )
821 {
822 if (sortkeyarray)
823 {
824 LDAPSortKey **p = sortkeyarray;
825 while (*p) sortkeyfreeU( *p++ );
826 heap_free( sortkeyarray );
827 }
828 }
829 #endif /* HAVE_LDAP */
830