dlls/wldap32/wldap32.h

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