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