dlls/secur32/thunks.c

   1 /* Copyright (C) 2004 Juan Lang
   2  *
   3  * This file implements thunks between wide char and multibyte functions for
   4  * SSPs that only provide one or the other.
   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 <stdarg.h>
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winnls.h"
  25 #include "winternl.h"
  26 #include "sspi.h"
  27
  28 #include "wine/debug.h"
  29 #include "secur32_priv.h"
  30 #include "thunks.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(secur32);
  33
  34 SECURITY_STATUS SEC_ENTRY thunk_AcquireCredentialsHandleA(
  35  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialsUse,
  36  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
  37  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
  38 {
  39     SECURITY_STATUS ret;
  40
  41     TRACE("%s %s %ld %p %p %p %p %p %p\n", debugstr_a(pszPrincipal),
  42      debugstr_a(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
  43      pvGetKeyArgument, phCredential, ptsExpiry);
  44     if (pszPackage)
  45     {
  46         UNICODE_STRING principal, package;
  47
  48         RtlCreateUnicodeStringFromAsciiz(&principal, pszPrincipal);
  49         RtlCreateUnicodeStringFromAsciiz(&package, pszPackage);
  50         ret = AcquireCredentialsHandleW(principal.Buffer, package.Buffer,
  51          fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn, pvGetKeyArgument,
  52          phCredential, ptsExpiry);
  53         RtlFreeUnicodeString(&principal);
  54         RtlFreeUnicodeString(&package);
  55     }
  56     else
  57         ret = SEC_E_SECPKG_NOT_FOUND;
  58     return ret;
  59 }
  60
  61 static char *strdupWA( const WCHAR *str )
  62 {
  63     char *ret = NULL;
  64     if (str)
  65     {
  66         int len = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
  67         if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, len )))
  68             WideCharToMultiByte( CP_ACP, 0, str, -1, ret, len, NULL, NULL );
  69     }
  70     return ret;
  71 }
  72
  73 SECURITY_STATUS SEC_ENTRY thunk_AcquireCredentialsHandleW(
  74  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse,
  75  PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn,
  76  PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
  77 {
  78     SECURITY_STATUS ret;
  79
  80     TRACE("%s %s %ld %p %p %p %p %p %p\n", debugstr_w(pszPrincipal),
  81      debugstr_w(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn,
  82      pvGetKeyArgument, phCredential, ptsExpiry);
  83     if (pszPackage)
  84     {
  85         char *principal, *package;
  86
  87         principal = strdupWA(pszPrincipal);
  88         package = strdupWA(pszPackage);
  89         ret = AcquireCredentialsHandleA(principal, package, fCredentialsUse,
  90          pvLogonID, pAuthData, pGetKeyFn, pvGetKeyArgument, phCredential, ptsExpiry);
  91         RtlFreeHeap(GetProcessHeap(), 0, principal);
  92         RtlFreeHeap(GetProcessHeap(), 0, package);
  93     }
  94     else
  95         ret = SEC_E_SECPKG_NOT_FOUND;
  96     return ret;
  97 }
  98
  99 /* thunking is pretty dicey for these--the output type depends on ulAttribute,
 100  * so we have to know about every type the caller does
 101  */
 102 SECURITY_STATUS SEC_ENTRY thunk_QueryCredentialsAttributesA(
 103  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
 104 {
 105     SECURITY_STATUS ret;
 106
 107     TRACE("%p %ld %p\n", phCredential, ulAttribute, pBuffer);
 108     if (phCredential)
 109     {
 110         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 111         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 112
 113         if (package && package->provider)
 114         {
 115             if (package->provider->fnTableW.QueryCredentialsAttributesW)
 116             {
 117                 ret = package->provider->fnTableW.QueryCredentialsAttributesW( cred, ulAttribute, pBuffer);
 118                 if (ret == SEC_E_OK)
 119                 {
 120                     switch (ulAttribute)
 121                     {
 122                         case SECPKG_CRED_ATTR_NAMES:
 123                         {
 124                             PSecPkgCredentials_NamesW names = (PSecPkgCredentials_NamesW)pBuffer;
 125                             SEC_WCHAR *oldUser = names->sUserName;
 126
 127                             if (oldUser)
 128                             {
 129                                 names->sUserName = (WCHAR *)strdupWA(oldUser);
 130                                 package->provider->fnTableW.FreeContextBuffer(oldUser);
 131                             }
 132                             break;
 133                         }
 134                         default:
 135                             WARN("attribute type %ld unknown\n", ulAttribute);
 136                             ret = SEC_E_INTERNAL_ERROR;
 137                     }
 138                 }
 139             }
 140             else
 141                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 142         }
 143         else
 144             ret = SEC_E_INVALID_HANDLE;
 145     }
 146     else
 147         ret = SEC_E_INVALID_HANDLE;
 148     return ret;
 149 }
 150
 151 static WCHAR *strdupAW( const char *str )
 152 {
 153     WCHAR *ret = NULL;
 154     if (str)
 155     {
 156         int len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
 157         if ((ret = RtlAllocateHeap( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
 158             MultiByteToWideChar( CP_ACP, 0, str, -1, ret, len );
 159     }
 160     return ret;
 161 }
 162
 163 SECURITY_STATUS SEC_ENTRY thunk_QueryCredentialsAttributesW(
 164  PCredHandle phCredential, ULONG ulAttribute, void *pBuffer)
 165 {
 166     SECURITY_STATUS ret;
 167
 168     TRACE("%p %ld %p\n", phCredential, ulAttribute, pBuffer);
 169     if (phCredential)
 170     {
 171         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 172         PCredHandle cred = (PCredHandle)phCredential->dwLower;
 173
 174         if (package && package->provider)
 175         {
 176             if (package->provider->fnTableA.QueryCredentialsAttributesA)
 177             {
 178                 ret = package->provider->fnTableA.QueryCredentialsAttributesA(cred, ulAttribute, pBuffer);
 179                 if (ret == SEC_E_OK)
 180                 {
 181                     switch (ulAttribute)
 182                     {
 183                         case SECPKG_CRED_ATTR_NAMES:
 184                         {
 185                             PSecPkgCredentials_NamesA names = (PSecPkgCredentials_NamesA)pBuffer;
 186                             SEC_CHAR *oldUser = names->sUserName;
 187
 188                             if (oldUser)
 189                             {
 190                                 names->sUserName = (char *)strdupAW(oldUser);
 191                                 package->provider->fnTableA.FreeContextBuffer(oldUser);
 192                             }
 193                             break;
 194                         }
 195                         default:
 196                             WARN("attribute type %ld unknown\n", ulAttribute);
 197                             ret = SEC_E_INTERNAL_ERROR;
 198                     }
 199                 }
 200             }
 201             else
 202                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 203         }
 204         else
 205             ret = SEC_E_INVALID_HANDLE;
 206     }
 207     else
 208         ret = SEC_E_INVALID_HANDLE;
 209     return ret;
 210 }
 211
 212 SECURITY_STATUS SEC_ENTRY thunk_InitializeSecurityContextA(
 213  PCredHandle phCredential, PCtxtHandle phContext,
 214  SEC_CHAR *pszTargetName, ULONG fContextReq,
 215  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
 216  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
 217  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 218 {
 219     SECURITY_STATUS ret;
 220
 221     TRACE("%p %p %s %ld %ld %ld %p %ld %p %p %p %p\n", phCredential, phContext,
 222      debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 223      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 224     if (phCredential)
 225     {
 226         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 227
 228         if (package && package->provider)
 229         {
 230             if (package->provider->fnTableW.InitializeSecurityContextW)
 231             {
 232                 UNICODE_STRING target;
 233
 234                 RtlCreateUnicodeStringFromAsciiz(&target, pszTargetName);
 235                 ret = package->provider->fnTableW.InitializeSecurityContextW(
 236                  phCredential, phContext, target.Buffer, fContextReq, Reserved1,
 237                  TargetDataRep, pInput, Reserved2, phNewContext, pOutput,
 238                  pfContextAttr, ptsExpiry);
 239                 RtlFreeUnicodeString(&target);
 240             }
 241             else
 242                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 243         }
 244         else
 245             ret = SEC_E_INVALID_HANDLE;
 246     }
 247     else
 248         ret = SEC_E_INVALID_HANDLE;
 249     return ret;
 250 }
 251
 252 SECURITY_STATUS SEC_ENTRY thunk_InitializeSecurityContextW(
 253  PCredHandle phCredential, PCtxtHandle phContext,
 254  SEC_WCHAR *pszTargetName, ULONG fContextReq,
 255  ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput,
 256  ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput,
 257  ULONG *pfContextAttr, PTimeStamp ptsExpiry)
 258 {
 259     SECURITY_STATUS ret;
 260
 261     TRACE("%p %p %s %ld %ld %ld %p %ld %p %p %p %p\n", phCredential, phContext,
 262      debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput,
 263      Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry);
 264     if (phCredential)
 265     {
 266         SecurePackage *package = (SecurePackage *)phCredential->dwUpper;
 267
 268         if (package && package->provider)
 269         {
 270             if (package->provider->fnTableA.InitializeSecurityContextA)
 271             {
 272                 char *target = strdupWA(pszTargetName);
 273
 274                 ret = package->provider->fnTableA.InitializeSecurityContextA(
 275                  phCredential, phContext, target, fContextReq, Reserved1,
 276                  TargetDataRep, pInput, Reserved2, phNewContext, pOutput,
 277                  pfContextAttr, ptsExpiry);
 278                 RtlFreeHeap(GetProcessHeap(), 0, target);
 279             }
 280             else
 281                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 282         }
 283         else
 284             ret = SEC_E_INVALID_HANDLE;
 285     }
 286     else
 287         ret = SEC_E_INVALID_HANDLE;
 288     return ret;
 289 }
 290
 291 SECURITY_STATUS SEC_ENTRY thunk_AddCredentialsA(PCredHandle hCredentials,
 292  SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse,
 293  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
 294  PTimeStamp ptsExpiry)
 295 {
 296     SECURITY_STATUS ret;
 297
 298     TRACE("%p %s %s %ld %p %p %p %p\n", hCredentials, debugstr_a(pszPrincipal),
 299      debugstr_a(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
 300      pvGetKeyArgument, ptsExpiry);
 301     if (hCredentials)
 302     {
 303         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
 304         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
 305
 306         if (package && package->provider)
 307         {
 308             if (package->provider->fnTableW.AddCredentialsW)
 309             {
 310                 UNICODE_STRING szPrincipal, szPackage;
 311
 312                 RtlCreateUnicodeStringFromAsciiz(&szPrincipal, pszPrincipal);
 313                 RtlCreateUnicodeStringFromAsciiz(&szPackage, pszPackage);
 314                 ret = package->provider->fnTableW.AddCredentialsW(
 315                  cred, szPrincipal.Buffer, szPackage.Buffer, fCredentialUse,
 316                  pAuthData, pGetKeyFn, pvGetKeyArgument, ptsExpiry);
 317                 RtlFreeUnicodeString(&szPrincipal);
 318                 RtlFreeUnicodeString(&szPackage);
 319             }
 320             else
 321                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 322         }
 323         else
 324             ret = SEC_E_INVALID_HANDLE;
 325     }
 326     else
 327         ret = SEC_E_INVALID_HANDLE;
 328     return ret;
 329 }
 330
 331 SECURITY_STATUS SEC_ENTRY thunk_AddCredentialsW(PCredHandle hCredentials,
 332  SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse,
 333  void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument,
 334  PTimeStamp ptsExpiry)
 335 {
 336     SECURITY_STATUS ret;
 337
 338     TRACE("%p %s %s %ld %p %p %p %p\n", hCredentials, debugstr_w(pszPrincipal),
 339      debugstr_w(pszPackage), fCredentialUse, pAuthData, pGetKeyFn,
 340      pvGetKeyArgument, ptsExpiry);
 341     if (hCredentials)
 342     {
 343         SecurePackage *package = (SecurePackage *)hCredentials->dwUpper;
 344         PCredHandle cred = (PCtxtHandle)hCredentials->dwLower;
 345
 346         if (package && package->provider)
 347         {
 348             if (package->provider->fnTableA.AddCredentialsA)
 349             {
 350                 char *szPrincipal = strdupWA(pszPrincipal);
 351                 char *szPackage = strdupWA(pszPackage);
 352
 353                 ret = package->provider->fnTableA.AddCredentialsA(
 354                  cred, szPrincipal, szPackage, fCredentialUse, pAuthData,
 355                  pGetKeyFn, pvGetKeyArgument, ptsExpiry);
 356                 RtlFreeHeap(GetProcessHeap(), 0, szPrincipal);
 357                 RtlFreeHeap(GetProcessHeap(), 0, szPackage);
 358             }
 359             else
 360                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 361         }
 362         else
 363             ret = SEC_E_INVALID_HANDLE;
 364     }
 365     else
 366         ret = SEC_E_INVALID_HANDLE;
 367     return ret;
 368 }
 369
 370 static PSecPkgInfoA _copyPackageInfoFlatWToA(const SecPkgInfoW *infoW)
 371 {
 372     PSecPkgInfoA ret;
 373
 374     if (infoW)
 375     {
 376         size_t bytesNeeded = sizeof(SecPkgInfoA);
 377         int nameLen = 0, commentLen = 0;
 378
 379         if (infoW->Name)
 380         {
 381             nameLen = WideCharToMultiByte(CP_ACP, 0, infoW->Name, -1,
 382              NULL, 0, NULL, NULL);
 383             bytesNeeded += nameLen;
 384         }
 385         if (infoW->Comment)
 386         {
 387             commentLen = WideCharToMultiByte(CP_ACP, 0, infoW->Comment, -1,
 388              NULL, 0, NULL, NULL);
 389             bytesNeeded += commentLen;
 390         }
 391         if ((ret = RtlAllocateHeap(GetProcessHeap(), 0, bytesNeeded)))
 392         {
 393             char *nextString = (char *)ret + sizeof(SecPkgInfoA);
 394
 395             memcpy(ret, infoW, sizeof(SecPkgInfoA));
 396             if (infoW->Name)
 397             {
 398                 ret->Name = nextString;
 399                 WideCharToMultiByte(CP_ACP, 0, infoW->Name, -1, nextString, nameLen, NULL, NULL);
 400                 nextString += nameLen;
 401             }
 402             else
 403                 ret->Name = NULL;
 404             if (infoW->Comment)
 405             {
 406                 ret->Comment = nextString;
 407                 WideCharToMultiByte(CP_ACP, 0, infoW->Comment, -1, nextString, nameLen, NULL, NULL);
 408             }
 409             else
 410                 ret->Comment = NULL;
 411         }
 412     }
 413     else
 414         ret = NULL;
 415     return ret;
 416 }
 417
 418 static SECURITY_STATUS thunk_ContextAttributesWToA(SecurePackage *package,
 419  ULONG ulAttribute, void *pBuffer)
 420 {
 421     SECURITY_STATUS ret = SEC_E_OK;
 422
 423     if (package && pBuffer)
 424     {
 425         switch (ulAttribute)
 426         {
 427             case SECPKG_ATTR_NAMES:
 428             {
 429                 PSecPkgContext_NamesW names = (PSecPkgContext_NamesW)pBuffer;
 430                 SEC_WCHAR *oldUser = names->sUserName;
 431
 432                 if (oldUser)
 433                 {
 434                     names->sUserName = (WCHAR *)strdupWA(oldUser);
 435                     package->provider->fnTableW.FreeContextBuffer(oldUser);
 436                 }
 437                 break;
 438             }
 439             case SECPKG_ATTR_AUTHORITY:
 440             {
 441                 PSecPkgContext_AuthorityW names = (PSecPkgContext_AuthorityW)pBuffer;
 442                 SEC_WCHAR *oldAuth = names->sAuthorityName;
 443
 444                 if (oldAuth)
 445                 {
 446                     names->sAuthorityName = (WCHAR *)strdupWA(oldAuth);
 447                     package->provider->fnTableW.FreeContextBuffer(oldAuth);
 448                 }
 449                 break;
 450             }
 451             case SECPKG_ATTR_KEY_INFO:
 452             {
 453                 PSecPkgContext_KeyInfoW info = (PSecPkgContext_KeyInfoW)pBuffer;
 454                 SEC_WCHAR *oldSigAlgName = info->sSignatureAlgorithmName;
 455                 SEC_WCHAR *oldEncAlgName = info->sEncryptAlgorithmName;
 456
 457                 if (oldSigAlgName)
 458                 {
 459                     info->sSignatureAlgorithmName = (WCHAR *)strdupWA(oldSigAlgName);
 460                     package->provider->fnTableW.FreeContextBuffer(oldSigAlgName);
 461                 }
 462                 if (oldEncAlgName)
 463                 {
 464                     info->sEncryptAlgorithmName = (WCHAR *)strdupWA(oldEncAlgName);
 465                     package->provider->fnTableW.FreeContextBuffer(oldEncAlgName);
 466                 }
 467                 break;
 468             }
 469             case SECPKG_ATTR_PACKAGE_INFO:
 470             {
 471                 PSecPkgContext_PackageInfoW info = (PSecPkgContext_PackageInfoW)pBuffer;
 472                 PSecPkgInfoW oldPkgInfo = info->PackageInfo;
 473
 474                 if (oldPkgInfo)
 475                 {
 476                     info->PackageInfo = (PSecPkgInfoW)
 477                      _copyPackageInfoFlatWToA(oldPkgInfo);
 478                     package->provider->fnTableW.FreeContextBuffer(oldPkgInfo);
 479                 }
 480                 break;
 481             }
 482             case SECPKG_ATTR_NEGOTIATION_INFO:
 483             {
 484                 PSecPkgContext_NegotiationInfoW info = (PSecPkgContext_NegotiationInfoW)pBuffer;
 485                 PSecPkgInfoW oldPkgInfo = info->PackageInfo;
 486
 487                 if (oldPkgInfo)
 488                 {
 489                     info->PackageInfo = (PSecPkgInfoW)
 490                      _copyPackageInfoFlatWToA(oldPkgInfo);
 491                     package->provider->fnTableW.FreeContextBuffer(oldPkgInfo);
 492                 }
 493                 break;
 494             }
 495             case SECPKG_ATTR_NATIVE_NAMES:
 496             {
 497                 PSecPkgContext_NativeNamesW names = (PSecPkgContext_NativeNamesW)pBuffer;
 498                 WCHAR *oldClient = names->sClientName;
 499                 WCHAR *oldServer = names->sServerName;
 500
 501                 if (oldClient)
 502                 {
 503                     names->sClientName = (WCHAR *)strdupWA(oldClient);
 504                     package->provider->fnTableW.FreeContextBuffer(oldClient);
 505                 }
 506                 if (oldServer)
 507                 {
 508                     names->sServerName = (WCHAR *)strdupWA(oldServer);
 509                     package->provider->fnTableW.FreeContextBuffer(oldServer);
 510                 }
 511                 break;
 512             }
 513             case SECPKG_ATTR_CREDENTIAL_NAME:
 514             {
 515                 PSecPkgContext_CredentialNameW name = (PSecPkgContext_CredentialNameW)pBuffer;
 516                 WCHAR *oldCred = name->sCredentialName;
 517
 518                 if (oldCred)
 519                 {
 520                     name->sCredentialName = (WCHAR *)strdupWA(oldCred);
 521                     package->provider->fnTableW.FreeContextBuffer(oldCred);
 522                 }
 523                 break;
 524             }
 525             /* no thunking needed: */
 526             case SECPKG_ATTR_ACCESS_TOKEN:
 527             case SECPKG_ATTR_DCE_INFO:
 528             case SECPKG_ATTR_FLAGS:
 529             case SECPKG_ATTR_LIFESPAN:
 530             case SECPKG_ATTR_PASSWORD_EXPIRY:
 531             case SECPKG_ATTR_SESSION_KEY:
 532             case SECPKG_ATTR_SIZES:
 533             case SECPKG_ATTR_STREAM_SIZES:
 534             case SECPKG_ATTR_TARGET_INFORMATION:
 535                 break;
 536             default:
 537                 WARN("attribute type %ld unknown\n", ulAttribute);
 538                 ret = SEC_E_INTERNAL_ERROR;
 539         }
 540     }
 541     else
 542         ret = SEC_E_INVALID_TOKEN;
 543     return ret;
 544 }
 545
 546 SECURITY_STATUS SEC_ENTRY thunk_QueryContextAttributesA(PCtxtHandle phContext,
 547  ULONG ulAttribute, void *pBuffer)
 548 {
 549     SECURITY_STATUS ret;
 550
 551     TRACE("%p %ld %p\n", phContext, ulAttribute, pBuffer);
 552     if (phContext)
 553     {
 554         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 555         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 556
 557         if (package && package->provider)
 558         {
 559             if (package->provider->fnTableW.QueryContextAttributesW)
 560             {
 561                 ret = package->provider->fnTableW.QueryContextAttributesW( ctxt, ulAttribute, pBuffer);
 562                 if (ret == SEC_E_OK)
 563                     ret = thunk_ContextAttributesWToA(package, ulAttribute, pBuffer);
 564             }
 565             else
 566                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 567         }
 568         else
 569             ret = SEC_E_INVALID_HANDLE;
 570     }
 571     else
 572         ret = SEC_E_INVALID_HANDLE;
 573     return ret;
 574 }
 575
 576 static PSecPkgInfoW _copyPackageInfoFlatAToW(const SecPkgInfoA *infoA)
 577 {
 578     PSecPkgInfoW ret;
 579
 580     if (infoA)
 581     {
 582         size_t bytesNeeded = sizeof(SecPkgInfoW);
 583         int nameLen = 0, commentLen = 0;
 584
 585         if (infoA->Name)
 586         {
 587             nameLen = MultiByteToWideChar(CP_ACP, 0, infoA->Name, -1, NULL, 0);
 588             bytesNeeded += nameLen * sizeof(WCHAR);
 589         }
 590         if (infoA->Comment)
 591         {
 592             commentLen = MultiByteToWideChar(CP_ACP, 0, infoA->Comment, -1, NULL, 0);
 593             bytesNeeded += commentLen * sizeof(WCHAR);
 594         }
 595         if ((ret = RtlAllocateHeap(GetProcessHeap(), 0, bytesNeeded)))
 596         {
 597             WCHAR *nextString = (WCHAR *)(char *)ret + sizeof(SecPkgInfoW);
 598
 599             memcpy(ret, infoA, sizeof(SecPkgInfoA));
 600             if (infoA->Name)
 601             {
 602                 ret->Name = nextString;
 603                 MultiByteToWideChar(CP_ACP, 0, infoA->Name, -1, nextString, nameLen);
 604                 nextString += nameLen;
 605             }
 606             else
 607                 ret->Name = NULL;
 608             if (infoA->Comment)
 609             {
 610                 ret->Comment = nextString;
 611                 MultiByteToWideChar(CP_ACP, 0, infoA->Comment, -1, nextString, commentLen);
 612             }
 613             else
 614                 ret->Comment = NULL;
 615         }
 616     }
 617     else
 618         ret = NULL;
 619     return ret;
 620 }
 621
 622 static SECURITY_STATUS thunk_ContextAttributesAToW(SecurePackage *package,
 623  ULONG ulAttribute, void *pBuffer)
 624 {
 625     SECURITY_STATUS ret = SEC_E_OK;
 626
 627     if (package && pBuffer)
 628     {
 629         switch (ulAttribute)
 630         {
 631             case SECPKG_ATTR_NAMES:
 632             {
 633                 PSecPkgContext_NamesA names = (PSecPkgContext_NamesA)pBuffer;
 634                 SEC_CHAR *oldUser = names->sUserName;
 635
 636                 if (oldUser)
 637                 {
 638                     names->sUserName = (char *)strdupAW(oldUser);
 639                     package->provider->fnTableW.FreeContextBuffer(oldUser);
 640                 }
 641                 break;
 642             }
 643             case SECPKG_ATTR_AUTHORITY:
 644             {
 645                 PSecPkgContext_AuthorityA names = (PSecPkgContext_AuthorityA)pBuffer;
 646                 SEC_CHAR *oldAuth = names->sAuthorityName;
 647
 648                 if (oldAuth)
 649                 {
 650                     names->sAuthorityName = (char *)strdupAW(oldAuth);
 651                     package->provider->fnTableW.FreeContextBuffer(oldAuth);
 652                 }
 653                 break;
 654             }
 655             case SECPKG_ATTR_KEY_INFO:
 656             {
 657                 PSecPkgContext_KeyInfoA info = (PSecPkgContext_KeyInfoA)pBuffer;
 658                 SEC_CHAR *oldSigAlgName = info->sSignatureAlgorithmName;
 659                 SEC_CHAR *oldEncAlgName = info->sEncryptAlgorithmName;
 660
 661                 if (oldSigAlgName)
 662                 {
 663                     info->sSignatureAlgorithmName = (char *)strdupAW(oldSigAlgName);
 664                     package->provider->fnTableW.FreeContextBuffer(oldSigAlgName);
 665                 }
 666                 if (oldEncAlgName)
 667                 {
 668                     info->sEncryptAlgorithmName = (char *)strdupAW(oldEncAlgName);
 669                     package->provider->fnTableW.FreeContextBuffer(oldEncAlgName);
 670                 }
 671                 break;
 672             }
 673             case SECPKG_ATTR_PACKAGE_INFO:
 674             {
 675                 PSecPkgContext_PackageInfoA info = (PSecPkgContext_PackageInfoA)pBuffer;
 676                 PSecPkgInfoA oldPkgInfo = info->PackageInfo;
 677
 678                 if (oldPkgInfo)
 679                 {
 680                     info->PackageInfo = (PSecPkgInfoA)
 681                      _copyPackageInfoFlatAToW(oldPkgInfo);
 682                     package->provider->fnTableW.FreeContextBuffer(oldPkgInfo);
 683                 }
 684                 break;
 685             }
 686             case SECPKG_ATTR_NEGOTIATION_INFO:
 687             {
 688                 PSecPkgContext_NegotiationInfoA info = (PSecPkgContext_NegotiationInfoA)pBuffer;
 689                 PSecPkgInfoA oldPkgInfo = info->PackageInfo;
 690
 691                 if (oldPkgInfo)
 692                 {
 693                     info->PackageInfo = (PSecPkgInfoA)
 694                      _copyPackageInfoFlatAToW(oldPkgInfo);
 695                     package->provider->fnTableW.FreeContextBuffer(oldPkgInfo);
 696                 }
 697                 break;
 698             }
 699             case SECPKG_ATTR_NATIVE_NAMES:
 700             {
 701                 PSecPkgContext_NativeNamesA names = (PSecPkgContext_NativeNamesA)pBuffer;
 702                 char *oldClient = names->sClientName;
 703                 char *oldServer = names->sServerName;
 704
 705                 if (oldClient)
 706                 {
 707                     names->sClientName = (char *)strdupAW(oldClient);
 708                     package->provider->fnTableW.FreeContextBuffer(oldClient);
 709                 }
 710                 if (oldServer)
 711                 {
 712                     names->sServerName = (char *)strdupAW(oldServer);
 713                     package->provider->fnTableW.FreeContextBuffer(oldServer);
 714                 }
 715                 break;
 716             }
 717             case SECPKG_ATTR_CREDENTIAL_NAME:
 718             {
 719                 PSecPkgContext_CredentialNameA name = (PSecPkgContext_CredentialNameA)pBuffer;
 720                 char *oldCred = name->sCredentialName;
 721
 722                 if (oldCred)
 723                 {
 724                     name->sCredentialName = (char *)strdupAW(oldCred);
 725                     package->provider->fnTableW.FreeContextBuffer(oldCred);
 726                 }
 727                 break;
 728             }
 729             /* no thunking needed: */
 730             case SECPKG_ATTR_ACCESS_TOKEN:
 731             case SECPKG_ATTR_DCE_INFO:
 732             case SECPKG_ATTR_FLAGS:
 733             case SECPKG_ATTR_LIFESPAN:
 734             case SECPKG_ATTR_PASSWORD_EXPIRY:
 735             case SECPKG_ATTR_SESSION_KEY:
 736             case SECPKG_ATTR_SIZES:
 737             case SECPKG_ATTR_STREAM_SIZES:
 738             case SECPKG_ATTR_TARGET_INFORMATION:
 739                 break;
 740             default:
 741                 WARN("attribute type %ld unknown\n", ulAttribute);
 742                 ret = SEC_E_INTERNAL_ERROR;
 743         }
 744     }
 745     else
 746         ret = SEC_E_INVALID_TOKEN;
 747     return ret;
 748 }
 749
 750 SECURITY_STATUS SEC_ENTRY thunk_QueryContextAttributesW(PCtxtHandle phContext,
 751  ULONG ulAttribute, void *pBuffer)
 752 {
 753     SECURITY_STATUS ret;
 754
 755     TRACE("%p %ld %p\n", phContext, ulAttribute, pBuffer);
 756     if (phContext)
 757     {
 758         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 759         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 760
 761         if (package && package->provider)
 762         {
 763             if (package->provider->fnTableA.QueryContextAttributesA)
 764             {
 765                 ret = package->provider->fnTableA.QueryContextAttributesA(ctxt, ulAttribute, pBuffer);
 766                 if (ret == SEC_E_OK)
 767                     ret = thunk_ContextAttributesAToW(package, ulAttribute, pBuffer);
 768             }
 769             else
 770                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 771         }
 772         else
 773             ret = SEC_E_INVALID_HANDLE;
 774     }
 775     else
 776         ret = SEC_E_INVALID_HANDLE;
 777     return ret;
 778 }
 779
 780 SECURITY_STATUS SEC_ENTRY thunk_SetContextAttributesA(PCtxtHandle phContext,
 781  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
 782 {
 783     SECURITY_STATUS ret;
 784
 785     TRACE("%p %ld %p %ld\n", phContext, ulAttribute, pBuffer, cbBuffer);
 786     if (phContext)
 787     {
 788         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 789         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 790
 791         if (package && package->provider && pBuffer && cbBuffer)
 792         {
 793             if (package->provider->fnTableW.SetContextAttributesW)
 794             {
 795                 /* TODO: gotta validate size too! */
 796                 ret = thunk_ContextAttributesWToA(package, ulAttribute, pBuffer);
 797                 if (ret == SEC_E_OK)
 798                     ret = package->provider->fnTableW.SetContextAttributesW(ctxt, ulAttribute, pBuffer, cbBuffer);
 799             }
 800             else
 801                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 802         }
 803         else
 804             ret = SEC_E_INVALID_HANDLE;
 805     }
 806     else
 807         ret = SEC_E_INVALID_HANDLE;
 808     return ret;
 809 }
 810
 811 SECURITY_STATUS SEC_ENTRY thunk_SetContextAttributesW(PCtxtHandle phContext,
 812  ULONG ulAttribute, void *pBuffer, ULONG cbBuffer)
 813 {
 814     SECURITY_STATUS ret;
 815
 816     TRACE("%p %ld %p %ld\n", phContext, ulAttribute, pBuffer, cbBuffer);
 817     if (phContext)
 818     {
 819         SecurePackage *package = (SecurePackage *)phContext->dwUpper;
 820         PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower;
 821
 822         if (package && package->provider && pBuffer && cbBuffer)
 823         {
 824             if (package->provider->fnTableA.SetContextAttributesA)
 825             {
 826                 /* TODO: gotta validate size too! */
 827                 ret = thunk_ContextAttributesAToW(package, ulAttribute, pBuffer);
 828                 if (ret == SEC_E_OK)
 829                     ret = package->provider->fnTableA.SetContextAttributesA(ctxt, ulAttribute, pBuffer, cbBuffer);
 830             }
 831             else
 832                 ret = SEC_E_UNSUPPORTED_FUNCTION;
 833         }
 834         else
 835             ret = SEC_E_INVALID_HANDLE;
 836     }
 837     else
 838         ret = SEC_E_INVALID_HANDLE;
 839     return ret;
 840 }
 841
 842 SECURITY_STATUS SEC_ENTRY thunk_ImportSecurityContextA(
 843  SEC_CHAR *pszPackage, PSecBuffer pPackedContext, void *Token,
 844  PCtxtHandle phContext)
 845 {
 846     SECURITY_STATUS ret;
 847     UNICODE_STRING package;
 848
 849     TRACE("%s %p %p %p\n", debugstr_a(pszPackage), pPackedContext, Token, phContext);
 850     RtlCreateUnicodeStringFromAsciiz(&package, pszPackage);
 851     ret = ImportSecurityContextW(package.Buffer, pPackedContext, Token, phContext);
 852     RtlFreeUnicodeString(&package);
 853     return ret;
 854 }
 855
 856 SECURITY_STATUS SEC_ENTRY thunk_ImportSecurityContextW(
 857  SEC_WCHAR *pszPackage, PSecBuffer pPackedContext, void *Token,
 858  PCtxtHandle phContext)
 859 {
 860     SECURITY_STATUS ret;
 861     char *package = strdupWA(pszPackage);
 862
 863     TRACE("%s %p %p %p\n", debugstr_w(pszPackage), pPackedContext, Token, phContext);
 864     ret = ImportSecurityContextA(package, pPackedContext, Token, phContext);
 865     RtlFreeHeap(GetProcessHeap(), 0, package);
 866     return ret;
 867 }