Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-02-24 09:25:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

partial sync to wine 1.1.31

Browse source 
svn path=/trunk/; revision=43442
This commit is contained in:
Christoph von Wittich 2009-10-13 21:09:08 +00:00
parent 3a38bb048a
commit df9eccd994
1 changed files with 84 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

146
reactos/dll/win32/advapi32/sec/cred.c
View file

@ -911,55 +911,63 @@ static DWORD mac_delete_credential(LPCWSTR TargetName)
}
#endif
static void convert_PCREDENTIALW_to_PCREDENTIALA(const CREDENTIALW *CredentialW, PCREDENTIALA CredentialA, DWORD *len)
static INT convert_PCREDENTIALW_to_PCREDENTIALA(const CREDENTIALW *CredentialW, PCREDENTIALA CredentialA, INT len)
{
char *buffer = (char *)CredentialA + sizeof(CREDENTIALA);
char *buffer;
INT string_len;
INT needed = sizeof(CREDENTIALA);
*len += sizeof(CREDENTIALA);
if (!CredentialA)
{
if (CredentialW->TargetName) *len += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, NULL, 0, NULL, NULL);
if (CredentialW->Comment) *len += WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, NULL, 0, NULL, NULL);
*len += CredentialW->CredentialBlobSize;
if (CredentialW->TargetAlias) *len += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, NULL, 0, NULL, NULL);
if (CredentialW->UserName) *len += WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, NULL, 0, NULL, NULL);
if (CredentialW->TargetName)
needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, NULL, 0, NULL, NULL);
if (CredentialW->Comment)
needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, NULL, 0, NULL, NULL);
needed += CredentialW->CredentialBlobSize;
if (CredentialW->TargetAlias)
needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, NULL, 0, NULL, NULL);
if (CredentialW->UserName)
needed += WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, NULL, 0, NULL, NULL);
return;
return needed;
}
buffer = (char *)CredentialA + sizeof(CREDENTIALA);
len -= sizeof(CREDENTIALA);
CredentialA->Flags = CredentialW->Flags;
CredentialA->Type = CredentialW->Type;
if (CredentialW->TargetName)
{
CredentialA->TargetName = buffer;
/* Buffer is guaranteed to be large enough */
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, CredentialA->TargetName, 0x7FFFFFFF, NULL, NULL);
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetName, -1, buffer, len, NULL, NULL);
buffer += string_len;
*len += string_len;
needed += string_len;
len -= string_len;
}
else
CredentialA->TargetName = NULL;
if (CredentialW->Comment)
{
CredentialA->Comment = buffer;
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, CredentialA->Comment, 0x7FFFFFFF, NULL, NULL);
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->Comment, -1, buffer, len, NULL, NULL);
buffer += string_len;
*len += string_len;
needed += string_len;
len -= string_len;
}
else
CredentialA->Comment = NULL;
CredentialA->LastWritten = CredentialW->LastWritten;
CredentialA->CredentialBlobSize = CredentialW->CredentialBlobSize;
if (CredentialW->CredentialBlobSize)
if (CredentialW->CredentialBlobSize && (CredentialW->CredentialBlobSize <= len))
{
CredentialA->CredentialBlob =(LPBYTE)buffer;
memcpy(CredentialA->CredentialBlob, CredentialW->CredentialBlob,
CredentialW->CredentialBlobSize);
buffer += CredentialW->CredentialBlobSize;
*len += CredentialW->CredentialBlobSize;
needed += CredentialW->CredentialBlobSize;
len -= CredentialW->CredentialBlobSize;
}
else
CredentialA->CredentialBlob = NULL;
@ -969,57 +977,67 @@ static void convert_PCREDENTIALW_to_PCREDENTIALA(const CREDENTIALW *CredentialW,
if (CredentialW->TargetAlias)
{
CredentialA->TargetAlias = buffer;
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, CredentialA->TargetAlias, 0x7FFFFFFF, NULL, NULL);
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->TargetAlias, -1, buffer, len, NULL, NULL);
buffer += string_len;
*len += string_len;
needed += string_len;
len -= string_len;
}
else
CredentialA->TargetAlias = NULL;
if (CredentialW->UserName)
{
CredentialA->UserName = buffer;
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, CredentialA->UserName, 0x7FFFFFFF, NULL, NULL);
buffer += string_len;
*len += string_len;
string_len = WideCharToMultiByte(CP_ACP, 0, CredentialW->UserName, -1, buffer, len, NULL, NULL);
needed += string_len;
}
else
CredentialA->UserName = NULL;
return needed;
}
static void convert_PCREDENTIALA_to_PCREDENTIALW(const CREDENTIALA *CredentialA, PCREDENTIALW CredentialW, DWORD *len)
static INT convert_PCREDENTIALA_to_PCREDENTIALW(const CREDENTIALA *CredentialA, PCREDENTIALW CredentialW, INT len)
{
char *buffer = (char *)CredentialW + sizeof(CREDENTIALW);
char *buffer;
INT string_len;
INT needed = sizeof(CREDENTIALW);
*len += sizeof(CREDENTIALW);
if (!CredentialW)
{
if (CredentialA->TargetName) *len += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, NULL, 0);
if (CredentialA->Comment) *len += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, NULL, 0);
*len += CredentialA->CredentialBlobSize;
if (CredentialA->TargetAlias) *len += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, NULL, 0);
if (CredentialA->UserName) *len += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, NULL, 0);
if (CredentialA->TargetName)
needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, NULL, 0);
if (CredentialA->Comment)
needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, NULL, 0);
needed += CredentialA->CredentialBlobSize;
if (CredentialA->TargetAlias)
needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, NULL, 0);
if (CredentialA->UserName)
needed += sizeof(WCHAR) * MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, NULL, 0);
return;
return needed;
}
buffer = (char *)CredentialW + sizeof(CREDENTIALW);
len -= sizeof(CREDENTIALW);
CredentialW->Flags = CredentialA->Flags;
CredentialW->Type = CredentialA->Type;
if (CredentialA->TargetName)
{
CredentialW->TargetName = (LPWSTR)buffer;
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, CredentialW->TargetName, 0x7FFFFFFF);
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetName, -1, CredentialW->TargetName, len / sizeof(WCHAR));
buffer += sizeof(WCHAR) * string_len;
*len += sizeof(WCHAR) * string_len;
needed += sizeof(WCHAR) * string_len;
len -= sizeof(WCHAR) * string_len;
}
else
CredentialW->TargetName = NULL;
if (CredentialA->Comment)
{
CredentialW->Comment = (LPWSTR)buffer;
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, CredentialW->Comment, 0x7FFFFFFF);
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->Comment, -1, CredentialW->Comment, len / sizeof(WCHAR));
buffer += sizeof(WCHAR) * string_len;
*len += sizeof(WCHAR) * string_len;
needed += sizeof(WCHAR) * string_len;
len -= sizeof(WCHAR) * string_len;
}
else
CredentialW->Comment = NULL;
@ -1031,7 +1049,8 @@ static void convert_PCREDENTIALA_to_PCREDENTIALW(const CREDENTIALA *CredentialA,
memcpy(CredentialW->CredentialBlob, CredentialA->CredentialBlob,
CredentialA->CredentialBlobSize);
buffer += CredentialA->CredentialBlobSize;
*len += CredentialA->CredentialBlobSize;
needed += CredentialA->CredentialBlobSize;
len -= CredentialA->CredentialBlobSize;
}
else
CredentialW->CredentialBlob = NULL;
@ -1041,21 +1060,23 @@ static void convert_PCREDENTIALA_to_PCREDENTIALW(const CREDENTIALA *CredentialA,
if (CredentialA->TargetAlias)
{
CredentialW->TargetAlias = (LPWSTR)buffer;
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, CredentialW->TargetAlias, 0x7FFFFFFF);
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->TargetAlias, -1, CredentialW->TargetAlias, len / sizeof(WCHAR));
buffer += sizeof(WCHAR) * string_len;
*len += sizeof(WCHAR) * string_len;
needed += sizeof(WCHAR) * string_len;
len -= sizeof(WCHAR) * string_len;
}
else
CredentialW->TargetAlias = NULL;
if (CredentialA->UserName)
{
CredentialW->UserName = (LPWSTR)buffer;
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, CredentialW->UserName, 0x7FFFFFFF);
buffer += sizeof(WCHAR) * string_len;
*len += sizeof(WCHAR) * string_len;
string_len = MultiByteToWideChar(CP_ACP, 0, CredentialA->UserName, -1, CredentialW->UserName, len / sizeof(WCHAR));
needed += sizeof(WCHAR) * string_len;
}
else
CredentialW->UserName = NULL;
return needed;
}
/******************************************************************************
@ -1161,7 +1182,8 @@ BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,
LPWSTR FilterW;
PCREDENTIALW *CredentialsW;
DWORD i;
DWORD len;
INT len;
INT needed;
char *buffer;
TRACE("(%s, 0x%x, %p, %p)\n", debugstr_a(Filter), Flags, Count, Credentials);
@ -1189,7 +1211,7 @@ BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,
len = *Count * sizeof(PCREDENTIALA);
for (i = 0; i < *Count; i++)
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, &len);
len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
*Credentials = HeapAlloc(GetProcessHeap(), 0, len);
if (!*Credentials)
@ -1200,12 +1222,13 @@ BOOL WINAPI CredEnumerateA(LPCSTR Filter, DWORD Flags, DWORD *Count,
}
buffer = (char *)&(*Credentials)[*Count];
len -= *Count * sizeof(PCREDENTIALA);
for (i = 0; i < *Count; i++)
{
len = 0;
(*Credentials)[i] = (PCREDENTIALA)buffer;
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], &len);
buffer += len;
needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
buffer += needed;
len -= needed;
}
CredFree(CredentialsW);
@ -1334,7 +1357,7 @@ BOOL WINAPI CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *
{
LPWSTR TargetNameW;
PCREDENTIALW CredentialW;
DWORD len;
INT len;
TRACE("(%s, %d, 0x%x, %p)\n", debugstr_a(TargetName), Type, Flags, Credential);
@ -1360,16 +1383,14 @@ BOOL WINAPI CredReadA(LPCSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALA *
}
HeapFree(GetProcessHeap(), 0, TargetNameW);
len = 0;
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, NULL, &len);
len = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, NULL, 0);
*Credential = HeapAlloc(GetProcessHeap(), 0, len);
if (!*Credential)
{
SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
len = 0;
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, *Credential, &len);
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialW, *Credential, len);
CredFree(CredentialW);
@ -1540,7 +1561,7 @@ BOOL WINAPI CredReadW(LPCWSTR TargetName, DWORD Type, DWORD Flags, PCREDENTIALW
BOOL WINAPI CredWriteA(PCREDENTIALA Credential, DWORD Flags)
{
BOOL ret;
DWORD len;
INT len;
PCREDENTIALW CredentialW;
TRACE("(%p, 0x%x)\n", Credential, Flags);
@ -1551,16 +1572,15 @@ BOOL WINAPI CredWriteA(PCREDENTIALA Credential, DWORD Flags)
return FALSE;
}
len = 0;
convert_PCREDENTIALA_to_PCREDENTIALW(Credential, NULL, &len);
len = convert_PCREDENTIALA_to_PCREDENTIALW(Credential, NULL, 0);
CredentialW = HeapAlloc(GetProcessHeap(), 0, len);
if (!CredentialW)
{
SetLastError(ERROR_OUTOFMEMORY);
return FALSE;
}
len = 0;
convert_PCREDENTIALA_to_PCREDENTIALW(Credential, CredentialW, &len);
convert_PCREDENTIALA_to_PCREDENTIALW(Credential, CredentialW, len);
ret = CredWriteW(CredentialW, Flags);
@ -1722,7 +1742,7 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf
DWORD Flags, DWORD *Size, PCREDENTIALA **Credentials)
{
PCREDENTIAL_TARGET_INFORMATIONW TargetInformationW;
DWORD len, i;
INT len, i;
WCHAR *buffer, *end;
BOOL ret;
PCREDENTIALW* CredentialsW;
@ -1831,10 +1851,11 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf
if (ret)
{
char *buf;
INT needed;
len = *Size * sizeof(PCREDENTIALA);
for (i = 0; i < *Size; i++)
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, &len);
len += convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], NULL, 0);
*Credentials = HeapAlloc(GetProcessHeap(), 0, len);
if (!*Credentials)
@ -1845,12 +1866,13 @@ BOOL WINAPI CredReadDomainCredentialsA(PCREDENTIAL_TARGET_INFORMATIONA TargetInf
}
buf = (char *)&(*Credentials)[*Size];
len -= *Size * sizeof(PCREDENTIALA);
for (i = 0; i < *Size; i++)
{
len = 0;
(*Credentials)[i] = (PCREDENTIALA)buf;
convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], &len);
buf += len;
needed = convert_PCREDENTIALW_to_PCREDENTIALA(CredentialsW[i], (*Credentials)[i], len);
buf += needed;
len -= needed;
}
CredFree(CredentialsW);