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