DWORD APIENTRY NPEnumResource(
HANDLE hEnum, LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
{
FSP_NP_ENUM *Enum = hEnum;
DWORD NpResult;
LPNETRESOURCEW Resource; /* grows upwards */
PWCHAR Strings; /* grows downwards */
PWCHAR ProviderName = 0;
DWORD Count;
PWCHAR P, VolumePrefix;
ULONG Backslashes;
WCHAR Drive;
if (!FspNpValidateEnum(Enum))
return WN_BAD_HANDLE;
if (0 == lpcCount || 0 == lpBuffer || 0 == lpBufferSize)
return WN_BAD_VALUE;
Resource = lpBuffer;
Strings = (PVOID)((PUINT8)lpBuffer + (*lpBufferSize & ~1/* WCHAR alignment */));
Count = 0;
for (P = Enum->VolumeName; *lpcCount > Count && Enum->VolumeListBufEnd > P; P++)
{
if (L'\0' == *P)
{
/*
* Extract the VolumePrefix from the VolumeName.
*
* The VolumeName will have the following syntax:
* \Device\Volume{GUID}\Server\Share
*
* We want to extract the \Server\Share part. We will simply count backslashes and
* stop at the third one.
*/
for (Backslashes = 0, VolumePrefix = Enum->VolumeName; VolumePrefix < P; VolumePrefix++)
if (L'\\' == *VolumePrefix)
if (3 == ++Backslashes)
break;
if (3 == Backslashes)
{
Drive = FspNpGetDriveLetter(&Enum->LogicalDrives, Enum->VolumeName);
Strings -= (Drive ? 3 : 0) + 2/* backslash + term-0 */ + lstrlenW(VolumePrefix) +
(0 == ProviderName ? lstrlenW(L"" FSP_NP_NAME) + 1 : 0);
if ((PVOID)(Resource + 1) > (PVOID)Strings)
{
if (0 == Count)
{
*lpBufferSize =
(DWORD)((PUINT8)(Resource + 1) - (PUINT8)lpBuffer) +
(DWORD)((PUINT8)lpBuffer + *lpBufferSize - (PUINT8)Strings);
NpResult = WN_MORE_DATA;
}
else
{
*lpcCount = Count;
NpResult = WN_SUCCESS;
}
goto exit;
}
if (0 == ProviderName)
{
ProviderName = Strings + (Drive ? 3 : 0) + 2/* backslash + term-0 */ + lstrlenW(VolumePrefix);
lstrcpyW(ProviderName, L"" FSP_NP_NAME);
}
if (Drive)
{
Strings[0] = Drive;
Strings[1] = L':';
Strings[2] = L'\0';
Strings[3] = L'\\';
lstrcpyW(Strings + 4, VolumePrefix);
}
else
{
Strings[0] = L'\\';
lstrcpyW(Strings + 1, VolumePrefix);
}
Resource->dwScope = Enum->dwScope;
Resource->dwType = RESOURCETYPE_DISK;
Resource->dwDisplayType = RESOURCEDISPLAYTYPE_SHARE;
Resource->dwUsage = RESOURCEUSAGE_CONNECTABLE;
Resource->lpLocalName = Drive ? Strings : 0;
Resource->lpRemoteName = Drive ? Strings + 3 : Strings;
Resource->lpComment = 0;
Resource->lpProvider = ProviderName;
Resource++;
Count++;
}
Enum->VolumeName = P + 1;
}
}
if (0 == Count)
NpResult = WN_NO_MORE_ENTRIES;
else
{
*lpcCount = Count;
NpResult = WN_SUCCESS;
}
exit:
return NpResult;
}
/*******************************************************************************
* GAMEUX_ParseGDFBinary
*
* Helper function, loads given binary and parses embed GDF if there's any.
*
* Parameters:
* GameData [I/O] Structure with game's data. Content of field
* sGDFBinaryPath defines path to binary, from
* which embed GDF will be loaded. Data from
* GDF will be stored in other fields of this
* structure.
*/
static HRESULT GAMEUX_ParseGDFBinary(struct GAMEUX_GAME_DATA *GameData)
{
static const WCHAR sRes[] = {'r','e','s',':','/','/',0};
static const WCHAR sDATA[] = {'D','A','T','A',0};
static const WCHAR sSlash[] = {'/',0};
HRESULT hr = S_OK;
WCHAR sResourcePath[MAX_PATH];
VARIANT variant;
VARIANT_BOOL isSuccessful;
IXMLDOMDocument *document;
IXMLDOMNode *gdNode;
IXMLDOMElement *root, *gdElement;
TRACE("(%p)->sGDFBinaryPath = %s\n", GameData, debugstr_w(GameData->sGDFBinaryPath));
/* prepare path to GDF, using res:// prefix */
lstrcpyW(sResourcePath, sRes);
lstrcatW(sResourcePath, GameData->sGDFBinaryPath);
lstrcatW(sResourcePath, sSlash);
lstrcatW(sResourcePath, sDATA);
lstrcatW(sResourcePath, sSlash);
lstrcatW(sResourcePath, ID_GDF_XML_STR);
hr = CoCreateInstance(&CLSID_DOMDocument, NULL, CLSCTX_INPROC_SERVER,
&IID_IXMLDOMDocument, (void**)&document);
if(SUCCEEDED(hr))
{
/* load GDF into MSXML */
V_VT(&variant) = VT_BSTR;
V_BSTR(&variant) = SysAllocString(sResourcePath);
if(!V_BSTR(&variant))
hr = E_OUTOFMEMORY;
if(SUCCEEDED(hr))
{
hr = IXMLDOMDocument_load(document, variant, &isSuccessful);
if(hr == S_FALSE || isSuccessful == VARIANT_FALSE)
hr = E_FAIL;
}
SysFreeString(V_BSTR(&variant));
if(SUCCEEDED(hr))
{
hr = IXMLDOMDocument_get_documentElement(document, &root);
if(hr == S_FALSE)
hr = E_FAIL;
}
if(SUCCEEDED(hr))
{
hr = IXMLDOMElement_get_firstChild(root, &gdNode);
if(hr == S_FALSE)
hr = E_FAIL;
if(SUCCEEDED(hr))
{
hr = IXMLDOMNode_QueryInterface(gdNode, &IID_IXMLDOMElement, (LPVOID*)&gdElement);
if(SUCCEEDED(hr))
{
hr = GAMEUX_ParseGameDefinition(gdElement, GameData);
IXMLDOMElement_Release(gdElement);
}
IXMLDOMNode_Release(gdNode);
}
IXMLDOMElement_Release(root);
}
IXMLDOMDocument_Release(document);
}
return hr;
}
/*
* Try to parse object at current cursor position
* Returns:
* NTDS_BAD_RECORD if record is not a user account or computer
* NTDS_MEM_ERROR if memory allocation errors
*/
int NTDS_NTLM_ParseSAMRecord(s_parser *parser,JET_TABLEID tableid,s_ldapAccountInfo *ldapAccountEntry,BOOL with_history) {
unsigned long attributeSize;
BYTE attributeVal[1024];
JET_ERR jet_err;
RtlZeroMemory(ldapAccountEntry,sizeof(s_ldapAccountInfo));
/* Browse per sam account type */
attributeSize = sizeof(attributeVal);
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_SAM_ACCOUNT_TYPE].columnid,attributeVal,&attributeSize);
if((jet_err==JET_errSuccess)&&(attributeSize==sizeof(ldapAccountEntry->szSAMAccountType))) {
ldapAccountEntry->szSAMAccountType = *(LPDWORD)attributeVal;
}
else
return NTDS_BAD_RECORD;
if((ldapAccountEntry->szSAMAccountType != SAM_USER_OBJECT) &&
(ldapAccountEntry->szSAMAccountType != SAM_MACHINE_ACCOUNT) &&
(ldapAccountEntry->szSAMAccountType != SAM_TRUST_ACCOUNT)){
return NTDS_BAD_RECORD;
}
/* Get SAM account name */
attributeSize = sizeof(attributeVal);
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_SAM_ACCOUNT_NAME].columnid,attributeVal,&attributeSize);
if((!attributeSize) || (jet_err!=JET_errSuccess))
return NTDS_BAD_RECORD;
lstrcpyW(ldapAccountEntry->szSAMAccountName,(LPWSTR)attributeVal);
/* Get LM hash */
attributeSize = sizeof(attributeVal);
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_LM_HASH].columnid,attributeVal,&attributeSize);
if((jet_err==JET_errSuccess)&&(attributeSize==sizeof(s_NTLM_hash_ciphered))) {
RtlMoveMemory(&ldapAccountEntry->LM_hash_ciphered,attributeVal,sizeof(s_NTLM_hash_ciphered));
ldapAccountEntry->NTLM_hash.hash_type = LM_HASH;
}
else {
ldapAccountEntry->NTLM_hash.hash_type = NT_NO_HASH;
}
/* Get NT hash */
attributeSize = sizeof(attributeVal);
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_NT_HASH].columnid,attributeVal,&attributeSize);
if((jet_err==JET_errSuccess)&&(attributeSize==sizeof(s_NTLM_hash_ciphered))) {
RtlMoveMemory(&ldapAccountEntry->NT_hash_ciphered,attributeVal,sizeof(s_NTLM_hash_ciphered));
if(ldapAccountEntry->NTLM_hash.hash_type != LM_HASH)
ldapAccountEntry->NTLM_hash.hash_type = NT_HASH;
}
if(with_history) {
/* Get LM hash history */
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_LM_HASH_HISTORY].columnid,NULL,&attributeSize);
if(jet_err==JET_errSuccess && attributeSize) {
ldapAccountEntry->LM_history_ciphered = (LPBYTE)VirtualAlloc(NULL,attributeSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
ldapAccountEntry->LM_history_deciphered = (LPBYTE)VirtualAlloc(NULL,attributeSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
if(!ldapAccountEntry->LM_history_ciphered || !ldapAccountEntry->LM_history_deciphered)
return NTDS_MEM_ERROR;
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_LM_HASH_HISTORY].columnid,ldapAccountEntry->LM_history_ciphered,&attributeSize);
if(jet_err != JET_errSuccess)
return NTDS_API_ERROR;
ldapAccountEntry->LM_history_ciphered_size = attributeSize;
}
/* Get NT hash history */
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_NT_HASH_HISTORY].columnid,NULL,&attributeSize);
if(jet_err==JET_errSuccess && attributeSize) {
ldapAccountEntry->NT_history_ciphered = (LPBYTE)VirtualAlloc(NULL,attributeSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
ldapAccountEntry->NT_history_deciphered = (LPBYTE)VirtualAlloc(NULL,attributeSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
if(!ldapAccountEntry->NT_history_ciphered || !ldapAccountEntry->NT_history_deciphered)
return NTDS_MEM_ERROR;
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_NT_HASH_HISTORY].columnid,ldapAccountEntry->NT_history_ciphered,&attributeSize);
if(jet_err != JET_errSuccess)
return NTDS_API_ERROR;
}
if(ldapAccountEntry->LM_history_ciphered && ldapAccountEntry->NT_history_ciphered) {
ldapAccountEntry->nbHistoryEntries = (attributeSize - 24) / WIN_NTLM_HASH_SIZE;
if(!(ldapAccountEntry->NTLM_hash_history = (s_NTLM_Hash *)VirtualAlloc(NULL,ldapAccountEntry->nbHistoryEntries*sizeof(s_NTLM_Hash),MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE)))
return NTDS_MEM_ERROR;
ldapAccountEntry->NT_history_ciphered_size = attributeSize;
}
}
/* Get Sid */
attributeSize = sizeof(attributeVal);
jet_err = NTDS_GetRecord(parser,tableid,parser->columndef[ID_OBJECT_SID].columnid,attributeVal,&attributeSize);
if(jet_err==JET_errSuccess) {
ldapAccountEntry->sid = (PSID)VirtualAlloc(NULL,attributeSize,MEM_COMMIT | MEM_RESERVE,PAGE_READWRITE);
if(!ldapAccountEntry->sid)
return NTDS_MEM_ERROR;
RtlMoveMemory(ldapAccountEntry->sid,attributeVal,attributeSize-sizeof(ldapAccountEntry->rid));
ldapAccountEntry->rid = BSWAP(*LPDWORD(attributeVal+attributeSize-sizeof(ldapAccountEntry->rid)));
*LPDWORD((LPBYTE)ldapAccountEntry->sid+attributeSize-sizeof(ldapAccountEntry->rid))= ldapAccountEntry->rid;
}
else
return NTDS_BAD_RECORD;
return NTDS_SUCCESS;
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file - writable file stream to export registry branch to.
* key - registry branch to export.
* reg_key_name_buf - name of the key with registry class.
* Is resized if necessary.
* reg_key_name_size - length of the buffer for the registry class in characters.
* val_name_buf - buffer for storing value name.
* Is resized if necessary.
* val_name_size - length of the buffer for storing value names in characters.
* val_buf - buffer for storing values while extracting.
* Is resized if necessary.
* val_size - size of the buffer for storing values in bytes.
*/
static void export_hkey(FILE *file, HKEY key,
WCHAR **reg_key_name_buf, DWORD *reg_key_name_size,
WCHAR **val_name_buf, DWORD *val_name_size,
BYTE **val_buf, DWORD *val_size,
WCHAR **line_buf, DWORD *line_buf_size,
BOOL unicode)
{
DWORD max_sub_key_len;
DWORD max_val_name_len;
DWORD max_val_size;
DWORD curr_len;
DWORD i;
BOOL more_data;
LONG ret;
WCHAR key_format[] = {'\n','[','%','s',']','\n',0};
/* get size information and resize the buffers if necessary */
if (RegQueryInfoKeyW(key, NULL, NULL, NULL, NULL,
&max_sub_key_len, NULL,
NULL, &max_val_name_len, &max_val_size, NULL, NULL
) != ERROR_SUCCESS) {
REGPROC_print_error();
}
curr_len = strlenW(*reg_key_name_buf);
REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size,
max_sub_key_len + curr_len + 1);
REGPROC_resize_char_buffer(val_name_buf, val_name_size,
max_val_name_len);
REGPROC_resize_binary_buffer(val_buf, val_size, max_val_size);
REGPROC_resize_char_buffer(line_buf, line_buf_size, lstrlenW(*reg_key_name_buf) + 4);
/* output data for the current key */
sprintfW(*line_buf, key_format, *reg_key_name_buf);
REGPROC_write_line(file, *line_buf, unicode);
/* print all the values */
i = 0;
more_data = TRUE;
while(more_data) {
DWORD value_type;
DWORD val_name_size1 = *val_name_size;
DWORD val_size1 = *val_size;
ret = RegEnumValueW(key, i, *val_name_buf, &val_name_size1, NULL,
&value_type, *val_buf, &val_size1);
if (ret == ERROR_MORE_DATA) {
/* Increase the size of the buffers and retry */
REGPROC_resize_char_buffer(val_name_buf, val_name_size, val_name_size1);
REGPROC_resize_binary_buffer(val_buf, val_size, val_size1);
} else if (ret != ERROR_SUCCESS) {
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
REGPROC_print_error();
}
} else {
DWORD line_len;
i++;
if ((*val_name_buf)[0]) {
const WCHAR val_start[] = {'"','%','s','"','=',0};
line_len = 0;
REGPROC_export_string(line_buf, line_buf_size, &line_len, *val_name_buf, lstrlenW(*val_name_buf));
REGPROC_resize_char_buffer(val_name_buf, val_name_size, lstrlenW(*line_buf) + 1);
lstrcpyW(*val_name_buf, *line_buf);
line_len = 3 + lstrlenW(*val_name_buf);
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
sprintfW(*line_buf, val_start, *val_name_buf);
} else {
const WCHAR std_val[] = {'@','=',0};
line_len = 2;
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
lstrcpyW(*line_buf, std_val);
}
switch (value_type) {
case REG_SZ:
{
WCHAR* wstr = (WCHAR*)*val_buf;
if (val_size1 < sizeof(WCHAR) || val_size1 % sizeof(WCHAR) ||
wstr[val_size1 / sizeof(WCHAR) - 1]) {
REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
} else {
const WCHAR start[] = {'"',0};
const WCHAR end[] = {'"','\n',0};
DWORD len;
len = lstrlenW(start);
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + len);
lstrcpyW(*line_buf + line_len, start);
line_len += len;
/* At this point we know wstr is '\0'-terminated
* so we can substract 1 from the size
*/
REGPROC_export_string(line_buf, line_buf_size, &line_len, wstr, val_size1 / sizeof(WCHAR) - 1);
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + lstrlenW(end));
lstrcpyW(*line_buf + line_len, end);
}
break;
}
case REG_DWORD:
{
WCHAR format[] = {'d','w','o','r','d',':','%','0','8','x','\n',0};
REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + 15);
sprintfW(*line_buf + line_len, format, *((DWORD *)*val_buf));
break;
}
default:
{
char* key_nameA = GetMultiByteString(*reg_key_name_buf);
char* value_nameA = GetMultiByteString(*val_name_buf);
fprintf(stderr,"%s: warning - unsupported registry format '%d', "
"treat as binary\n",
getAppName(), value_type);
fprintf(stderr,"key name: \"%s\"\n", key_nameA);
fprintf(stderr,"value name:\"%s\"\n\n", value_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
HeapFree(GetProcessHeap(), 0, value_nameA);
}
/* falls through */
case REG_EXPAND_SZ:
case REG_MULTI_SZ:
/* falls through */
case REG_BINARY:
REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
}
REGPROC_write_line(file, *line_buf, unicode);
}
}
i = 0;
more_data = TRUE;
(*reg_key_name_buf)[curr_len] = '\\';
while(more_data) {
DWORD buf_size = *reg_key_name_size - curr_len - 1;
ret = RegEnumKeyExW(key, i, *reg_key_name_buf + curr_len + 1, &buf_size,
NULL, NULL, NULL, NULL);
if (ret == ERROR_MORE_DATA) {
/* Increase the size of the buffer and retry */
REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size, curr_len + 1 + buf_size);
} else if (ret != ERROR_SUCCESS) {
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
REGPROC_print_error();
}
} else {
HKEY subkey;
i++;
if (RegOpenKeyW(key, *reg_key_name_buf + curr_len + 1,
&subkey) == ERROR_SUCCESS) {
export_hkey(file, subkey, reg_key_name_buf, reg_key_name_size,
val_name_buf, val_name_size, val_buf, val_size,
line_buf, line_buf_size, unicode);
RegCloseKey(subkey);
} else {
REGPROC_print_error();
}
}
}
(*reg_key_name_buf)[curr_len] = '\0';
}
static void REGPROC_export_binary(WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, DWORD type, BYTE *value, DWORD value_size, BOOL unicode)
{
DWORD hex_pos, data_pos;
const WCHAR *hex_prefix;
const WCHAR hex[] = {'h','e','x',':',0};
WCHAR hex_buf[17];
const WCHAR concat[] = {'\\','\n',' ',' ',0};
DWORD concat_prefix, concat_len;
const WCHAR newline[] = {'\n',0};
CHAR* value_multibyte = NULL;
if (type == REG_BINARY) {
hex_prefix = hex;
} else {
const WCHAR hex_format[] = {'h','e','x','(','%','u',')',':',0};
hex_prefix = hex_buf;
sprintfW(hex_buf, hex_format, type);
if ((type == REG_SZ || type == REG_EXPAND_SZ || type == REG_MULTI_SZ) && !unicode)
{
value_multibyte = GetMultiByteStringN((WCHAR*)value, value_size / sizeof(WCHAR), &value_size);
value = (BYTE*)value_multibyte;
}
}
concat_len = lstrlenW(concat);
concat_prefix = 2;
hex_pos = *line_len;
*line_len += lstrlenW(hex_prefix);
data_pos = *line_len;
*line_len += value_size * 3;
/* - The 2 spaces that concat places at the start of the
* line effectively reduce the space available for data.
* - If the value name and hex prefix are very long
* ( > REG_FILE_HEX_LINE_LEN) then we may overestimate
* the needed number of lines by one. But that's ok.
* - The trailing linefeed takes the place of a comma so
* it's accounted for already.
*/
*line_len += *line_len / (REG_FILE_HEX_LINE_LEN - concat_prefix) * concat_len;
REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len);
lstrcpyW(*line_buf + hex_pos, hex_prefix);
if (value_size)
{
const WCHAR format[] = {'%','0','2','x',0};
DWORD i, column;
column = data_pos; /* no line wrap yet */
i = 0;
while (1)
{
sprintfW(*line_buf + data_pos, format, (unsigned int)value[i]);
data_pos += 2;
if (++i == value_size)
break;
(*line_buf)[data_pos++] = ',';
column += 3;
/* wrap the line */
if (column >= REG_FILE_HEX_LINE_LEN) {
lstrcpyW(*line_buf + data_pos, concat);
data_pos += concat_len;
column = concat_prefix;
}
}
}
lstrcpyW(*line_buf + data_pos, newline);
HeapFree(GetProcessHeap(), 0, value_multibyte);
}
static HRESULT WINAPI IAssemblyNameImpl_GetProperty(IAssemblyName *iface,
DWORD PropertyId,
LPVOID pvProperty,
LPDWORD pcbProperty)
{
IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
TRACE("(%p, %d, %p, %p)\n", iface, PropertyId, pvProperty, pcbProperty);
*((LPWSTR)pvProperty) = '\0';
switch (PropertyId)
{
case ASM_NAME_NULL_PUBLIC_KEY:
case ASM_NAME_NULL_PUBLIC_KEY_TOKEN:
if (name->haspubkey)
return S_OK;
return S_FALSE;
case ASM_NAME_NULL_CUSTOM:
return S_OK;
case ASM_NAME_NAME:
*pcbProperty = 0;
if (name->name)
{
lstrcpyW(pvProperty, name->name);
*pcbProperty = (lstrlenW(name->name) + 1) * 2;
}
break;
case ASM_NAME_MAJOR_VERSION:
*pcbProperty = 0;
*((WORD *)pvProperty) = name->version[0];
if (name->versize >= 1)
*pcbProperty = sizeof(WORD);
break;
case ASM_NAME_MINOR_VERSION:
*pcbProperty = 0;
*((WORD *)pvProperty) = name->version[1];
if (name->versize >= 2)
*pcbProperty = sizeof(WORD);
break;
case ASM_NAME_BUILD_NUMBER:
*pcbProperty = 0;
*((WORD *)pvProperty) = name->version[2];
if (name->versize >= 3)
*pcbProperty = sizeof(WORD);
break;
case ASM_NAME_REVISION_NUMBER:
*pcbProperty = 0;
*((WORD *)pvProperty) = name->version[3];
if (name->versize >= 4)
*pcbProperty = sizeof(WORD);
break;
case ASM_NAME_CULTURE:
*pcbProperty = 0;
if (name->culture)
{
lstrcpyW(pvProperty, name->culture);
*pcbProperty = (lstrlenW(name->culture) + 1) * 2;
}
break;
case ASM_NAME_PUBLIC_KEY_TOKEN:
*pcbProperty = 0;
if (name->haspubkey)
{
memcpy(pvProperty, name->pubkey, sizeof(DWORD) * 2);
*pcbProperty = sizeof(DWORD) * 2;
}
break;
default:
*pcbProperty = 0;
break;
}
return S_OK;
}
BOOL RenameKey(HWND hwnd, HKEY hRootKey, LPCWSTR keyPath, LPCWSTR newName)
{
LPWSTR parentPath = 0;
LPCWSTR srcSubKey = 0;
HKEY parentKey = 0;
HKEY destKey = 0;
BOOL result = FALSE;
LONG lRet;
DWORD disposition;
if (!keyPath || !newName) return FALSE;
if (!strrchrW(keyPath, '\\')) {
parentKey = hRootKey;
srcSubKey = keyPath;
} else {
LPWSTR srcSubKey_copy;
parentPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(keyPath)+1)*sizeof(WCHAR));
lstrcpyW(parentPath, keyPath);
srcSubKey_copy = strrchrW(parentPath, '\\');
*srcSubKey_copy = 0;
srcSubKey = srcSubKey_copy + 1;
lRet = RegOpenKeyExW(hRootKey, parentPath, 0, KEY_READ | KEY_CREATE_SUB_KEY, &parentKey);
if (lRet != ERROR_SUCCESS) {
error_code_messagebox(hwnd, lRet);
goto done;
}
}
/* The following fails if the old name is the same as the new name. */
if (!lstrcmpW(srcSubKey, newName)) goto done;
lRet = RegCreateKeyExW(parentKey, newName, 0, NULL, REG_OPTION_NON_VOLATILE,
KEY_WRITE, NULL /* FIXME */, &destKey, &disposition);
if (disposition == REG_OPENED_EXISTING_KEY)
lRet = ERROR_FILE_EXISTS; /* FIXME: we might want a better error message than this */
if (lRet != ERROR_SUCCESS) {
error_code_messagebox(hwnd, lRet);
goto done;
}
/* FIXME: SHCopyKey does not copy the security attributes */
lRet = SHCopyKeyW(parentKey, srcSubKey, destKey, 0);
if (lRet != ERROR_SUCCESS) {
RegCloseKey(destKey);
RegDeleteKeyW(parentKey, newName);
error_code_messagebox(hwnd, lRet);
goto done;
}
lRet = SHDeleteKeyW(hRootKey, keyPath);
if (lRet != ERROR_SUCCESS) {
error_code_messagebox(hwnd, lRet);
goto done;
}
result = TRUE;
done:
RegCloseKey(destKey);
if (parentKey) {
RegCloseKey(parentKey);
HeapFree(GetProcessHeap(), 0, parentPath);
}
return result;
}
static DWORD service_start_process(struct service_entry *service_entry, HANDLE *process)
{
PROCESS_INFORMATION pi;
STARTUPINFOW si;
LPWSTR path = NULL;
DWORD size;
BOOL r;
service_lock_exclusive(service_entry);
if (!env)
{
HANDLE htok;
if (OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY|TOKEN_DUPLICATE, &htok))
CreateEnvironmentBlock(&env, htok, FALSE);
if (!env)
WINE_ERR("failed to create services environment\n");
}
size = ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,NULL,0);
path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR));
if (!path)
{
service_unlock(service_entry);
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
}
ExpandEnvironmentStringsW(service_entry->config.lpBinaryPathName,path,size);
if (service_entry->config.dwServiceType == SERVICE_KERNEL_DRIVER)
{
static const WCHAR winedeviceW[] = {'\\','w','i','n','e','d','e','v','i','c','e','.','e','x','e',' ',0};
WCHAR system_dir[MAX_PATH];
DWORD type, len;
GetSystemDirectoryW( system_dir, MAX_PATH );
if (is_win64)
{
if (!GetBinaryTypeW( path, &type ))
{
HeapFree( GetProcessHeap(), 0, path );
service_unlock(service_entry);
return GetLastError();
}
if (type == SCS_32BIT_BINARY) GetSystemWow64DirectoryW( system_dir, MAX_PATH );
}
len = strlenW( system_dir ) + sizeof(winedeviceW)/sizeof(WCHAR) + strlenW(service_entry->name);
HeapFree( GetProcessHeap(), 0, path );
if (!(path = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
{
service_unlock(service_entry);
return ERROR_NOT_ENOUGH_SERVER_MEMORY;
}
lstrcpyW( path, system_dir );
lstrcatW( path, winedeviceW );
lstrcatW( path, service_entry->name );
}
ZeroMemory(&si, sizeof(STARTUPINFOW));
si.cb = sizeof(STARTUPINFOW);
if (!(service_entry->config.dwServiceType & SERVICE_INTERACTIVE_PROCESS))
{
static WCHAR desktopW[] = {'_','_','w','i','n','e','s','e','r','v','i','c','e','_','w','i','n','s','t','a','t','i','o','n','\\','D','e','f','a','u','l','t',0};
si.lpDesktop = desktopW;
}
service_entry->status.dwCurrentState = SERVICE_START_PENDING;
service_unlock(service_entry);
r = CreateProcessW(NULL, path, NULL, NULL, FALSE, CREATE_UNICODE_ENVIRONMENT, env, NULL, &si, &pi);
HeapFree(GetProcessHeap(),0,path);
if (!r)
{
service_lock_exclusive(service_entry);
service_entry->status.dwCurrentState = SERVICE_STOPPED;
service_unlock(service_entry);
return GetLastError();
}
service_entry->status.dwProcessId = pi.dwProcessId;
service_entry->process = pi.hProcess;
*process = pi.hProcess;
CloseHandle( pi.hThread );
return ERROR_SUCCESS;
}
// need to provide the implementations in unicode for non-unicode
// builds linking with the unicode strmbase.lib
LPWSTR WINAPI lstrcpyWInternal(
LPWSTR lpString1,
LPCWSTR lpString2
) {
return lstrcpyW(lpString1, lpString2);
}
BOOL DeleteFolderWR(LPCWSTR szPath)
{
WIN32_FIND_DATAW findFileData;
HANDLE hFind = INVALID_HANDLE_VALUE;
DWORD dwError, dwAttrs;
BOOL bRes;
int nLength;
wchar_t cPath[MAX_PATH], cCurrentFile[MAX_PATH];
if (szPath == NULL) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (szPath[0] == L'\\' || szPath[0] == L'\0' || szPath[0] == L'.' || lstrcmpiW(szPath, L"..") == 0) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
dwAttrs = GetFileAttributesW(szPath);
if (dwAttrs == INVALID_FILE_ATTRIBUTES) {
return FALSE;
}
if (~dwAttrs & FILE_ATTRIBUTE_DIRECTORY) {
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
SetLastError(0);
bRes = RemoveDirectoryW(szPath);
if (bRes == TRUE)
return TRUE;
if (bRes == FALSE && GetLastError() != ERROR_DIR_NOT_EMPTY)
return FALSE;
nLength = lstrlenW(szPath);
if (nLength + lstrlenW(L"\\*.*") + 1> MAX_PATH)
return FALSE;
if (szPath[nLength - 1] == L'\\')
wsprintfW(cPath, L"%s*.*", szPath);
else
wsprintfW(cPath, L"%s\\*.*", szPath);
hFind = FindFirstFileW(cPath, &findFileData);
if (hFind == INVALID_HANDLE_VALUE)
return FALSE;
lstrcpyW(cPath, szPath);
if (cPath[nLength - 1] == L'\\')
cPath[nLength - 1] = L'\0';
do
{
if (lstrcmpiW(findFileData.cFileName, L".") == 0 || lstrcmpiW(findFileData.cFileName, L"..") == 0)
continue;
if (lstrlenW(cPath) + lstrlenW(L"\\") + lstrlenW(findFileData.cFileName) + 1 > MAX_PATH)
continue;
wsprintfW(cCurrentFile, L"%s\\%s", cPath, findFileData.cFileName);
if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
{
findFileData.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
SetFileAttributesW(cCurrentFile, findFileData.dwFileAttributes);
}
if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
bRes = RemoveDirectoryW(cCurrentFile);
else
bRes = DeleteFolderWR(cCurrentFile);
}
else
{
if ((findFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ||
(findFileData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM))
SetFileAttributesW(cCurrentFile, FILE_ATTRIBUTE_NORMAL);
DeleteFileW(cCurrentFile);
}
} while (FindNextFileW(hFind, &findFileData));
dwError = GetLastError();
if (hFind != INVALID_HANDLE_VALUE)
FindClose(hFind);
if (dwError != ERROR_NO_MORE_FILES)
return FALSE;
bRes = RemoveDirectoryW(szPath);
return bRes;
}
static HRESULT HttpProtocol_open_request(Protocol *prot, LPCWSTR url, DWORD request_flags,
HINTERNET internet_session, IInternetBindInfo *bind_info)
{
HttpProtocol *This = ASYNCPROTOCOL_THIS(prot);
LPWSTR addl_header = NULL, post_cookie = NULL, optional = NULL;
IServiceProvider *service_provider = NULL;
IHttpNegotiate2 *http_negotiate2 = NULL;
LPWSTR host, user, pass, path;
LPOLESTR accept_mimes[257];
URL_COMPONENTSW url_comp;
BYTE security_id[512];
DWORD len = 0;
ULONG num;
BOOL res, b;
HRESULT hres;
static const WCHAR wszBindVerb[BINDVERB_CUSTOM][5] =
{{'G','E','T',0},
{'P','O','S','T',0},
{'P','U','T',0}};
memset(&url_comp, 0, sizeof(url_comp));
url_comp.dwStructSize = sizeof(url_comp);
url_comp.dwSchemeLength = url_comp.dwHostNameLength = url_comp.dwUrlPathLength = url_comp.dwExtraInfoLength =
url_comp.dwUserNameLength = url_comp.dwPasswordLength = 1;
if (!InternetCrackUrlW(url, 0, 0, &url_comp))
return MK_E_SYNTAX;
if(!url_comp.nPort)
url_comp.nPort = This->https ? INTERNET_DEFAULT_HTTPS_PORT : INTERNET_DEFAULT_HTTP_PORT;
host = heap_strndupW(url_comp.lpszHostName, url_comp.dwHostNameLength);
user = heap_strndupW(url_comp.lpszUserName, url_comp.dwUserNameLength);
pass = heap_strndupW(url_comp.lpszPassword, url_comp.dwPasswordLength);
This->base.connection = InternetConnectW(internet_session, host, url_comp.nPort, user, pass,
INTERNET_SERVICE_HTTP, This->https ? INTERNET_FLAG_SECURE : 0, (DWORD_PTR)&This->base);
heap_free(pass);
heap_free(user);
heap_free(host);
if(!This->base.connection) {
WARN("InternetConnect failed: %d\n", GetLastError());
return INET_E_CANNOT_CONNECT;
}
num = sizeof(accept_mimes)/sizeof(accept_mimes[0])-1;
hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_ACCEPT_MIMES, accept_mimes, num, &num);
if(hres != S_OK) {
WARN("GetBindString BINDSTRING_ACCEPT_MIMES failed: %08x\n", hres);
return INET_E_NO_VALID_MEDIA;
}
accept_mimes[num] = 0;
path = heap_alloc((url_comp.dwUrlPathLength+url_comp.dwExtraInfoLength+1)*sizeof(WCHAR));
if(url_comp.dwUrlPathLength)
memcpy(path, url_comp.lpszUrlPath, url_comp.dwUrlPathLength*sizeof(WCHAR));
if(url_comp.dwExtraInfoLength)
memcpy(path+url_comp.dwUrlPathLength, url_comp.lpszExtraInfo, url_comp.dwExtraInfoLength*sizeof(WCHAR));
path[url_comp.dwUrlPathLength+url_comp.dwExtraInfoLength] = 0;
if(This->https)
request_flags |= INTERNET_FLAG_SECURE;
This->base.request = HttpOpenRequestW(This->base.connection,
This->base.bind_info.dwBindVerb < BINDVERB_CUSTOM
? wszBindVerb[This->base.bind_info.dwBindVerb] : This->base.bind_info.szCustomVerb,
path, NULL, NULL, (LPCWSTR *)accept_mimes, request_flags, (DWORD_PTR)&This->base);
heap_free(path);
while(num--)
CoTaskMemFree(accept_mimes[num]);
if (!This->base.request) {
WARN("HttpOpenRequest failed: %d\n", GetLastError());
return INET_E_RESOURCE_NOT_FOUND;
}
hres = IInternetProtocolSink_QueryInterface(This->base.protocol_sink, &IID_IServiceProvider,
(void **)&service_provider);
if (hres != S_OK) {
WARN("IInternetProtocolSink_QueryInterface IID_IServiceProvider failed: %08x\n", hres);
return hres;
}
hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
&IID_IHttpNegotiate, (void **)&This->http_negotiate);
if (hres != S_OK) {
WARN("IServiceProvider_QueryService IID_IHttpNegotiate failed: %08x\n", hres);
return hres;
}
hres = IHttpNegotiate_BeginningTransaction(This->http_negotiate, url, wszHeaders,
0, &addl_header);
if(hres != S_OK) {
WARN("IHttpNegotiate_BeginningTransaction failed: %08x\n", hres);
IServiceProvider_Release(service_provider);
return hres;
}
if(addl_header) {
int len_addl_header = strlenW(addl_header);
This->full_header = heap_alloc(len_addl_header*sizeof(WCHAR)+sizeof(wszHeaders));
lstrcpyW(This->full_header, addl_header);
lstrcpyW(&This->full_header[len_addl_header], wszHeaders);
CoTaskMemFree(addl_header);
}else {
This->full_header = (LPWSTR)wszHeaders;
}
hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
&IID_IHttpNegotiate2, (void **)&http_negotiate2);
IServiceProvider_Release(service_provider);
if(hres != S_OK) {
WARN("IServiceProvider_QueryService IID_IHttpNegotiate2 failed: %08x\n", hres);
/* No goto done as per native */
}else {
len = sizeof(security_id)/sizeof(security_id[0]);
hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, security_id, &len, 0);
IHttpNegotiate2_Release(http_negotiate2);
if (hres != S_OK)
WARN("IHttpNegotiate2_GetRootSecurityId failed: %08x\n", hres);
}
/* FIXME: Handle security_id. Native calls undocumented function IsHostInProxyBypassList. */
if(This->base.bind_info.dwBindVerb == BINDVERB_POST) {
num = 0;
hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_POST_COOKIE, &post_cookie, 1, &num);
if(hres == S_OK && num) {
if(!InternetSetOptionW(This->base.request, INTERNET_OPTION_SECONDARY_CACHE_KEY,
post_cookie, lstrlenW(post_cookie)))
WARN("InternetSetOption INTERNET_OPTION_SECONDARY_CACHE_KEY failed: %d\n", GetLastError());
CoTaskMemFree(post_cookie);
}
}
if(This->base.bind_info.dwBindVerb != BINDVERB_GET) {
/* Native does not use GlobalLock/GlobalUnlock, so we won't either */
if (This->base.bind_info.stgmedData.tymed != TYMED_HGLOBAL)
WARN("Expected This->base.bind_info.stgmedData.tymed to be TYMED_HGLOBAL, not %d\n",
This->base.bind_info.stgmedData.tymed);
else
optional = (LPWSTR)This->base.bind_info.stgmedData.u.hGlobal;
}
b = TRUE;
res = InternetSetOptionW(This->base.request, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b));
if(!res)
WARN("InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %08x\n", GetLastError());
res = HttpSendRequestW(This->base.request, This->full_header, lstrlenW(This->full_header),
optional, optional ? This->base.bind_info.cbstgmedData : 0);
if(!res && GetLastError() != ERROR_IO_PENDING) {
WARN("HttpSendRequest failed: %d\n", GetLastError());
return INET_E_DOWNLOAD_FAILURE;
}
return S_OK;
}
static void test_ntncdf(void)
{
NTSTATUS r;
HANDLE hdir, hEvent;
char buffer[0x1000];
DWORD fflags, filter = 0;
IO_STATUS_BLOCK iosb;
WCHAR path[MAX_PATH], subdir[MAX_PATH];
static const WCHAR szBoo[] = { '\\','b','o','o',0 };
static const WCHAR szHoo[] = { '\\','h','o','o',0 };
PFILE_NOTIFY_INFORMATION pfni;
r = GetTempPathW( MAX_PATH, path );
ok( r != 0, "temp path failed\n");
if (!r)
return;
lstrcatW( path, szBoo );
lstrcpyW( subdir, path );
lstrcatW( subdir, szHoo );
RemoveDirectoryW( subdir );
RemoveDirectoryW( path );
r = CreateDirectoryW(path, NULL);
ok( r == TRUE, "failed to create directory\n");
r = pNtNotifyChangeDirectoryFile(NULL,NULL,NULL,NULL,NULL,NULL,0,0,0);
ok(r==STATUS_ACCESS_VIOLATION, "should return access violation\n");
fflags = FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED;
hdir = CreateFileW(path, GENERIC_READ|SYNCHRONIZE, FILE_SHARE_READ, NULL,
OPEN_EXISTING, fflags, NULL);
ok( hdir != INVALID_HANDLE_VALUE, "failed to open directory\n");
hEvent = CreateEventA( NULL, 0, 0, NULL );
r = pNtNotifyChangeDirectoryFile(hdir,NULL,NULL,NULL,&iosb,NULL,0,0,0);
ok(r==STATUS_INVALID_PARAMETER, "should return invalid parameter\n");
r = pNtNotifyChangeDirectoryFile(hdir,hEvent,NULL,NULL,&iosb,NULL,0,0,0);
ok(r==STATUS_INVALID_PARAMETER, "should return invalid parameter\n");
filter = FILE_NOTIFY_CHANGE_FILE_NAME;
filter |= FILE_NOTIFY_CHANGE_DIR_NAME;
filter |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
filter |= FILE_NOTIFY_CHANGE_SIZE;
filter |= FILE_NOTIFY_CHANGE_LAST_WRITE;
filter |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
filter |= FILE_NOTIFY_CHANGE_CREATION;
filter |= FILE_NOTIFY_CHANGE_SECURITY;
U(iosb).Status = 1;
iosb.Information = 1;
r = pNtNotifyChangeDirectoryFile(hdir,hEvent,NULL,NULL,&iosb,buffer,sizeof buffer,-1,0);
ok(r==STATUS_INVALID_PARAMETER, "should return invalid parameter\n");
ok( U(iosb).Status == 1, "information wrong\n");
ok( iosb.Information == 1, "information wrong\n");
U(iosb).Status = 1;
iosb.Information = 0;
r = pNtNotifyChangeDirectoryFile(hdir,hEvent,NULL,NULL,&iosb,buffer,sizeof buffer,filter,0);
ok(r==STATUS_PENDING, "should return status pending\n");
r = WaitForSingleObject( hEvent, 0 );
ok( r == STATUS_TIMEOUT, "should timeout\n" );
r = WaitForSingleObject( hdir, 0 );
ok( r == STATUS_TIMEOUT, "should timeout\n" );
r = CreateDirectoryW( subdir, NULL );
ok( r == TRUE, "failed to create directory\n");
r = WaitForSingleObject( hdir, 0 );
ok( r == STATUS_TIMEOUT, "should timeout\n" );
r = WaitForSingleObject( hEvent, 0 );
ok( r == WAIT_OBJECT_0, "event should be ready\n" );
ok( U(iosb).Status == STATUS_SUCCESS, "information wrong\n");
ok( iosb.Information == 0x12, "information wrong\n");
pfni = (PFILE_NOTIFY_INFORMATION) buffer;
ok( pfni->NextEntryOffset == 0, "offset wrong\n" );
ok( pfni->Action == FILE_ACTION_ADDED, "action wrong\n" );
ok( pfni->FileNameLength == 6, "len wrong\n" );
ok( !memcmp(pfni->FileName,&szHoo[1],6), "name wrong\n" );
r = pNtNotifyChangeDirectoryFile(hdir,0,NULL,NULL,&iosb,buffer,sizeof buffer,0,0);
ok(r==STATUS_INVALID_PARAMETER, "should return invalid parameter\n");
r = pNtNotifyChangeDirectoryFile(hdir,hEvent,NULL,NULL,&iosb,buffer,sizeof buffer,0,0);
ok(r==STATUS_INVALID_PARAMETER, "should return invalid parameter\n");
filter = FILE_NOTIFY_CHANGE_SIZE;
U(iosb).Status = 1;
iosb.Information = 1;
r = pNtNotifyChangeDirectoryFile(hdir,0,NULL,NULL,&iosb,NULL,0,filter,0);
ok(r==STATUS_PENDING, "should status pending\n");
ok( U(iosb).Status == 1, "information wrong\n");
ok( iosb.Information == 1, "information wrong\n");
r = WaitForSingleObject( hdir, 0 );
ok( r == STATUS_TIMEOUT, "should timeout\n" );
r = RemoveDirectoryW( subdir );
ok( r == TRUE, "failed to remove directory\n");
r = WaitForSingleObject( hdir, 100 );
ok( r == WAIT_OBJECT_0, "should be ready\n" );
r = WaitForSingleObject( hdir, 100 );
ok( r == WAIT_OBJECT_0, "should be ready\n" );
ok( U(iosb).Status == STATUS_NOTIFY_ENUM_DIR, "information wrong\n");
ok( iosb.Information == 0, "information wrong\n");
CloseHandle(hdir);
CloseHandle(hEvent);
r = RemoveDirectoryW( path );
ok( r == TRUE, "failed to remove directory\n");
}
LONG CED6AsDecompiler::CreateDefinition(LPWSTR pszAsFile, LPSTR Buffer)
{
WCHAR szPath[MAX_PATH];
LPWSTR pszFileName;
lstrcpyW(szPath, pszAsFile);
pszFileName = findnamew(szPath);
if (pszFileName != szPath)
*pszFileName = 0;
lstrcpyW(pszFileName, WSTRING(NAME_DEFINITION_FILE));
if (IsPathExistsW(szPath))
return ASDECL_ERROR_SUCCESS;
LONG Status;
CFileDisk file;
ED6_AS_INSTRUCTION_MAP *pMap;
ED6_INSTRUCTION_PARAM_DESC *pDesc;
CHAR szParamLengthTable[] = { 'b', 's', 't', 'i' };
if (!file.Create(szPath))
return ASDECL_ERROR_CREATE_FILE;
WriteScr(
"@_DEFI 4\n"
"@_DEFF 4\n"
"@_IGNORECASE\n"
"\n"
);
pMap = g_InstructionMap;
for (ULONG Count = countof(g_InstructionMap); Count; ++pMap, --Count)
{
if (pMap->pszName != NULL)
{
WriteScr("@%s [%02X]\n", pMap->pszName, pMap->Instruction);
}
else
{
// WriteScr("@%s%X [%02X]\n", NAME_DEFAULT_INSTRUCTION_PREFIX, pMap->Instruction, pMap->Instruction);
}
pDesc = pMap->pParamDesc;
for (ULONG DescCount = pMap->DescCount; DescCount; pDesc++, --DescCount)
{
if (pDesc->pszDescription == NULL)
continue;
#if 0
if (pDesc->Length > 4)
{
PBYTE pbBuffer;
WriteScr(" @%s [", pDesc->pszDescription);
pbBuffer = (PBYTE)&pDesc->Value;
for (ULONG Length = pDesc->Length; ; )
{
WriteScr("%02X", *pbBuffer++);
if (--Length == 0)
break;
WriteScr(" ");
}
WriteScr("]\n");
}
else
#endif
{
WriteScr(
" @%s 0x%X:%c\n",
pDesc->pszDescription,
pDesc->Value,
szParamLengthTable[pDesc->Length - 1]
);
}
}
}
WriteScr("\n");
pMap = g_InstructionMap;
for (ULONG Count = countof(g_InstructionMap); Count; ++pMap, --Count)
{
WriteScr("@%s%X [%02X]\n", NAME_DEFAULT_INSTRUCTION_PREFIX, pMap->Instruction, pMap->Instruction);
}
return 0;
}
static void test_SQLGetPrivateProfileStringW(void)
{
static WCHAR testing[] = {'t','e','s','t','i','n','g',0};
static WCHAR wineodbc[] = {'w','i','n','e','o','d','b','c',0};
static WCHAR defaultval[] = {'d','e','f','a','u','l','t',0};
static WCHAR odbcini[] = {'O','D','B','C','.','I','N','I',0};
static WCHAR abcdini[] = {'a','b','c','d','.','I','N','I',0};
static WCHAR wine[] = {'w','i','n','e',0};
static WCHAR value[] = {'v','a','l','u','e',0};
static WCHAR empty[] = {0};
static WCHAR defaultX[] = {'d','e','f','a','u','l','t',0};
static WCHAR def[] = {'d','e','f',0};
static WCHAR value0[] = {'v','a','l','u','e','0','1','2','3','4','5','6','7','8','9',0};
static WCHAR testingvalue[] = {'t','e','s','t','i','n','g',0,'v','a','l','u','e',0};
int ret;
WCHAR buffer[256] = {0};
LONG reg_ret;
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(NULL, testing , defaultval, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, wine), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , defaultval, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, empty), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , NULL, buffer, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, empty), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 256, odbcini);
ok(ret == lstrlenW(defaultX), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, defaultX), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 4, odbcini);
ok(ret == lstrlenW(def), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, def), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 8, odbcini);
ok(ret == lstrlenW(defaultX), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, defaultX), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, NULL, 256, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 0, odbcini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, value), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLWritePrivateProfileString("wineodbc", "testing" , "value0123456789", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
if(ret)
{
HKEY hkey;
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 256, abcdini);
ok(ret == lstrlenW(value0), "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, value0), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, NULL, 0, abcdini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
ret = SQLGetPrivateProfileStringW(wineodbc, testing , defaultX, buffer, 7, abcdini);
ok(ret == 6, "SQLGetPrivateProfileStringW returned %d\n", ret);
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 10, abcdini);
ok(ret == lstrlenW(testing)+1, "SQLGetPrivateProfileStringW returned %d\n", ret);
ok(!lstrcmpW(buffer, testing), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
ret = SQLWritePrivateProfileString("wineodbc", "value" , "0", "abcd.ini");
ok(ret, "SQLWritePrivateProfileString failed\n");
lstrcpyW(buffer, wine);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 256, abcdini);
ok(ret == (lstrlenW(testing) + lstrlenW(value)+2), "SQLGetPrivateProfileStringW returned %d\n", ret);
if(ret == (lstrlenW(testing) + lstrlenW(value)+2))
{
ok(!memcmp(buffer, testingvalue, sizeof(testingvalue)),
"incorrect string '%s'\n", wine_dbgstr_wn(buffer, ret));
}
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 10, abcdini);
ok(ret == lstrlenW(testing)+1, "SQLGetPrivateProfileStringW returned %d\n", ret);
if(ret >= lstrlenW(testing)+1)
{
ok(!lstrcmpW(buffer, testing), "incorrect string '%s'\n", wine_dbgstr_w(buffer));
}
lstrcpyW(buffer, value);
ret = SQLGetPrivateProfileStringW(wineodbc, NULL , empty, buffer, 2, abcdini);
ok(ret == 0, "SQLGetPrivateProfileStringW returned %d\n", ret);
reg_ret = RegOpenKeyExW(HKEY_CURRENT_USER, abcd_key, 0, KEY_READ, &hkey);
ok(reg_ret == ERROR_SUCCESS, "RegOpenKeyExW failed\n");
if(reg_ret == ERROR_SUCCESS)
{
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcd_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
RegCloseKey(hkey);
}
/* Cleanup key */
reg_ret = RegDeleteKeyW(HKEY_CURRENT_USER, abcdini_key);
ok(reg_ret == ERROR_SUCCESS, "RegDeleteKeyW failed\n");
}
}
static NTSTATUS
TH32CreateSnapshotSectionInitialize(DWORD dwFlags,
DWORD th32ProcessID,
PRTL_DEBUG_INFORMATION HeapDebug,
PRTL_DEBUG_INFORMATION ModuleDebug,
PVOID ProcThrdInfo,
HANDLE *SectionHandle)
{
PSYSTEM_PROCESS_INFORMATION ProcessInfo;
LPHEAPLIST32 HeapListEntry;
LPMODULEENTRY32W ModuleListEntry;
LPPROCESSENTRY32W ProcessListEntry;
LPTHREADENTRY32 ThreadListEntry;
OBJECT_ATTRIBUTES ObjectAttributes;
LARGE_INTEGER SSize, SOffset;
HANDLE hSection;
PTH32SNAPSHOT Snapshot;
ULONG_PTR DataOffset;
SIZE_T ViewSize;
ULONG i, nProcesses = 0, nThreads = 0, nHeaps = 0, nModules = 0;
ULONG RequiredSnapshotSize = sizeof(TH32SNAPSHOT);
PRTL_PROCESS_HEAPS hi = NULL;
PRTL_PROCESS_MODULES mi = NULL;
NTSTATUS Status = STATUS_SUCCESS;
/*
* Determine the required size for the heap snapshot
*/
if(dwFlags & TH32CS_SNAPHEAPLIST)
{
hi = (PRTL_PROCESS_HEAPS)HeapDebug->Heaps;
nHeaps = hi->NumberOfHeaps;
RequiredSnapshotSize += nHeaps * sizeof(HEAPLIST32);
}
/*
* Determine the required size for the module snapshot
*/
if(dwFlags & TH32CS_SNAPMODULE)
{
mi = (PRTL_PROCESS_MODULES)ModuleDebug->Modules;
nModules = mi->NumberOfModules;
RequiredSnapshotSize += nModules * sizeof(MODULEENTRY32W);
}
/*
* Determine the required size for the processes and threads snapshot
*/
if(dwFlags & (TH32CS_SNAPPROCESS | TH32CS_SNAPTHREAD))
{
ULONG ProcOffset = 0;
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)ProcThrdInfo;
do
{
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)ProcessInfo + ProcOffset);
nProcesses++;
nThreads += ProcessInfo->NumberOfThreads;
ProcOffset = ProcessInfo->NextEntryOffset;
} while(ProcOffset != 0);
if(dwFlags & TH32CS_SNAPPROCESS)
{
RequiredSnapshotSize += nProcesses * sizeof(PROCESSENTRY32W);
}
if(dwFlags & TH32CS_SNAPTHREAD)
{
RequiredSnapshotSize += nThreads * sizeof(THREADENTRY32);
}
}
/*
* Create and map the section
*/
SSize.QuadPart = RequiredSnapshotSize;
InitializeObjectAttributes(&ObjectAttributes,
NULL,
((dwFlags & TH32CS_INHERIT) ? OBJ_INHERIT : 0),
NULL,
NULL);
Status = NtCreateSection(&hSection,
SECTION_ALL_ACCESS,
&ObjectAttributes,
&SSize,
PAGE_READWRITE,
SEC_COMMIT,
NULL);
if(!NT_SUCCESS(Status))
{
return Status;
}
SOffset.QuadPart = 0;
ViewSize = 0;
Snapshot = NULL;
Status = NtMapViewOfSection(hSection,
NtCurrentProcess(),
(PVOID*)&Snapshot,
0,
0,
&SOffset,
&ViewSize,
ViewShare,
0,
PAGE_READWRITE);
if(!NT_SUCCESS(Status))
{
NtClose(hSection);
return Status;
}
RtlZeroMemory(Snapshot, sizeof(TH32SNAPSHOT));
DataOffset = 0;
/*
* Initialize the section data and fill it with all the data we collected
*/
/* initialize the heap list */
if(dwFlags & TH32CS_SNAPHEAPLIST)
{
Snapshot->HeapListCount = nHeaps;
Snapshot->HeapListOffset = DataOffset;
HeapListEntry = (LPHEAPLIST32)OffsetToPtr(Snapshot, DataOffset);
for(i = 0; i < nHeaps; i++)
{
HeapListEntry->dwSize = sizeof(HEAPLIST32);
HeapListEntry->th32ProcessID = th32ProcessID;
HeapListEntry->th32HeapID = (ULONG_PTR)hi->Heaps[i].BaseAddress;
HeapListEntry->dwFlags = hi->Heaps[i].Flags;
HeapListEntry++;
}
DataOffset += hi->NumberOfHeaps * sizeof(HEAPLIST32);
}
/* initialize the module list */
if(dwFlags & TH32CS_SNAPMODULE)
{
Snapshot->ModuleListCount = nModules;
Snapshot->ModuleListOffset = DataOffset;
ModuleListEntry = (LPMODULEENTRY32W)OffsetToPtr(Snapshot, DataOffset);
for(i = 0; i < nModules; i++)
{
ModuleListEntry->dwSize = sizeof(MODULEENTRY32W);
ModuleListEntry->th32ModuleID = 1; /* no longer used, always set to one! */
ModuleListEntry->th32ProcessID = th32ProcessID;
ModuleListEntry->GlblcntUsage = mi->Modules[i].LoadCount;
ModuleListEntry->ProccntUsage = mi->Modules[i].LoadCount;
ModuleListEntry->modBaseAddr = (BYTE*)mi->Modules[i].ImageBase;
ModuleListEntry->modBaseSize = mi->Modules[i].ImageSize;
ModuleListEntry->hModule = (HMODULE)mi->Modules[i].ImageBase;
MultiByteToWideChar(CP_ACP,
0,
&mi->Modules[i].FullPathName[mi->Modules[i].OffsetToFileName],
-1,
ModuleListEntry->szModule,
sizeof(ModuleListEntry->szModule) / sizeof(ModuleListEntry->szModule[0]));
MultiByteToWideChar(CP_ACP,
0,
mi->Modules[i].FullPathName,
-1,
ModuleListEntry->szExePath,
sizeof(ModuleListEntry->szExePath) / sizeof(ModuleListEntry->szExePath[0]));
ModuleListEntry++;
}
DataOffset += mi->NumberOfModules * sizeof(MODULEENTRY32W);
}
/* initialize the process list */
if(dwFlags & TH32CS_SNAPPROCESS)
{
ULONG ProcOffset = 0;
Snapshot->ProcessListCount = nProcesses;
Snapshot->ProcessListOffset = DataOffset;
ProcessListEntry = (LPPROCESSENTRY32W)OffsetToPtr(Snapshot, DataOffset);
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)ProcThrdInfo;
do
{
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)ProcessInfo + ProcOffset);
ProcessListEntry->dwSize = sizeof(PROCESSENTRY32W);
ProcessListEntry->cntUsage = 0; /* no longer used */
ProcessListEntry->th32ProcessID = (ULONG_PTR)ProcessInfo->UniqueProcessId;
ProcessListEntry->th32DefaultHeapID = 0; /* no longer used */
ProcessListEntry->th32ModuleID = 0; /* no longer used */
ProcessListEntry->cntThreads = ProcessInfo->NumberOfThreads;
ProcessListEntry->th32ParentProcessID = (ULONG_PTR)ProcessInfo->InheritedFromUniqueProcessId;
ProcessListEntry->pcPriClassBase = ProcessInfo->BasePriority;
ProcessListEntry->dwFlags = 0; /* no longer used */
if(ProcessInfo->ImageName.Buffer != NULL)
{
lstrcpynW(ProcessListEntry->szExeFile,
ProcessInfo->ImageName.Buffer,
min(ProcessInfo->ImageName.Length / sizeof(WCHAR), sizeof(ProcessListEntry->szExeFile) / sizeof(ProcessListEntry->szExeFile[0])));
}
else
{
lstrcpyW(ProcessListEntry->szExeFile, L"[System Process]");
}
ProcessListEntry++;
ProcOffset = ProcessInfo->NextEntryOffset;
} while(ProcOffset != 0);
DataOffset += nProcesses * sizeof(PROCESSENTRY32W);
}
/* initialize the thread list */
if(dwFlags & TH32CS_SNAPTHREAD)
{
ULONG ProcOffset = 0;
Snapshot->ThreadListCount = nThreads;
Snapshot->ThreadListOffset = DataOffset;
ThreadListEntry = (LPTHREADENTRY32)OffsetToPtr(Snapshot, DataOffset);
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)ProcThrdInfo;
do
{
PSYSTEM_THREAD_INFORMATION ThreadInfo;
ULONG n;
ProcessInfo = (PSYSTEM_PROCESS_INFORMATION)((ULONG_PTR)ProcessInfo + ProcOffset);
ThreadInfo = (PSYSTEM_THREAD_INFORMATION)(ProcessInfo + 1);
for(n = 0; n < ProcessInfo->NumberOfThreads; n++)
{
ThreadListEntry->dwSize = sizeof(THREADENTRY32);
ThreadListEntry->cntUsage = 0; /* no longer used */
ThreadListEntry->th32ThreadID = (ULONG_PTR)ThreadInfo->ClientId.UniqueThread;
ThreadListEntry->th32OwnerProcessID = (ULONG_PTR)ThreadInfo->ClientId.UniqueProcess;
ThreadListEntry->tpBasePri = ThreadInfo->BasePriority;
ThreadListEntry->tpDeltaPri = 0; /* no longer used */
ThreadListEntry->dwFlags = 0; /* no longer used */
ThreadInfo++;
ThreadListEntry++;
}
ProcOffset = ProcessInfo->NextEntryOffset;
} while(ProcOffset != 0);
}
/*
* We're done, unmap the view and return the section handle
*/
Status = NtUnmapViewOfSection(NtCurrentProcess(), (PVOID)Snapshot);
if(NT_SUCCESS(Status))
{
*SectionHandle = hSection;
}
else
{
NtClose(hSection);
}
return Status;
}
NTSTATUS HID_LinkDevice(DEVICE_OBJECT *device)
{
WCHAR dev_link[255];
WCHAR *ptr;
SP_DEVINFO_DATA Data;
UNICODE_STRING nameW, linkW;
NTSTATUS status;
HDEVINFO devinfo;
GUID hidGuid;
BASE_DEVICE_EXTENSION *ext;
HidD_GetHidGuid(&hidGuid);
ext = device->DeviceExtension;
sprintfW(dev_link, device_link_fmtW, ext->instance_id, class_guid);
ptr = dev_link + 4;
do { if (*ptr == '\\') *ptr = '#'; } while (*ptr++);
struprW(dev_link);
RtlInitUnicodeString( &nameW, ext->device_name);
RtlInitUnicodeString( &linkW, dev_link );
TRACE("Create link %s\n", debugstr_w(dev_link));
ext->link_name = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * (lstrlenW(dev_link) + 1));
lstrcpyW(ext->link_name, dev_link);
status = IoCreateSymbolicLink( &linkW, &nameW );
if (status)
{
FIXME( "failed to create link error %x\n", status );
return status;
}
devinfo = SetupDiGetClassDevsW(&GUID_DEVCLASS_HIDCLASS, NULL, NULL, DIGCF_DEVICEINTERFACE);
if (!devinfo)
{
FIXME( "failed to get ClassDevs %x\n", GetLastError());
return GetLastError();
}
Data.cbSize = sizeof(Data);
if (!SetupDiCreateDeviceInfoW(devinfo, ext->instance_id, &GUID_DEVCLASS_HIDCLASS, NULL, NULL, DICD_INHERIT_CLASSDRVS, &Data))
{
if (GetLastError() == ERROR_DEVINST_ALREADY_EXISTS)
{
SetupDiDestroyDeviceInfoList(devinfo);
return ERROR_SUCCESS;
}
FIXME( "failed to Create Device Info %x\n", GetLastError());
return GetLastError();
}
if (!SetupDiRegisterDeviceInfo( devinfo, &Data, 0, NULL, NULL, NULL ))
{
FIXME( "failed to Register Device Info %x\n", GetLastError());
return GetLastError();
}
if (!SetupDiCreateDeviceInterfaceW( devinfo, &Data, &hidGuid, NULL, 0, NULL))
{
FIXME( "failed to Create Device Interface %x\n", GetLastError());
return GetLastError();
}
SetupDiDestroyDeviceInfoList(devinfo);
return S_OK;
}
// Sets the console font properties.
void SetFontProperties(int fontX, int fontY, wchar_t *fontName)
{
HANDLE hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
/* Retrieving pointers for Windows Vista/7 Functions */
PGetCurrentConsoleFontEx pGetCurrentConsoleFontEx = (PGetCurrentConsoleFontEx)
GetProcAddress(GetModuleHandle("kernel32.dll"), "GetCurrentConsoleFontEx");
PSetCurrentConsoleFontEx pSetCurrentConsoleFontEx = (PSetCurrentConsoleFontEx)
GetProcAddress(GetModuleHandle("kernel32.dll"), "SetCurrentConsoleFontEx");
/* Check for pointers: if they exist, we have Vista/7 and we can use them */
if (pGetCurrentConsoleFontEx && pSetCurrentConsoleFontEx)
{
CONSOLE_FONT_INFOEX cfi = { sizeof(CONSOLE_FONT_INFOEX) };
/* Tell the font info how big it is, to avoid memory corruption */
cfi.cbSize = sizeof(CONSOLE_FONT_INFOEX);
pGetCurrentConsoleFontEx(hOutput, TRUE, &cfi);
/* Set the font type to name indicated by wide string literal */
/* Set to 0 to keep current settings */
lstrcpyW(cfi.FaceName, fontName);
cfi.dwFontSize.X = fontX;
cfi.dwFontSize.Y = fontY;
cfi.FontFamily = 0; /* Set to 0x30 for Terminal font */
cfi.FontWeight = 0;
/* Set the console font info */
pSetCurrentConsoleFontEx(hOutput, TRUE, &cfi);
}
else /* We don't have access to the vista functions */
{
CONSOLE_INFO2 ci = { sizeof(ci) };
HWND hwndConsole = GetConsoleWindow();
GetConsoleSizeInfo(&ci, hOutput);
/* Set to 0 to keep current settings */
ci.FontSize.X = fontX;
ci.FontSize.Y = fontY;
ci.FontFamily = 0; /* Set to 0x30 for Terminal font */
ci.FontWeight = 0;
lstrcpyW(ci.FaceName, fontName);
ci.CursorSize = 100;
ci.FullScreen = FALSE;
ci.QuickEdit = FALSE;
ci.AutoPosition = 0x10000;
ci.InsertMode = TRUE;
ci.ScreenColors = MAKEWORD(0x7, 0x0);
ci.PopupColors = MAKEWORD(0x5, 0xf);
ci.HistoryNoDup = TRUE;
ci.HistoryBufferSize = 50;
ci.NumberOfHistoryBuffers = 4;
ci.CodePage = 0;
ci.Hwnd = hwndConsole;
lstrcpyW(ci.ConsoleTitle, L"");
SetConsoleInfo(hwndConsole, &ci);
}
}
/***********************************************************************
* msidbImportTables
*
* Takes a list of tables or '*' (for all) to import from text archive
* files in specified folder
*
* For each table, a file called <tablename>.idt is imported containing
* tab separated ASCII.
*
* Examples (note wildcard escape for *nix/bash):
* msidb -d <pathtomsi>.msi -f <workdir> -i \*
* msidb -d <pathtomsi>.msi -f <workdir> -i File Directory Binary
**********************************************************************/
static BOOL msidbImportTables(LPCWSTR dbfile, LPCWSTR wdir, LPWSTR tables[], BOOL create)
{
static const WCHAR ext[] = {'.', 'i', 'd', 't', 0};
static const WCHAR all[] = {'*', 0};
UINT r, len;
char *dirNameA;
char *fileName;
DIR *dir;
struct dirent *ent;
int i = 0;
MSIHANDLE dbhandle;
LPWSTR tableFile = 0;
LPCWSTR oFlag = (LPCWSTR) MSIDBOPEN_TRANSACT;
if (create == TRUE) oFlag = (LPCWSTR) MSIDBOPEN_CREATE;
r = MsiOpenDatabaseW(dbfile, oFlag, &dbhandle);
if (r != ERROR_SUCCESS)
{
return FALSE;
}
if (strcmpW(tables[0], all) == 0)
{
dirNameA = strdupWtoA(CP_ACP, wdir);
dir = opendir(dirNameA);
if (dir)
{
while ((ent = readdir(dir)) != NULL)
{
if (ent->d_type != DT_REG) continue;
fileName = ent->d_name;
if (strcmp(fileName+strlen(fileName)-4*sizeof(fileName[0]), ".idt") != 0) continue;
if (strcmp(fileName, ".") == 0 || strcmp(fileName, "..") == 0) continue;
tableFile = strdupAtoW(CP_ACP, fileName);
r = MsiDatabaseImportW(dbhandle, wdir, tableFile);
free(tableFile);
}
}
else
return FALSE;
closedir(dir);
free(dirNameA);
}
else
{
for (i = 0; i < MAX_TABLES && tables[i] != 0; ++i)
{
len = lstrlenW(tables[i]) + 5;
tableFile = malloc(len * sizeof (WCHAR));
if (tableFile == NULL) return FALSE;
lstrcpyW(tableFile, tables[i]);
lstrcatW(tableFile, ext);
r = MsiDatabaseImportW(dbhandle, wdir, tableFile);
free(tableFile);
if (r != ERROR_SUCCESS)
{
return FALSE;
}
}
}
MsiDatabaseCommit(dbhandle);
MsiCloseHandle(dbhandle);
return TRUE;
}
static HRESULT WINAPI IAssemblyNameImpl_GetDisplayName(IAssemblyName *iface,
LPOLESTR szDisplayName,
LPDWORD pccDisplayName,
DWORD dwDisplayFlags)
{
IAssemblyNameImpl *name = (IAssemblyNameImpl *)iface;
WCHAR verstr[30];
DWORD size;
LPWSTR cultureval = 0;
static const WCHAR equals[] = {'=',0};
TRACE("(%p, %p, %p, %d)\n", iface, szDisplayName,
pccDisplayName, dwDisplayFlags);
if (dwDisplayFlags == 0)
{
if (!name->displayname || !*name->displayname)
return FUSION_E_INVALID_NAME;
size = min(*pccDisplayName, lstrlenW(name->displayname) + 1);
lstrcpynW(szDisplayName, name->displayname, size);
*pccDisplayName = size;
return S_OK;
}
if (!name->name || !*name->name)
return FUSION_E_INVALID_NAME;
/* Verify buffer size is sufficient */
size = lstrlenW(name->name) + 1;
if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
{
static const WCHAR spec[] = {'%','d',0};
static const WCHAR period[] = {'.',0};
int i;
wsprintfW(verstr, spec, name->version[0]);
for (i = 1; i < name->versize; i++)
{
WCHAR value[6];
wsprintfW(value, spec, name->version[i]);
lstrcatW(verstr, period);
lstrcatW(verstr, value);
}
size += lstrlenW(separator) + lstrlenW(version) + lstrlenW(equals) + lstrlenW(verstr);
}
if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
{
static const WCHAR neutral[] = {'n','e','u','t','r','a','l', 0};
cultureval = (lstrlenW(name->culture) == 2) ? name->culture : (LPWSTR) neutral;
size += lstrlenW(separator) + lstrlenW(culture) + lstrlenW(equals) + lstrlenW(cultureval);
}
if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
size += lstrlenW(separator) + lstrlenW(pubkey) + lstrlenW(equals) + CHARS_PER_PUBKEY;
if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
size += lstrlenW(separator) + lstrlenW(procarch) + lstrlenW(equals) + lstrlenW(name->procarch);
if (size > *pccDisplayName)
return S_FALSE;
/* Construct the string */
lstrcpyW(szDisplayName, name->name);
if ((dwDisplayFlags & ASM_DISPLAYF_VERSION) && (name->versize > 0))
{
lstrcatW(szDisplayName, separator);
lstrcatW(szDisplayName, version);
lstrcatW(szDisplayName, equals);
lstrcatW(szDisplayName, verstr);
}
if ((dwDisplayFlags & ASM_DISPLAYF_CULTURE) && (name->culture))
{
lstrcatW(szDisplayName, separator);
lstrcatW(szDisplayName, culture);
lstrcatW(szDisplayName, equals);
lstrcatW(szDisplayName, cultureval);
}
if ((dwDisplayFlags & ASM_DISPLAYF_PUBLIC_KEY_TOKEN) && (name->haspubkey))
{
WCHAR pkt[CHARS_PER_PUBKEY + 1];
static const WCHAR spec[] = {'%','0','x','%','0','x','%','0','x',
'%','0','x','%','0','x','%','0','x','%','0','x','%','0','x',0};
lstrcatW(szDisplayName, separator);
lstrcatW(szDisplayName, pubkey);
lstrcatW(szDisplayName, equals);
wsprintfW(pkt, spec, name->pubkey[0], name->pubkey[1], name->pubkey[2],
name->pubkey[3], name->pubkey[4], name->pubkey[5], name->pubkey[6],
name->pubkey[7]);
lstrcatW(szDisplayName, pkt);
}
if ((dwDisplayFlags & ASM_DISPLAYF_PROCESSORARCHITECTURE) && (name->procarch))
{
lstrcatW(szDisplayName, separator);
lstrcatW(szDisplayName, procarch);
lstrcatW(szDisplayName, equals);
lstrcatW(szDisplayName, name->procarch);
}
*pccDisplayName = size;
return S_OK;
}
/***********************************************************************
* msidbExportTables
*
* Takes a list of tables or '*' (for all) to export to text archive
* files in specified folder
*
* For each table, a file called <tablename>.idt is exported containing
* tab separated ASCII.
*
* Examples (note wildcard escape for *nix/bash):
* msidb -d <pathtomsi>.msi -f <workdir> -e \*
* msidb -d <pathtomsi>.msi -f <workdir> -e File Directory Binary
**********************************************************************/
static BOOL msidbExportTables(LPCWSTR dbfile, LPCWSTR wdir, LPWSTR tables[])
{
static const WCHAR ext[] = {'.', 'i', 'd', 't', 0};
static const WCHAR all[] = {'*', 0};
UINT r, len;
MSIHANDLE dbhandle, tableListView, rec;
LPWSTR tableFile = 0;
WCHAR tableName[MAX_TABLE_NAME];
DWORD size = sizeof(tableName) / sizeof(tableName[0]);
int i = 0;
r = MsiOpenDatabaseW(dbfile, (LPCWSTR) MSIDBOPEN_READONLY, &dbhandle);
if (r != ERROR_SUCCESS) return FALSE;
if (strcmpW(tables[0], all) == 0)
{
r = MsiDatabaseOpenView(dbhandle, "SELECT Name FROM _Tables", &tableListView);
r = MsiViewExecute(tableListView, 0);
r = MsiViewFetch(tableListView, &rec);
while (r == ERROR_SUCCESS)
{
size = sizeof(tableName) / sizeof(tableName[0]);
r = MsiRecordGetStringW(rec, 1, tableName, &size);
if (r == ERROR_SUCCESS)
{
len = lstrlenW(tableName) + 5;
tableFile = malloc(len * sizeof (WCHAR));
if (tableFile == NULL) return FALSE;
lstrcpyW(tableFile, tableName);
lstrcatW(tableFile, ext);
r = MsiDatabaseExportW(dbhandle, tableName, wdir, tableFile);
free(tableFile);
MsiCloseHandle(rec);
}
r = MsiViewFetch(tableListView, &rec);
}
MsiViewClose(tableListView);
MsiCloseHandle(tableListView);
}
else
{
for (i = 0; i < MAX_TABLES && tables[i] != 0; ++i)
{
len = lstrlenW(tables[i]) + 5;
tableFile = malloc(len * sizeof (WCHAR));
if (tableFile == NULL) return FALSE;
lstrcpyW(tableFile, tables[i]);
lstrcatW(tableFile, ext);
r = MsiDatabaseExportW(dbhandle, tables[i], wdir, tableFile);
free(tableFile);
}
}
MsiCloseHandle(dbhandle);
return TRUE;
}
static HRESULT WINAPI MMDevEnum_GetDefaultAudioEndpoint(IMMDeviceEnumerator *iface, EDataFlow flow, ERole role, IMMDevice **device)
{
MMDevEnumImpl *This = impl_from_IMMDeviceEnumerator(iface);
WCHAR reg_key[256];
HKEY key;
HRESULT hr;
TRACE("(%p)->(%u,%u,%p)\n", This, flow, role, device);
if (!device)
return E_POINTER;
if((flow != eRender && flow != eCapture) ||
(role != eConsole && role != eMultimedia && role != eCommunications)){
WARN("Unknown flow (%u) or role (%u)\n", flow, role);
return E_INVALIDARG;
}
*device = NULL;
if(!drvs.module_name[0])
return E_NOTFOUND;
lstrcpyW(reg_key, drv_keyW);
lstrcatW(reg_key, slashW);
lstrcatW(reg_key, drvs.module_name);
if(RegOpenKeyW(HKEY_CURRENT_USER, reg_key, &key) == ERROR_SUCCESS){
const WCHAR *reg_x_name, *reg_vx_name;
WCHAR def_id[256];
DWORD size = sizeof(def_id), state;
if(flow == eRender){
reg_x_name = reg_out_nameW;
reg_vx_name = reg_vout_nameW;
}else{
reg_x_name = reg_in_nameW;
reg_vx_name = reg_vin_nameW;
}
if(role == eCommunications &&
RegQueryValueExW(key, reg_vx_name, 0, NULL,
(BYTE*)def_id, &size) == ERROR_SUCCESS){
hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
if(SUCCEEDED(hr)){
if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
state == DEVICE_STATE_ACTIVE){
RegCloseKey(key);
return S_OK;
}
}
TRACE("Unable to find voice device %s\n", wine_dbgstr_w(def_id));
}
if(RegQueryValueExW(key, reg_x_name, 0, NULL,
(BYTE*)def_id, &size) == ERROR_SUCCESS){
hr = IMMDeviceEnumerator_GetDevice(iface, def_id, device);
if(SUCCEEDED(hr)){
if(SUCCEEDED(IMMDevice_GetState(*device, &state)) &&
state == DEVICE_STATE_ACTIVE){
RegCloseKey(key);
return S_OK;
}
}
TRACE("Unable to find device %s\n", wine_dbgstr_w(def_id));
}
RegCloseKey(key);
}
if (flow == eRender)
*device = &MMDevice_def_play->IMMDevice_iface;
else
*device = &MMDevice_def_rec->IMMDevice_iface;
if (!*device)
return E_NOTFOUND;
IMMDevice_AddRef(*device);
return S_OK;
}
/******************************************************************
* dump_modules
*
* Write in File the modules from pcs
*/
static unsigned dump_modules(struct dump_context* dc, BOOL dump_elf)
{
MINIDUMP_MODULE mdModule;
MINIDUMP_MODULE_LIST mdModuleList;
char tmp[1024];
MINIDUMP_STRING* ms = (MINIDUMP_STRING*)tmp;
ULONG i, nmod;
RVA rva_base;
DWORD flags_out;
unsigned sz;
for (i = nmod = 0; i < dc->num_modules; i++)
{
if ((dc->modules[i].is_elf && dump_elf) ||
(!dc->modules[i].is_elf && !dump_elf))
nmod++;
}
mdModuleList.NumberOfModules = 0;
/* reserve space for mdModuleList
* FIXME: since we don't support 0 length arrays, we cannot use the
* size of mdModuleList
* FIXME: if we don't ask for all modules in cb, we'll get a hole in the file
*/
/* the stream size is just the size of the module index. It does not include the data for the
names of each module. *Technically* the names are supposed to go into the common string table
in the minidump file. Since each string is referenced by RVA they can all safely be located
anywhere between streams in the file, so the end of this stream is sufficient. */
rva_base = dc->rva;
dc->rva += sz = sizeof(mdModuleList.NumberOfModules) + sizeof(mdModule) * nmod;
for (i = 0; i < dc->num_modules; i++)
{
if ((dc->modules[i].is_elf && !dump_elf) ||
(!dc->modules[i].is_elf && dump_elf))
continue;
flags_out = ModuleWriteModule | ModuleWriteMiscRecord | ModuleWriteCvRecord;
if (dc->type & MiniDumpWithDataSegs)
flags_out |= ModuleWriteDataSeg;
if (dc->type & MiniDumpWithProcessThreadData)
flags_out |= ModuleWriteTlsData;
if (dc->type & MiniDumpWithCodeSegs)
flags_out |= ModuleWriteCodeSegs;
ms->Length = (lstrlenW(dc->modules[i].name) + 1) * sizeof(WCHAR);
if (sizeof(ULONG) + ms->Length > sizeof(tmp))
FIXME("Buffer overflow!!!\n");
lstrcpyW(ms->Buffer, dc->modules[i].name);
if (dc->cb)
{
MINIDUMP_CALLBACK_INPUT cbin;
MINIDUMP_CALLBACK_OUTPUT cbout;
cbin.ProcessId = dc->pid;
cbin.ProcessHandle = dc->hProcess;
cbin.CallbackType = ModuleCallback;
cbin.u.Module.FullPath = ms->Buffer;
cbin.u.Module.BaseOfImage = dc->modules[i].base;
cbin.u.Module.SizeOfImage = dc->modules[i].size;
cbin.u.Module.CheckSum = dc->modules[i].checksum;
cbin.u.Module.TimeDateStamp = dc->modules[i].timestamp;
memset(&cbin.u.Module.VersionInfo, 0, sizeof(cbin.u.Module.VersionInfo));
cbin.u.Module.CvRecord = NULL;
cbin.u.Module.SizeOfCvRecord = 0;
cbin.u.Module.MiscRecord = NULL;
cbin.u.Module.SizeOfMiscRecord = 0;
cbout.u.ModuleWriteFlags = flags_out;
if (!dc->cb->CallbackRoutine(dc->cb->CallbackParam, &cbin, &cbout))
continue;
flags_out &= cbout.u.ModuleWriteFlags;
}
if (flags_out & ModuleWriteModule)
{
/* fetch CPU dependent module info (like UNWIND_INFO) */
dbghelp_current_cpu->fetch_minidump_module(dc, i, flags_out);
mdModule.BaseOfImage = dc->modules[i].base;
mdModule.SizeOfImage = dc->modules[i].size;
mdModule.CheckSum = dc->modules[i].checksum;
mdModule.TimeDateStamp = dc->modules[i].timestamp;
mdModule.ModuleNameRva = dc->rva;
ms->Length -= sizeof(WCHAR);
append(dc, ms, sizeof(ULONG) + ms->Length + sizeof(WCHAR));
fetch_module_versioninfo(ms->Buffer, &mdModule.VersionInfo);
mdModule.CvRecord.DataSize = 0; /* FIXME */
mdModule.CvRecord.Rva = 0; /* FIXME */
mdModule.MiscRecord.DataSize = 0; /* FIXME */
mdModule.MiscRecord.Rva = 0; /* FIXME */
mdModule.Reserved0 = 0; /* FIXME */
mdModule.Reserved1 = 0; /* FIXME */
writeat(dc,
rva_base + sizeof(mdModuleList.NumberOfModules) +
mdModuleList.NumberOfModules++ * sizeof(mdModule),
&mdModule, sizeof(mdModule));
}
}
writeat(dc, rva_base, &mdModuleList.NumberOfModules,
sizeof(mdModuleList.NumberOfModules));
return sz;
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file_name - name of a file to export registry branch to.
* reg_key_name - registry branch to export. The whole registry is exported if
* reg_key_name is NULL or contains an empty string.
*/
BOOL export_registry_key(WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
{
WCHAR *reg_key_name_buf;
WCHAR *val_name_buf;
BYTE *val_buf;
WCHAR *line_buf;
DWORD reg_key_name_size = KEY_MAX_LEN;
DWORD val_name_size = KEY_MAX_LEN;
DWORD val_size = REG_VAL_BUF_SIZE;
DWORD line_buf_size = KEY_MAX_LEN + REG_VAL_BUF_SIZE;
FILE *file = NULL;
BOOL unicode = (format == REG_FORMAT_5);
reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
reg_key_name_size * sizeof(*reg_key_name_buf));
val_name_buf = HeapAlloc(GetProcessHeap(), 0,
val_name_size * sizeof(*val_name_buf));
val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
if (reg_key_name && reg_key_name[0]) {
HKEY reg_key_class;
WCHAR *branch_name = NULL;
HKEY key;
REGPROC_resize_char_buffer(®_key_name_buf, ®_key_name_size,
lstrlenW(reg_key_name));
lstrcpyW(reg_key_name_buf, reg_key_name);
/* open the specified key */
if (!parseKeyName(reg_key_name, ®_key_class, &branch_name)) {
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
exit(1);
}
if (!branch_name[0]) {
/* no branch - registry class is specified */
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, reg_key_class,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
} else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, key,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
RegCloseKey(key);
} else {
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Can't export. Registry key '%s' does not exist!\n",
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
REGPROC_print_error();
}
} else {
unsigned int i;
/* export all registry classes */
file = REGPROC_open_export_file(file_name, unicode);
for (i = 0; i < REG_CLASS_NUMBER; i++) {
/* do not export HKEY_CLASSES_ROOT */
if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
reg_class_keys[i] != HKEY_DYN_DATA) {
lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
export_hkey(file, reg_class_keys[i],
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
}
}
}
if (file) {
fclose(file);
}
HeapFree(GetProcessHeap(), 0, reg_key_name);
HeapFree(GetProcessHeap(), 0, val_name_buf);
HeapFree(GetProcessHeap(), 0, val_buf);
HeapFree(GetProcessHeap(), 0, line_buf);
return TRUE;
}
/**************************************************************************
* DoOpenProperties
*/
static void DoOpenProperties(ItemCmImpl *This, HWND hwnd)
{
static const UINT MAX_PROP_PAGES = 99;
static const WCHAR wszFolder[] = {'F','o','l','d','e','r', 0};
static const WCHAR wszFiletypeAll[] = {'*',0};
LPSHELLFOLDER lpDesktopSF;
LPSHELLFOLDER lpSF;
LPDATAOBJECT lpDo;
WCHAR wszFiletype[MAX_PATH];
WCHAR wszFilename[MAX_PATH];
PROPSHEETHEADERW psh;
HPROPSHEETPAGE hpages[MAX_PROP_PAGES];
HPSXA hpsxa;
UINT ret;
TRACE("(%p)->(wnd=%p)\n", This, hwnd);
ZeroMemory(&psh, sizeof(PROPSHEETHEADERW));
psh.dwSize = sizeof (PROPSHEETHEADERW);
psh.hwndParent = hwnd;
psh.dwFlags = PSH_PROPTITLE;
psh.nPages = 0;
psh.u3.phpage = hpages;
psh.u2.nStartPage = 0;
_ILSimpleGetTextW(This->apidl[0], (LPVOID)&wszFilename, MAX_PATH);
psh.pszCaption = (LPCWSTR)&wszFilename;
/* Find out where to look for the shell extensions */
if (_ILIsValue(This->apidl[0]))
{
char sTemp[64];
sTemp[0] = 0;
if (_ILGetExtension(This->apidl[0], sTemp, 64))
{
HCR_MapTypeToValueA(sTemp, sTemp, 64, TRUE);
MultiByteToWideChar(CP_ACP, 0, sTemp, -1, wszFiletype, MAX_PATH);
}
else
{
wszFiletype[0] = 0;
}
}
else if (_ILIsFolder(This->apidl[0]))
{
lstrcpynW(wszFiletype, wszFolder, 64);
}
else if (_ILIsSpecialFolder(This->apidl[0]))
{
LPGUID folderGUID;
static const WCHAR wszclsid[] = {'C','L','S','I','D','\\', 0};
folderGUID = _ILGetGUIDPointer(This->apidl[0]);
lstrcpyW(wszFiletype, wszclsid);
StringFromGUID2(folderGUID, &wszFiletype[6], MAX_PATH - 6);
}
else
{
FIXME("Requested properties for unknown type.\n");
return;
}
/* Get a suitable DataObject for accessing the files */
SHGetDesktopFolder(&lpDesktopSF);
if (_ILIsPidlSimple(This->pidl))
{
ret = IShellFolder_GetUIObjectOf(lpDesktopSF, hwnd, This->cidl, (LPCITEMIDLIST*)This->apidl,
&IID_IDataObject, NULL, (LPVOID *)&lpDo);
IShellFolder_Release(lpDesktopSF);
}
else
{
IShellFolder_BindToObject(lpDesktopSF, This->pidl, NULL, &IID_IShellFolder, (LPVOID*) &lpSF);
ret = IShellFolder_GetUIObjectOf(lpSF, hwnd, This->cidl, (LPCITEMIDLIST*)This->apidl,
&IID_IDataObject, NULL, (LPVOID *)&lpDo);
IShellFolder_Release(lpSF);
IShellFolder_Release(lpDesktopSF);
}
if (SUCCEEDED(ret))
{
hpsxa = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszFiletype, MAX_PROP_PAGES - psh.nPages, lpDo);
if (hpsxa != NULL)
{
SHAddFromPropSheetExtArray(hpsxa, Properties_AddPropSheetCallback, (LPARAM)&psh);
SHDestroyPropSheetExtArray(hpsxa);
}
hpsxa = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszFiletypeAll, MAX_PROP_PAGES - psh.nPages, lpDo);
if (hpsxa != NULL)
{
SHAddFromPropSheetExtArray(hpsxa, Properties_AddPropSheetCallback, (LPARAM)&psh);
SHDestroyPropSheetExtArray(hpsxa);
}
IDataObject_Release(lpDo);
}
if (psh.nPages)
PropertySheetW(&psh);
else
FIXME("No property pages found.\n");
}
static HRESULT WINAPI IPersistFile_fnLoad(IPersistFile *iface, LPCOLESTR pszFileName, DWORD dwMode)
{
IAVIFileImpl *This = impl_from_IPersistFile(iface);
WCHAR wszStreamFmt[50];
INT len;
TRACE("(%p,%s,0x%08X)\n", iface, debugstr_w(pszFileName), dwMode);
/* check parameter */
if (pszFileName == NULL)
return AVIERR_BADPARAM;
if (This->hmmio != NULL)
return AVIERR_ERROR; /* No reuse of this object for another file! */
/* remember mode and name */
This->uMode = dwMode;
len = lstrlenW(pszFileName) + 1;
This->szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
if (This->szFileName == NULL)
return AVIERR_MEMORY;
lstrcpyW(This->szFileName, pszFileName);
/* try to open the file */
This->hmmio = mmioOpenW(This->szFileName, NULL, MMIO_ALLOCBUF | dwMode);
if (This->hmmio == NULL) {
/* mmioOpenW not in native DLLs of Win9x -- try mmioOpenA */
LPSTR szFileName;
len = WideCharToMultiByte(CP_ACP, 0, This->szFileName, -1,
NULL, 0, NULL, NULL);
szFileName = HeapAlloc(GetProcessHeap(), 0, len * sizeof(CHAR));
if (szFileName == NULL)
return AVIERR_MEMORY;
WideCharToMultiByte(CP_ACP, 0, This->szFileName, -1, szFileName,
len, NULL, NULL);
This->hmmio = mmioOpenA(szFileName, NULL, MMIO_ALLOCBUF | dwMode);
HeapFree(GetProcessHeap(), 0, szFileName);
if (This->hmmio == NULL)
return AVIERR_FILEOPEN;
}
memset(& This->fInfo, 0, sizeof(This->fInfo));
memset(& This->sInfo, 0, sizeof(This->sInfo));
LoadStringW(AVIFILE_hModule, IDS_WAVEFILETYPE, This->fInfo.szFileType,
sizeof(This->fInfo.szFileType)/sizeof(This->fInfo.szFileType[0]));
if (LoadStringW(AVIFILE_hModule, IDS_WAVESTREAMFORMAT,
wszStreamFmt, sizeof(wszStreamFmt)/sizeof(wszStreamFmt[0])) > 0) {
wsprintfW(This->sInfo.szName, wszStreamFmt,
AVIFILE_BasenameW(This->szFileName));
}
/* should we create a new file? */
if (dwMode & OF_CREATE) {
/* nothing more to do */
return AVIERR_OK;
} else
return AVIFILE_LoadFile(This);
}
HANDLE __stdcall DllInjectionW(PROCESS_INFORMATION *pi, //プロセスの情報
const wchar_t *szDllName)//Dllファイル名
{
HANDLE hProcess = pi->hProcess;
//dllファイルの絶対パスを保存する変数
TCHAR szLibFile[MAX_PATH];
//dllファイルの絶対パスの文字列の長さ + 1(\0までの長さを保存する)
int szLibFileLen;
//もし相対パスなら、
//自身の絶対パスの取得をして、dllまでの絶対パスを作る。
//(例 X:/-----/--.... というパスは、1バイト目が':'なので、絶対パスとなる。)
//絶対パスなら、そのままコピーするだけ。
if(szDllName[1] != ':'){
GetModuleFileName(NULL, szLibFile, sizeof(szLibFile));
lstrcpy(_tcsrchr(szLibFile, _TEXT('\\')) + 1, szDllName);
} else {
lstrcpyW(szLibFile,szDllName);
}
//長さ(使うメモリ領域)の計算
szLibFileLen = lstrlen(szLibFile) + 1;
szLibFileLen = szLibFileLen * sizeof(TCHAR);
//プロセス内にメモリ領域の確保
LPSTR RemoteProcessMemory;
RemoteProcessMemory = (LPSTR)VirtualAllocEx( hProcess, NULL, szLibFileLen, MEM_COMMIT, PAGE_READWRITE);
if(RemoteProcessMemory == NULL){
//setErrorString("プロセス内にメモリが確保できませんでした。");
return NULL;
}
//書き込み
if(WriteProcessMemory(hProcess, RemoteProcessMemory, (PVOID)szLibFile, szLibFileLen, NULL) == 0){
//setErrorString("プロセスに書き込みができませんでした。");
return NULL;
}
//LoadLibraryW関数が始まるポインタの取得
PTHREAD_START_ROUTINE pfnThreadRtn;
pfnThreadRtn = (PTHREAD_START_ROUTINE)GetProcAddress( GetModuleHandle(_TEXT("Kernel32")), "LoadLibraryW");
if (pfnThreadRtn == NULL){
//setErrorString("LoadLibraryが見つかりませんでした。(何故？)");
return NULL;
}
//スレッド作成
HANDLE hThread;
hThread = CreateRemoteThread(hProcess, NULL, 0, pfnThreadRtn, RemoteProcessMemory,CREATE_SUSPENDED, NULL);
if (hThread == NULL){
//setErrorString("スレッドが作れませんでした。");
return NULL;
}
//スレッド実行
ResumeThread(hThread);
BYTE *modulePointer = (BYTE *)WaitForSingleObject(hThread,INFINITE);
DWORD dwExitCode; //終了コード
GetExitCodeThread(hThread,&dwExitCode);
CloseHandle(hThread); //スレッドを閉じる
//プロセス内に確保したメモリの開放
VirtualFreeEx(hProcess,RemoteProcessMemory,260,MEM_DECOMMIT);
if(dwExitCode == NULL){
char a_szLibName[MAX_PATH];
BOOL bDummy;
WideCharToMultiByte(CP_ACP,0,szLibFile,-1,a_szLibName,MAX_PATH,"<不明なライブラリ>",&bDummy);
//setErrorStringEx("%s ---- DLLがロードできませんでした。",a_szLibName);
return NULL;
}
return (HANDLE)dwExitCode;
}
/*******************************************************************************
* GAMEUX_buildGameRegistryPath
*
* Internal helper function. Description available in gameux_private.h file
*/
HRESULT GAMEUX_buildGameRegistryPath(GAME_INSTALL_SCOPE installScope,
LPCGUID gameInstanceId,
LPWSTR* lpRegistryPath)
{
static const WCHAR sGameUxRegistryPath[] = {'S','O','F','T','W','A','R','E','\\',
'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\','G','a','m','e','U','X',0};
static const WCHAR sGames[] = {'G','a','m','e','s',0};
static const WCHAR sBackslash[] = {'\\',0};
HRESULT hr = S_OK;
HANDLE hToken = NULL;
PTOKEN_USER pTokenUser = NULL;
DWORD dwLength;
LPWSTR lpSID = NULL;
WCHAR sInstanceId[40];
WCHAR sRegistryPath[8192];
TRACE("(0x%x, %s, %p)\n", installScope, debugstr_guid(gameInstanceId), lpRegistryPath);
/* this will make freeing it easier for user */
*lpRegistryPath = NULL;
lstrcpyW(sRegistryPath, sGameUxRegistryPath);
lstrcatW(sRegistryPath, sBackslash);
if(installScope == GIS_CURRENT_USER)
{
/* build registry path containing user's SID */
if(!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &hToken))
hr = HRESULT_FROM_WIN32(GetLastError());
if(SUCCEEDED(hr))
{
if(!GetTokenInformation(hToken, TokenUser, NULL, 0, &dwLength) &&
GetLastError()!=ERROR_INSUFFICIENT_BUFFER)
hr = HRESULT_FROM_WIN32(GetLastError());
if(SUCCEEDED(hr))
{
pTokenUser = HeapAlloc(GetProcessHeap(), 0, dwLength);
if(!pTokenUser)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
if(!GetTokenInformation(hToken, TokenUser, (LPVOID)pTokenUser, dwLength, &dwLength))
hr = HRESULT_FROM_WIN32(GetLastError());
if(SUCCEEDED(hr))
if(!ConvertSidToStringSidW(pTokenUser->User.Sid, &lpSID))
hr = HRESULT_FROM_WIN32(GetLastError());
if(SUCCEEDED(hr))
{
lstrcatW(sRegistryPath, lpSID);
LocalFree(lpSID);
}
HeapFree(GetProcessHeap(), 0, pTokenUser);
CloseHandle(hToken);
}
}
else if(installScope == GIS_ALL_USERS)
/* build registry path without SID */
lstrcatW(sRegistryPath, sGames);
else
hr = E_INVALIDARG;
/* put game's instance id on the end of path, only if instance id was given */
if(gameInstanceId)
{
if(SUCCEEDED(hr))
hr = (StringFromGUID2(gameInstanceId, sInstanceId, sizeof(sInstanceId)/sizeof(sInstanceId[0])) ? S_OK : E_FAIL);
if(SUCCEEDED(hr))
{
lstrcatW(sRegistryPath, sBackslash);
lstrcatW(sRegistryPath, sInstanceId);
}
}
if(SUCCEEDED(hr))
{
*lpRegistryPath = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(sRegistryPath)+1)*sizeof(WCHAR));
if(!*lpRegistryPath)
hr = E_OUTOFMEMORY;
}
if(SUCCEEDED(hr))
lstrcpyW(*lpRegistryPath, sRegistryPath);
TRACE("result: 0x%x, path: %s\n", hr, debugstr_w(*lpRegistryPath));
return hr;
}
static void test_OleUIAddVerbMenu(void)
{
static const WCHAR cadabraW[] = {'c','a','d','a','b','r','a',0};
HMENU hMenu, verbmenu;
MENUITEMINFOW info;
WCHAR buffW[50];
int count;
BOOL ret;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, NULL, NULL, 0, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, NULL, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
hMenu = CreatePopupMenu();
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 0, 0, 0, FALSE, 0, NULL);
ok(!ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
ret = InsertMenuItemW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 1, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 2, "got %d\n", count);
/* object doesn't support EnumVerbs() */
g_enumverbsfail = TRUE;
g_enumpos = 0;
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 2, 0, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
g_enumverbsfail = FALSE;
/* added disabled item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_SUBMENU;
ret = GetMenuItemInfoW(hMenu, 2, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState & MFS_DISABLED, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 3, "got %d\n", count);
/* now without object */
verbmenu = (HMENU)0xdeadbeef;
ret = OleUIAddVerbMenuW(NULL, testW, hMenu, 3, 42, 0, FALSE, 0, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE|MIIM_ID|MIIM_STRING|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 3, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
ok(info.wID == 42, "got id %d\n", info.wID);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 4, "got %d\n", count);
verbmenu = (HMENU)0xdeadbeef;
g_enumpos = 0;
ret = OleUIAddVerbMenuW(&oleobject, NULL, hMenu, 4, 0, 0, FALSE, 0, &verbmenu);
ok(ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
/* check newly added item */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE|MIIM_SUBMENU;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 4, TRUE, &info);
ok(ret, "got %d\n", ret);
/* Item string contains verb, usertype and localized string for 'Object' word,
exact format depends on localization. */
ok(strstrW(buffW, verbW) != NULL, "str %s\n", wine_dbgstr_w(buffW));
ok(info.fState == 0, "got state 0x%08x\n", info.fState);
ok(info.hSubMenu == NULL, "got submenu %p\n", info.hSubMenu);
count = GetMenuItemCount(hMenu);
ok(count == 5, "got %d\n", count);
DestroyMenu(hMenu);
/* try to add verb menu repeatedly, with same id */
hMenu = CreatePopupMenu();
count = GetMenuItemCount(hMenu);
ok(count == 0, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* same position, different id */
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 6, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
/* change added item string and state */
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
info.fState = MFS_ENABLED;
info.dwTypeData = buffW;
lstrcpyW(buffW, cadabraW);
ret = SetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
buffW[0] = 0;
GetMenuStringW(hMenu, 0, buffW, sizeof(buffW)/sizeof(buffW[0]), MF_BYPOSITION);
ok(!lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
verbmenu = NULL;
ret = OleUIAddVerbMenuW(NULL, NULL, hMenu, 0, 5, 10, TRUE, 3, &verbmenu);
ok(!ret, "got %d\n", ret);
ok(verbmenu == NULL, "got %p\n", verbmenu);
memset(&info, 0, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STRING|MIIM_STATE;
buffW[0] = 0;
info.dwTypeData = buffW;
info.cch = sizeof(buffW)/sizeof(WCHAR);
ret = GetMenuItemInfoW(hMenu, 0, TRUE, &info);
ok(ret, "got %d\n", ret);
ok(lstrcmpW(buffW, cadabraW), "got %s\n", wine_dbgstr_w(buffW));
ok(info.fState == MF_GRAYED, "got state 0x%08x\n", info.fState);
count = GetMenuItemCount(hMenu);
ok(count == 1, "got %d\n", count);
DestroyMenu(hMenu);
}
static void testAcquireSecurityContext(void)
{
SECURITY_STATUS st;
CredHandle cred;
TimeStamp exp;
SCHANNEL_CRED schanCred;
PCCERT_CONTEXT certs[2];
HCRYPTPROV csp;
static CHAR unisp_name_a[] = UNISP_NAME_A;
WCHAR ms_def_prov_w[MAX_PATH];
BOOL ret;
HCRYPTKEY key;
CRYPT_KEY_PROV_INFO keyProvInfo;
if (!pAcquireCredentialsHandleA || !pCertCreateCertificateContext ||
!pFreeCredentialsHandle || !pCryptAcquireContextW)
{
skip("Needed functions are not available\n");
return;
}
lstrcpyW(ms_def_prov_w, MS_DEF_PROV_W);
keyProvInfo.pwszContainerName = cspNameW;
keyProvInfo.pwszProvName = ms_def_prov_w;
keyProvInfo.dwProvType = PROV_RSA_FULL;
keyProvInfo.dwFlags = 0;
keyProvInfo.cProvParam = 0;
keyProvInfo.rgProvParam = NULL;
keyProvInfo.dwKeySpec = AT_SIGNATURE;
certs[0] = pCertCreateCertificateContext(X509_ASN_ENCODING, bigCert,
sizeof(bigCert));
certs[1] = pCertCreateCertificateContext(X509_ASN_ENCODING, selfSignedCert,
sizeof(selfSignedCert));
pCryptAcquireContextW(&csp, cspNameW, MS_DEF_PROV_W, PROV_RSA_FULL,
CRYPT_DELETEKEYSET);
st = pAcquireCredentialsHandleA(NULL, NULL, 0, NULL, NULL, NULL, NULL, NULL,
NULL);
ok(st == SEC_E_SECPKG_NOT_FOUND,
"Expected SEC_E_SECPKG_NOT_FOUND, got %08x\n", st);
if (0)
{
/* Crashes on Win2K */
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, 0, NULL, NULL, NULL,
NULL, NULL, NULL);
ok(st == SEC_E_NO_CREDENTIALS, "Expected SEC_E_NO_CREDENTIALS, got %08x\n",
st);
}
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_BOTH, NULL,
NULL, NULL, NULL, NULL, NULL);
ok(st == SEC_E_NO_CREDENTIALS, "Expected SEC_E_NO_CREDENTIALS, got %08x\n",
st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, NULL, NULL, NULL, NULL, NULL);
ok(st == SEC_E_NO_CREDENTIALS, "Expected SEC_E_NO_CREDENTIALS, got %08x\n",
st);
if (0)
{
/* Crashes */
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, NULL, NULL, NULL, NULL, NULL);
}
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, NULL, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", st);
pFreeCredentialsHandle(&cred);
memset(&cred, 0, sizeof(cred));
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, NULL, NULL, NULL, &cred, &exp);
ok(st == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", st);
/* expriy is indeterminate in win2k3 */
trace("expiry: %08lx%08lx\n", exp.HighPart, exp.LowPart);
pFreeCredentialsHandle(&cred);
/* Bad version in SCHANNEL_CRED */
memset(&schanCred, 0, sizeof(schanCred));
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_INTERNAL_ERROR, "Expected SEC_E_INTERNAL_ERROR, got %08x\n",
st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_INTERNAL_ERROR, "Expected SEC_E_INTERNAL_ERROR, got %08x\n",
st);
/* No cert in SCHANNEL_CRED succeeds for outbound.. */
schanCred.dwVersion = SCHANNEL_CRED_VERSION;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", st);
pFreeCredentialsHandle(&cred);
/* but fails for inbound. */
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_NO_CREDENTIALS, "Expected SEC_E_NO_CREDENTIALS, got %08x\n",
st);
if (0)
{
/* Crashes with bad paCred pointer */
schanCred.cCreds = 1;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
}
/* Bogus cert in SCHANNEL_CRED. Windows fails with
* SEC_E_UNKNOWN_CREDENTIALS, but I'll accept SEC_E_NO_CREDENTIALS too.
*/
schanCred.cCreds = 1;
schanCred.paCred = &certs[0];
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS || SEC_E_NO_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS or SEC_E_NO_CREDENTIALS, got %08x\n",
st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS || SEC_E_NO_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS or SEC_E_NO_CREDENTIALS, got %08x\n",
st);
/* Good cert, but missing private key. Windows fails with
* SEC_E_NO_CREDENTIALS, but I'll accept SEC_E_UNKNOWN_CREDENTIALS too.
*/
schanCred.cCreds = 1;
schanCred.paCred = &certs[1];
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS || SEC_E_NO_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS or SEC_E_NO_CREDENTIALS, got %08x\n",
st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS || SEC_E_NO_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS or SEC_E_NO_CREDENTIALS, got %08x\n",
st);
/* Good cert, with CRYPT_KEY_PROV_INFO set before it's had a key loaded. */
if (pCertSetCertificateContextProperty)
{
ret = pCertSetCertificateContextProperty(certs[1],
CERT_KEY_PROV_INFO_PROP_ID, 0, &keyProvInfo);
schanCred.dwVersion = SCH_CRED_V3;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
}
ret = pCryptAcquireContextW(&csp, cspNameW, MS_DEF_PROV_W, PROV_RSA_FULL,
CRYPT_NEWKEYSET);
ok(ret, "CryptAcquireContextW failed: %08x\n", GetLastError());
ret = 0;
if (pCryptImportKey)
{
ret = pCryptImportKey(csp, privKey, sizeof(privKey), 0, 0, &key);
ok(ret, "CryptImportKey failed: %08x\n", GetLastError());
}
if (ret)
{
PCCERT_CONTEXT tmp;
if (0)
{
/* Crashes */
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, NULL, NULL);
}
/* Good cert with private key, bogus version */
schanCred.dwVersion = SCH_CRED_V1;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_INTERNAL_ERROR,
"Expected SEC_E_INTERNAL_ERROR, got %08x\n", st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_INTERNAL_ERROR,
"Expected SEC_E_INTERNAL_ERROR, got %08x\n", st);
schanCred.dwVersion = SCH_CRED_V2;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_INTERNAL_ERROR,
"Expected SEC_E_INTERNAL_ERROR, got %08x\n", st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_INTERNAL_ERROR,
"Expected SEC_E_INTERNAL_ERROR, got %08x\n", st);
/* Succeeds on V3 or higher */
schanCred.dwVersion = SCH_CRED_V3;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", st);
pFreeCredentialsHandle(&cred);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK ||
st == SEC_E_UNKNOWN_CREDENTIALS, /* win2k3 */
"AcquireCredentialsHandleA failed: %08x\n", st);
pFreeCredentialsHandle(&cred);
schanCred.dwVersion = SCHANNEL_CRED_VERSION;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK, "AcquireCredentialsHandleA failed: %08x\n", st);
pFreeCredentialsHandle(&cred);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_OK ||
st == SEC_E_UNKNOWN_CREDENTIALS, /* win2k3 */
"AcquireCredentialsHandleA failed: %08x\n", st);
if (st == SEC_E_OK) test_strength(&cred);
pFreeCredentialsHandle(&cred);
/* How about more than one cert? */
schanCred.cCreds = 2;
schanCred.paCred = certs;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
tmp = certs[0];
certs[0] = certs[1];
certs[1] = tmp;
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_OUTBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
st = pAcquireCredentialsHandleA(NULL, unisp_name_a, SECPKG_CRED_INBOUND,
NULL, &schanCred, NULL, NULL, &cred, NULL);
ok(st == SEC_E_UNKNOWN_CREDENTIALS,
"Expected SEC_E_UNKNOWN_CREDENTIALS, got %08x\n", st);
/* FIXME: what about two valid certs? */
if (pCryptDestroyKey)
pCryptDestroyKey(key);
}
if (pCryptReleaseContext)
pCryptReleaseContext(csp, 0);
pCryptAcquireContextW(&csp, cspNameW, MS_DEF_PROV_W, PROV_RSA_FULL,
CRYPT_DELETEKEYSET);
if (pCertFreeCertificateContext)
{
pCertFreeCertificateContext(certs[0]);
pCertFreeCertificateContext(certs[1]);
}
}
DWORD APIENTRY NPAddConnection3(HWND hwndOwner,
LPNETRESOURCEW lpNetResource, LPWSTR lpPassword, LPWSTR lpUserName, DWORD dwFlags)
{
DWORD NpResult;
PWSTR RemoteName = lpNetResource->lpRemoteName;
DWORD CredentialsKind;
WCHAR UserName[CREDUI_MAX_USERNAME_LENGTH + 1], Password[CREDUI_MAX_PASSWORD_LENGTH + 1];
#if defined(FSP_NP_CREDENTIAL_MANAGER)
BOOL Save = TRUE;
#endif
//dwFlags |= CONNECT_INTERACTIVE | CONNECT_PROMPT; /* TESTING ONLY! */
/* CONNECT_PROMPT is only valid if CONNECT_INTERACTIVE is also set */
if (CONNECT_PROMPT == (dwFlags & (CONNECT_INTERACTIVE | CONNECT_PROMPT)))
return WN_BAD_VALUE;
/* if not CONNECT_PROMPT go ahead and attempt to NPAddConnection once */
if (0 == (dwFlags & CONNECT_PROMPT))
{
NpResult = NPAddConnection(lpNetResource, lpPassword, lpUserName);
if (WN_ACCESS_DENIED != NpResult || 0 == (dwFlags & CONNECT_INTERACTIVE))
return NpResult;
}
FspNpGetCredentialsKind(RemoteName, &CredentialsKind);
if (FSP_NP_CREDENTIALS_NONE == CredentialsKind)
return WN_CANCEL;
/* if CONNECT_INTERACTIVE keep asking the user for valid credentials or cancel */
NpResult = WN_SUCCESS;
lstrcpyW(UserName, L"UNSPECIFIED");
Password[0] = L'\0';
if (FSP_NP_CREDENTIALS_PASSWORD == CredentialsKind)
FspNpParseUserName(RemoteName, UserName, sizeof UserName / sizeof UserName[0]);
do
{
NpResult = FspNpGetCredentials(
hwndOwner, RemoteName, NpResult,
CredentialsKind,
#if defined(FSP_NP_CREDENTIAL_MANAGER)
&Save,
#else
0,
#endif
UserName, sizeof UserName / sizeof UserName[0],
Password, sizeof Password / sizeof Password[0]);
if (WN_SUCCESS != NpResult)
break;
NpResult = NPAddConnection(lpNetResource, Password, UserName);
} while (WN_ACCESS_DENIED == NpResult);
#if defined(FSP_NP_CREDENTIAL_MANAGER)
if (WN_SUCCESS == NpResult && Save)
{
CREDENTIALW Credential;
memset(&Credential, 0, sizeof Credential);
Credential.Type = CRED_TYPE_GENERIC;
Credential.Persist = CRED_PERSIST_LOCAL_MACHINE;
Credential.TargetName = RemoteName;
Credential.UserName = UserName;
Credential.CredentialBlobSize = (lstrlenW(Password) + 1) * sizeof(WCHAR);
Credential.CredentialBlob = (PVOID)Password;
CredWriteW(&Credential, 0);
}
#endif
SecureZeroMemory(Password, sizeof Password);
return NpResult;
}