| /* Copyright (C) 2004 Juan Lang |
| * |
| * This file implements thunks between wide char and multibyte functions for |
| * SSPs that only provide one or the other. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| #include <stdarg.h> |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winnls.h" |
| #include "winternl.h" |
| #include "sspi.h" |
| #include "secur32_priv.h" |
| #include "thunks.h" |
| |
| #include "wine/debug.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(secur32); |
| |
| SECURITY_STATUS SEC_ENTRY thunk_AcquireCredentialsHandleA( |
| SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialsUse, |
| PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, |
| PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_a(pszPrincipal), |
| debugstr_a(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn, |
| pvGetKeyArgument, phCredential, ptsExpiry); |
| if (pszPackage) |
| { |
| UNICODE_STRING principal, package; |
| |
| RtlCreateUnicodeStringFromAsciiz(&principal, pszPrincipal); |
| RtlCreateUnicodeStringFromAsciiz(&package, pszPackage); |
| ret = AcquireCredentialsHandleW(principal.Buffer, package.Buffer, |
| fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn, pvGetKeyArgument, |
| phCredential, ptsExpiry); |
| RtlFreeUnicodeString(&principal); |
| RtlFreeUnicodeString(&package); |
| } |
| else |
| ret = SEC_E_SECPKG_NOT_FOUND; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_AcquireCredentialsHandleW( |
| SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse, |
| PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, |
| PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%s %s %d %p %p %p %p %p %p\n", debugstr_w(pszPrincipal), |
| debugstr_w(pszPackage), fCredentialsUse, pvLogonID, pAuthData, pGetKeyFn, |
| pvGetKeyArgument, phCredential, ptsExpiry); |
| if (pszPackage) |
| { |
| PSTR principal, package; |
| |
| principal = SECUR32_AllocMultiByteFromWide(pszPrincipal); |
| package = SECUR32_AllocMultiByteFromWide(pszPackage); |
| ret = AcquireCredentialsHandleA(principal, package, fCredentialsUse, |
| pvLogonID, pAuthData, pGetKeyFn, pvGetKeyArgument, phCredential, |
| ptsExpiry); |
| HeapFree(GetProcessHeap(), 0, principal); |
| HeapFree(GetProcessHeap(), 0, package); |
| } |
| else |
| ret = SEC_E_SECPKG_NOT_FOUND; |
| return ret; |
| } |
| |
| /* thunking is pretty dicey for these--the output type depends on ulAttribute, |
| * so we have to know about every type the caller does |
| */ |
| SECURITY_STATUS SEC_ENTRY thunk_QueryCredentialsAttributesA( |
| PCredHandle phCredential, ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer); |
| if (phCredential) |
| { |
| SecurePackage *package = (SecurePackage *)phCredential->dwUpper; |
| PCredHandle cred = (PCredHandle)phCredential->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableW.QueryCredentialsAttributesW) |
| { |
| ret = package->provider->fnTableW.QueryCredentialsAttributesW( |
| cred, ulAttribute, pBuffer); |
| if (ret == SEC_E_OK) |
| { |
| switch (ulAttribute) |
| { |
| case SECPKG_CRED_ATTR_NAMES: |
| { |
| PSecPkgCredentials_NamesW names = |
| (PSecPkgCredentials_NamesW)pBuffer; |
| SEC_WCHAR *oldUser = names->sUserName; |
| |
| if (oldUser) |
| { |
| names->sUserName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldUser); |
| package->provider->fnTableW.FreeContextBuffer( |
| oldUser); |
| } |
| break; |
| } |
| default: |
| WARN("attribute type %d unknown\n", ulAttribute); |
| ret = SEC_E_INTERNAL_ERROR; |
| } |
| } |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_QueryCredentialsAttributesW( |
| PCredHandle phCredential, ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p\n", phCredential, ulAttribute, pBuffer); |
| if (phCredential) |
| { |
| SecurePackage *package = (SecurePackage *)phCredential->dwUpper; |
| PCredHandle cred = (PCredHandle)phCredential->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableA.QueryCredentialsAttributesA) |
| { |
| ret = package->provider->fnTableA.QueryCredentialsAttributesA( |
| cred, ulAttribute, pBuffer); |
| if (ret == SEC_E_OK) |
| { |
| switch (ulAttribute) |
| { |
| case SECPKG_CRED_ATTR_NAMES: |
| { |
| PSecPkgCredentials_NamesA names = |
| (PSecPkgCredentials_NamesA)pBuffer; |
| SEC_CHAR *oldUser = names->sUserName; |
| |
| if (oldUser) |
| { |
| names->sUserName = |
| (PSTR)SECUR32_AllocWideFromMultiByte(oldUser); |
| package->provider->fnTableA.FreeContextBuffer( |
| oldUser); |
| } |
| break; |
| } |
| default: |
| WARN("attribute type %d unknown\n", ulAttribute); |
| ret = SEC_E_INTERNAL_ERROR; |
| } |
| } |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_InitializeSecurityContextA( |
| PCredHandle phCredential, PCtxtHandle phContext, |
| SEC_CHAR *pszTargetName, ULONG fContextReq, |
| ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, |
| ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, |
| ULONG *pfContextAttr, PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext, |
| debugstr_a(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput, |
| Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry); |
| if (phCredential) |
| { |
| SecurePackage *package = (SecurePackage *)phCredential->dwUpper; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableW.InitializeSecurityContextW) |
| { |
| UNICODE_STRING target; |
| |
| RtlCreateUnicodeStringFromAsciiz(&target, pszTargetName); |
| ret = package->provider->fnTableW.InitializeSecurityContextW( |
| phCredential, phContext, target.Buffer, fContextReq, Reserved1, |
| TargetDataRep, pInput, Reserved2, phNewContext, pOutput, |
| pfContextAttr, ptsExpiry); |
| RtlFreeUnicodeString(&target); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_InitializeSecurityContextW( |
| PCredHandle phCredential, PCtxtHandle phContext, |
| SEC_WCHAR *pszTargetName, ULONG fContextReq, |
| ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, |
| ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, |
| ULONG *pfContextAttr, PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %p %s %d %d %d %p %d %p %p %p %p\n", phCredential, phContext, |
| debugstr_w(pszTargetName), fContextReq, Reserved1, TargetDataRep, pInput, |
| Reserved1, phNewContext, pOutput, pfContextAttr, ptsExpiry); |
| if (phCredential) |
| { |
| SecurePackage *package = (SecurePackage *)phCredential->dwUpper; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableA.InitializeSecurityContextA) |
| { |
| PSTR target = SECUR32_AllocMultiByteFromWide(pszTargetName); |
| |
| ret = package->provider->fnTableA.InitializeSecurityContextA( |
| phCredential, phContext, target, fContextReq, Reserved1, |
| TargetDataRep, pInput, Reserved2, phNewContext, pOutput, |
| pfContextAttr, ptsExpiry); |
| HeapFree(GetProcessHeap(), 0, target); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_AddCredentialsA(PCredHandle hCredentials, |
| SEC_CHAR *pszPrincipal, SEC_CHAR *pszPackage, ULONG fCredentialUse, |
| void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, |
| PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_a(pszPrincipal), |
| debugstr_a(pszPackage), fCredentialUse, pAuthData, pGetKeyFn, |
| pvGetKeyArgument, ptsExpiry); |
| if (hCredentials) |
| { |
| SecurePackage *package = (SecurePackage *)hCredentials->dwUpper; |
| PCredHandle cred = (PCtxtHandle)hCredentials->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableW.AddCredentialsW) |
| { |
| UNICODE_STRING szPrincipal, szPackage; |
| |
| RtlCreateUnicodeStringFromAsciiz(&szPrincipal, pszPrincipal); |
| RtlCreateUnicodeStringFromAsciiz(&szPackage, pszPackage); |
| ret = package->provider->fnTableW.AddCredentialsW( |
| cred, szPrincipal.Buffer, szPackage.Buffer, fCredentialUse, |
| pAuthData, pGetKeyFn, pvGetKeyArgument, ptsExpiry); |
| RtlFreeUnicodeString(&szPrincipal); |
| RtlFreeUnicodeString(&szPackage); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_AddCredentialsW(PCredHandle hCredentials, |
| SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialUse, |
| void *pAuthData, SEC_GET_KEY_FN pGetKeyFn, void *pvGetKeyArgument, |
| PTimeStamp ptsExpiry) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %s %s %d %p %p %p %p\n", hCredentials, debugstr_w(pszPrincipal), |
| debugstr_w(pszPackage), fCredentialUse, pAuthData, pGetKeyFn, |
| pvGetKeyArgument, ptsExpiry); |
| if (hCredentials) |
| { |
| SecurePackage *package = (SecurePackage *)hCredentials->dwUpper; |
| PCredHandle cred = (PCtxtHandle)hCredentials->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableA.AddCredentialsA) |
| { |
| PSTR szPrincipal = SECUR32_AllocMultiByteFromWide(pszPrincipal); |
| PSTR szPackage = SECUR32_AllocMultiByteFromWide(pszPackage); |
| |
| ret = package->provider->fnTableA.AddCredentialsA( |
| cred, szPrincipal, szPackage, fCredentialUse, pAuthData, |
| pGetKeyFn, pvGetKeyArgument, ptsExpiry); |
| HeapFree(GetProcessHeap(), 0, szPrincipal); |
| HeapFree(GetProcessHeap(), 0, szPackage); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| static PSecPkgInfoA _copyPackageInfoFlatWToA(const SecPkgInfoW *infoW) |
| { |
| PSecPkgInfoA ret; |
| |
| if (infoW) |
| { |
| size_t bytesNeeded = sizeof(SecPkgInfoA); |
| int nameLen = 0, commentLen = 0; |
| |
| if (infoW->Name) |
| { |
| nameLen = WideCharToMultiByte(CP_ACP, 0, infoW->Name, -1, |
| NULL, 0, NULL, NULL); |
| bytesNeeded += nameLen; |
| } |
| if (infoW->Comment) |
| { |
| commentLen = WideCharToMultiByte(CP_ACP, 0, infoW->Comment, -1, |
| NULL, 0, NULL, NULL); |
| bytesNeeded += commentLen; |
| } |
| ret = HeapAlloc(GetProcessHeap(), 0, bytesNeeded); |
| if (ret) |
| { |
| PSTR nextString = (PSTR)((PBYTE)ret + sizeof(SecPkgInfoA)); |
| |
| memcpy(ret, infoW, sizeof(SecPkgInfoA)); |
| if (infoW->Name) |
| { |
| ret->Name = nextString; |
| WideCharToMultiByte(CP_ACP, 0, infoW->Name, -1, nextString, |
| nameLen, NULL, NULL); |
| nextString += nameLen; |
| } |
| else |
| ret->Name = NULL; |
| if (infoW->Comment) |
| { |
| ret->Comment = nextString; |
| WideCharToMultiByte(CP_ACP, 0, infoW->Comment, -1, nextString, |
| nameLen, NULL, NULL); |
| } |
| else |
| ret->Comment = NULL; |
| } |
| } |
| else |
| ret = NULL; |
| return ret; |
| } |
| |
| static SECURITY_STATUS thunk_ContextAttributesWToA(SecurePackage *package, |
| ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret = SEC_E_OK; |
| |
| if (package && pBuffer) |
| { |
| switch (ulAttribute) |
| { |
| case SECPKG_ATTR_NAMES: |
| { |
| PSecPkgContext_NamesW names = (PSecPkgContext_NamesW)pBuffer; |
| SEC_WCHAR *oldUser = names->sUserName; |
| |
| if (oldUser) |
| { |
| names->sUserName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldUser); |
| package->provider->fnTableW.FreeContextBuffer(oldUser); |
| } |
| break; |
| } |
| case SECPKG_ATTR_AUTHORITY: |
| { |
| PSecPkgContext_AuthorityW names = |
| (PSecPkgContext_AuthorityW)pBuffer; |
| SEC_WCHAR *oldAuth = names->sAuthorityName; |
| |
| if (oldAuth) |
| { |
| names->sAuthorityName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldAuth); |
| package->provider->fnTableW.FreeContextBuffer(oldAuth); |
| } |
| break; |
| } |
| case SECPKG_ATTR_KEY_INFO: |
| { |
| PSecPkgContext_KeyInfoW info = (PSecPkgContext_KeyInfoW)pBuffer; |
| SEC_WCHAR *oldSigAlgName = info->sSignatureAlgorithmName; |
| SEC_WCHAR *oldEncAlgName = info->sEncryptAlgorithmName; |
| |
| if (oldSigAlgName) |
| { |
| info->sSignatureAlgorithmName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldSigAlgName); |
| package->provider->fnTableW.FreeContextBuffer( |
| oldSigAlgName); |
| } |
| if (oldEncAlgName) |
| { |
| info->sEncryptAlgorithmName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldEncAlgName); |
| package->provider->fnTableW.FreeContextBuffer( |
| oldEncAlgName); |
| } |
| break; |
| } |
| case SECPKG_ATTR_PACKAGE_INFO: |
| { |
| PSecPkgContext_PackageInfoW info = |
| (PSecPkgContext_PackageInfoW)pBuffer; |
| PSecPkgInfoW oldPkgInfo = info->PackageInfo; |
| |
| if (oldPkgInfo) |
| { |
| info->PackageInfo = (PSecPkgInfoW) |
| _copyPackageInfoFlatWToA(oldPkgInfo); |
| package->provider->fnTableW.FreeContextBuffer(oldPkgInfo); |
| } |
| break; |
| } |
| case SECPKG_ATTR_NEGOTIATION_INFO: |
| { |
| PSecPkgContext_NegotiationInfoW info = |
| (PSecPkgContext_NegotiationInfoW)pBuffer; |
| PSecPkgInfoW oldPkgInfo = info->PackageInfo; |
| |
| if (oldPkgInfo) |
| { |
| info->PackageInfo = (PSecPkgInfoW) |
| _copyPackageInfoFlatWToA(oldPkgInfo); |
| package->provider->fnTableW.FreeContextBuffer(oldPkgInfo); |
| } |
| break; |
| } |
| case SECPKG_ATTR_NATIVE_NAMES: |
| { |
| PSecPkgContext_NativeNamesW names = |
| (PSecPkgContext_NativeNamesW)pBuffer; |
| PWSTR oldClient = names->sClientName; |
| PWSTR oldServer = names->sServerName; |
| |
| if (oldClient) |
| { |
| names->sClientName = (PWSTR)SECUR32_AllocMultiByteFromWide( |
| oldClient); |
| package->provider->fnTableW.FreeContextBuffer(oldClient); |
| } |
| if (oldServer) |
| { |
| names->sServerName = (PWSTR)SECUR32_AllocMultiByteFromWide( |
| oldServer); |
| package->provider->fnTableW.FreeContextBuffer(oldServer); |
| } |
| break; |
| } |
| case SECPKG_ATTR_CREDENTIAL_NAME: |
| { |
| PSecPkgContext_CredentialNameW name = |
| (PSecPkgContext_CredentialNameW)pBuffer; |
| PWSTR oldCred = name->sCredentialName; |
| |
| if (oldCred) |
| { |
| name->sCredentialName = |
| (PWSTR)SECUR32_AllocMultiByteFromWide(oldCred); |
| package->provider->fnTableW.FreeContextBuffer(oldCred); |
| } |
| break; |
| } |
| /* no thunking needed: */ |
| case SECPKG_ATTR_ACCESS_TOKEN: |
| case SECPKG_ATTR_DCE_INFO: |
| case SECPKG_ATTR_FLAGS: |
| case SECPKG_ATTR_LIFESPAN: |
| case SECPKG_ATTR_PASSWORD_EXPIRY: |
| case SECPKG_ATTR_SESSION_KEY: |
| case SECPKG_ATTR_SIZES: |
| case SECPKG_ATTR_STREAM_SIZES: |
| case SECPKG_ATTR_TARGET_INFORMATION: |
| break; |
| default: |
| WARN("attribute type %d unknown\n", ulAttribute); |
| ret = SEC_E_INTERNAL_ERROR; |
| } |
| } |
| else |
| ret = SEC_E_INVALID_TOKEN; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_QueryContextAttributesA(PCtxtHandle phContext, |
| ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer); |
| if (phContext) |
| { |
| SecurePackage *package = (SecurePackage *)phContext->dwUpper; |
| PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableW.QueryContextAttributesW) |
| { |
| ret = package->provider->fnTableW.QueryContextAttributesW( |
| ctxt, ulAttribute, pBuffer); |
| if (ret == SEC_E_OK) |
| ret = thunk_ContextAttributesWToA(package, ulAttribute, |
| pBuffer); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| static PSecPkgInfoW _copyPackageInfoFlatAToW(const SecPkgInfoA *infoA) |
| { |
| PSecPkgInfoW ret; |
| |
| if (infoA) |
| { |
| size_t bytesNeeded = sizeof(SecPkgInfoW); |
| int nameLen = 0, commentLen = 0; |
| |
| if (infoA->Name) |
| { |
| nameLen = MultiByteToWideChar(CP_ACP, 0, infoA->Name, -1, |
| NULL, 0); |
| bytesNeeded += nameLen * sizeof(WCHAR); |
| } |
| if (infoA->Comment) |
| { |
| commentLen = MultiByteToWideChar(CP_ACP, 0, infoA->Comment, -1, |
| NULL, 0); |
| bytesNeeded += commentLen * sizeof(WCHAR); |
| } |
| ret = HeapAlloc(GetProcessHeap(), 0, bytesNeeded); |
| if (ret) |
| { |
| PWSTR nextString = (PWSTR)((PBYTE)ret + sizeof(SecPkgInfoW)); |
| |
| memcpy(ret, infoA, sizeof(SecPkgInfoA)); |
| if (infoA->Name) |
| { |
| ret->Name = nextString; |
| MultiByteToWideChar(CP_ACP, 0, infoA->Name, -1, nextString, |
| nameLen); |
| nextString += nameLen; |
| } |
| else |
| ret->Name = NULL; |
| if (infoA->Comment) |
| { |
| ret->Comment = nextString; |
| MultiByteToWideChar(CP_ACP, 0, infoA->Comment, -1, nextString, |
| commentLen); |
| } |
| else |
| ret->Comment = NULL; |
| } |
| } |
| else |
| ret = NULL; |
| return ret; |
| } |
| |
| static SECURITY_STATUS thunk_ContextAttributesAToW(SecurePackage *package, |
| ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret = SEC_E_OK; |
| |
| if (package && pBuffer) |
| { |
| switch (ulAttribute) |
| { |
| case SECPKG_ATTR_NAMES: |
| { |
| PSecPkgContext_NamesA names = (PSecPkgContext_NamesA)pBuffer; |
| SEC_CHAR *oldUser = names->sUserName; |
| |
| if (oldUser) |
| { |
| names->sUserName = |
| (PSTR)SECUR32_AllocWideFromMultiByte(oldUser); |
| package->provider->fnTableW.FreeContextBuffer(oldUser); |
| } |
| break; |
| } |
| case SECPKG_ATTR_AUTHORITY: |
| { |
| PSecPkgContext_AuthorityA names = |
| (PSecPkgContext_AuthorityA)pBuffer; |
| SEC_CHAR *oldAuth = names->sAuthorityName; |
| |
| if (oldAuth) |
| { |
| names->sAuthorityName = |
| (PSTR)SECUR32_AllocWideFromMultiByte(oldAuth); |
| package->provider->fnTableW.FreeContextBuffer(oldAuth); |
| } |
| break; |
| } |
| case SECPKG_ATTR_KEY_INFO: |
| { |
| PSecPkgContext_KeyInfoA info = (PSecPkgContext_KeyInfoA)pBuffer; |
| SEC_CHAR *oldSigAlgName = info->sSignatureAlgorithmName; |
| SEC_CHAR *oldEncAlgName = info->sEncryptAlgorithmName; |
| |
| if (oldSigAlgName) |
| { |
| info->sSignatureAlgorithmName = |
| (PSTR)SECUR32_AllocWideFromMultiByte(oldSigAlgName); |
| package->provider->fnTableW.FreeContextBuffer( |
| oldSigAlgName); |
| } |
| if (oldEncAlgName) |
| { |
| info->sEncryptAlgorithmName = |
| (PSTR)SECUR32_AllocWideFromMultiByte( |
| oldEncAlgName); |
| package->provider->fnTableW.FreeContextBuffer( |
| oldEncAlgName); |
| } |
| break; |
| } |
| case SECPKG_ATTR_PACKAGE_INFO: |
| { |
| PSecPkgContext_PackageInfoA info = |
| (PSecPkgContext_PackageInfoA)pBuffer; |
| PSecPkgInfoA oldPkgInfo = info->PackageInfo; |
| |
| if (oldPkgInfo) |
| { |
| info->PackageInfo = (PSecPkgInfoA) |
| _copyPackageInfoFlatAToW(oldPkgInfo); |
| package->provider->fnTableW.FreeContextBuffer(oldPkgInfo); |
| } |
| break; |
| } |
| case SECPKG_ATTR_NEGOTIATION_INFO: |
| { |
| PSecPkgContext_NegotiationInfoA info = |
| (PSecPkgContext_NegotiationInfoA)pBuffer; |
| PSecPkgInfoA oldPkgInfo = info->PackageInfo; |
| |
| if (oldPkgInfo) |
| { |
| info->PackageInfo = (PSecPkgInfoA) |
| _copyPackageInfoFlatAToW(oldPkgInfo); |
| package->provider->fnTableW.FreeContextBuffer(oldPkgInfo); |
| } |
| break; |
| } |
| case SECPKG_ATTR_NATIVE_NAMES: |
| { |
| PSecPkgContext_NativeNamesA names = |
| (PSecPkgContext_NativeNamesA)pBuffer; |
| PSTR oldClient = names->sClientName; |
| PSTR oldServer = names->sServerName; |
| |
| if (oldClient) |
| { |
| names->sClientName = (PSTR)SECUR32_AllocWideFromMultiByte( |
| oldClient); |
| package->provider->fnTableW.FreeContextBuffer(oldClient); |
| } |
| if (oldServer) |
| { |
| names->sServerName = (PSTR)SECUR32_AllocWideFromMultiByte( |
| oldServer); |
| package->provider->fnTableW.FreeContextBuffer(oldServer); |
| } |
| break; |
| } |
| case SECPKG_ATTR_CREDENTIAL_NAME: |
| { |
| PSecPkgContext_CredentialNameA name = |
| (PSecPkgContext_CredentialNameA)pBuffer; |
| PSTR oldCred = name->sCredentialName; |
| |
| if (oldCred) |
| { |
| name->sCredentialName = |
| (PSTR)SECUR32_AllocWideFromMultiByte(oldCred); |
| package->provider->fnTableW.FreeContextBuffer(oldCred); |
| } |
| break; |
| } |
| /* no thunking needed: */ |
| case SECPKG_ATTR_ACCESS_TOKEN: |
| case SECPKG_ATTR_DCE_INFO: |
| case SECPKG_ATTR_FLAGS: |
| case SECPKG_ATTR_LIFESPAN: |
| case SECPKG_ATTR_PASSWORD_EXPIRY: |
| case SECPKG_ATTR_SESSION_KEY: |
| case SECPKG_ATTR_SIZES: |
| case SECPKG_ATTR_STREAM_SIZES: |
| case SECPKG_ATTR_TARGET_INFORMATION: |
| break; |
| default: |
| WARN("attribute type %d unknown\n", ulAttribute); |
| ret = SEC_E_INTERNAL_ERROR; |
| } |
| } |
| else |
| ret = SEC_E_INVALID_TOKEN; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_QueryContextAttributesW(PCtxtHandle phContext, |
| ULONG ulAttribute, void *pBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p\n", phContext, ulAttribute, pBuffer); |
| if (phContext) |
| { |
| SecurePackage *package = (SecurePackage *)phContext->dwUpper; |
| PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower; |
| |
| if (package && package->provider) |
| { |
| if (package->provider->fnTableA.QueryContextAttributesA) |
| { |
| ret = package->provider->fnTableA.QueryContextAttributesA( |
| ctxt, ulAttribute, pBuffer); |
| if (ret == SEC_E_OK) |
| ret = thunk_ContextAttributesAToW(package, ulAttribute, |
| pBuffer); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_SetContextAttributesA(PCtxtHandle phContext, |
| ULONG ulAttribute, void *pBuffer, ULONG cbBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer); |
| if (phContext) |
| { |
| SecurePackage *package = (SecurePackage *)phContext->dwUpper; |
| PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower; |
| |
| if (package && package->provider && pBuffer && cbBuffer) |
| { |
| if (package->provider->fnTableW.SetContextAttributesW) |
| { |
| /* TODO: gotta validate size too! */ |
| ret = thunk_ContextAttributesWToA(package, ulAttribute, |
| pBuffer); |
| if (ret == SEC_E_OK) |
| ret = package->provider->fnTableW.SetContextAttributesW( |
| ctxt, ulAttribute, pBuffer, cbBuffer); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_SetContextAttributesW(PCtxtHandle phContext, |
| ULONG ulAttribute, void *pBuffer, ULONG cbBuffer) |
| { |
| SECURITY_STATUS ret; |
| |
| TRACE("%p %d %p %d\n", phContext, ulAttribute, pBuffer, cbBuffer); |
| if (phContext) |
| { |
| SecurePackage *package = (SecurePackage *)phContext->dwUpper; |
| PCtxtHandle ctxt = (PCtxtHandle)phContext->dwLower; |
| |
| if (package && package->provider && pBuffer && cbBuffer) |
| { |
| if (package->provider->fnTableA.SetContextAttributesA) |
| { |
| /* TODO: gotta validate size too! */ |
| ret = thunk_ContextAttributesAToW(package, ulAttribute, |
| pBuffer); |
| if (ret == SEC_E_OK) |
| ret = package->provider->fnTableA.SetContextAttributesA( |
| ctxt, ulAttribute, pBuffer, cbBuffer); |
| } |
| else |
| ret = SEC_E_UNSUPPORTED_FUNCTION; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| } |
| else |
| ret = SEC_E_INVALID_HANDLE; |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_ImportSecurityContextA( |
| SEC_CHAR *pszPackage, PSecBuffer pPackedContext, void *Token, |
| PCtxtHandle phContext) |
| { |
| SECURITY_STATUS ret; |
| UNICODE_STRING package; |
| |
| TRACE("%s %p %p %p\n", debugstr_a(pszPackage), pPackedContext, Token, |
| phContext); |
| RtlCreateUnicodeStringFromAsciiz(&package, pszPackage); |
| ret = ImportSecurityContextW(package.Buffer, pPackedContext, Token, |
| phContext); |
| RtlFreeUnicodeString(&package); |
| return ret; |
| } |
| |
| SECURITY_STATUS SEC_ENTRY thunk_ImportSecurityContextW( |
| SEC_WCHAR *pszPackage, PSecBuffer pPackedContext, void *Token, |
| PCtxtHandle phContext) |
| { |
| SECURITY_STATUS ret; |
| PSTR package = SECUR32_AllocMultiByteFromWide(pszPackage); |
| |
| TRACE("%s %p %p %p\n", debugstr_w(pszPackage), pPackedContext, Token, |
| phContext); |
| ret = ImportSecurityContextA(package, pPackedContext, Token, phContext); |
| HeapFree(GetProcessHeap(), 0, package); |
| return ret; |
| } |
