static LPSTR __apxStrnCatA(APXHANDLE hPool, LPSTR pOrg, LPCSTR szStr, LPCSTR szAdd)
{
DWORD len = 1;
DWORD nas = pOrg == NULL;
if (pOrg)
len += lstrlenA(pOrg);
if (szStr)
len += lstrlenA(szStr);
if (szAdd)
len += lstrlenA(szAdd);
pOrg = (LPSTR)apxPoolRealloc(hPool, pOrg, len);
if (pOrg) {
if (nas)
*pOrg = '\0';
if (szStr)
lstrcatA(pOrg, szStr);
if (szAdd)
lstrcatA(pOrg, szAdd);
}
return pOrg;
}
bool InitGlobalData(PHVNC lpServer)
{
bool ret_val=false;
do
{
lpServer->hGlobalVNCMapping=CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,sizeof(GLOBAL_VNC_DATA),lpServer->Names.szGlobalMappingName);
lpServer->lpGlobalVNCData=(GLOBAL_VNC_DATA *)MapViewOfFile(lpServer->hGlobalVNCMapping,FILE_MAP_ALL_ACCESS,0,0,0);
if ((!lpServer->lpGlobalVNCData) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->lpGlobalVNCData->dwVNCMessage=RegisterWindowMessageA(lpServer->DeskInfo.szDeskName);
if (!lpServer->lpGlobalVNCData->dwVNCMessage)
break;
lpServer->EventsInfo.hInputMutex=CreateMutex(NULL,false,lpServer->Names.szInputMutex);
if ((!lpServer->EventsInfo.hInputMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hPaintMutex=CreateMutex(NULL,false,NULL);
if (!lpServer->EventsInfo.hPaintMutex)
break;
lpServer->EventsInfo.hSharedMemMutex=CreateMutex(NULL,false,lpServer->Names.szSharedMemMutex);
if ((!lpServer->EventsInfo.hSharedMemMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageMutex=CreateMutex(NULL,false,lpServer->Names.szSendThreadMessageMutex);
if ((!lpServer->EventsInfo.hSendThreadMessageMutex) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hSendThreadMessageEvent=CreateEvent(NULL,true,false,lpServer->Names.szSendThreadMessageEvent);
if ((!lpServer->EventsInfo.hSendThreadMessageEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hVNCKillEvent=CreateEvent(NULL,true,false,lpServer->Names.szVNCKillEventName);
if ((!lpServer->EventsInfo.hVNCKillEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
lpServer->EventsInfo.hClipboardUpdatedEvent=CreateEvent(NULL,false,false,lpServer->Names.szClipboardUpdatedEvent);
if ((!lpServer->EventsInfo.hClipboardUpdatedEvent) || (GetLastError() == ERROR_ALREADY_EXISTS))
break;
if ((GetWindowsDirectoryA(lpServer->Names.szShell,sizeof(lpServer->Names.szShell))) || (GetEnvironmentVariableA("windir",lpServer->Names.szShell,sizeof(lpServer->Names.szShell))))
lstrcatA(lpServer->Names.szShell,"\\explorer.exe");
else
break;
ret_val=true;
}
while (false);
return ret_val;
}
char * SM_GetUsers(SESSION_INFO * si)
{
SESSION_INFO *pTemp = m_WndList;
int count = 0;
while (pTemp != NULL)
{
if (si && si == pTemp)
{
USERINFO * utemp = pTemp->pUsers;
if(utemp)
{
char * p = mmi.mmi_malloc(4096);
int alloced = 4096;
lstrcpyA(p, utemp->pszUID);
lstrcatA(p, " ");
utemp = utemp->next;
while(utemp)
{
if(lstrlenA(p) + lstrlenA(utemp->pszUID) > alloced - 10)
{
char *p2 = mmi.mmi_malloc(alloced + 4096);
lstrcpyA(p2, p);
mmi.mmi_free(p);
p = p2;
}
lstrcatA(p, utemp->pszUID);
lstrcatA(p, " ");
utemp = utemp->next;
}
return p;
}
return NULL;
}
pTemp = pTemp->next;
}
return NULL;
}
static INT_PTR CALLBACK WarnIniChangeDlgProc(HWND hwndDlg,UINT message,WPARAM wParam,LPARAM lParam)
{
static struct warnSettingChangeInfo_t *warnInfo;
switch(message) {
case WM_INITDIALOG:
{ char szSettingName[256];
const TCHAR *pszSecurityInfo;
warnInfo = (warnSettingChangeInfo_t*)lParam;
TranslateDialogDefault(hwndDlg);
SetDlgItemText(hwndDlg, IDC_ININAME, warnInfo->szIniPath);
lstrcpyA(szSettingName, warnInfo->szSection);
lstrcatA(szSettingName," / ");
lstrcatA(szSettingName,warnInfo->szName);
SetDlgItemTextA(hwndDlg,IDC_SETTINGNAME,szSettingName);
SetDlgItemTextA(hwndDlg,IDC_NEWVALUE,warnInfo->szValue);
if(IsInSpaceSeparatedList(warnInfo->szSection,warnInfo->szSafeSections))
pszSecurityInfo=LPGENT("This change is known to be safe.");
else if(IsInSpaceSeparatedList(warnInfo->szSection,warnInfo->szUnsafeSections))
pszSecurityInfo=LPGENT("This change is known to be potentially hazardous.");
else
pszSecurityInfo=LPGENT("This change is not known to be safe.");
SetDlgItemText(hwndDlg,IDC_SECURITYINFO,TranslateTS(pszSecurityInfo));
return TRUE;
}
case WM_COMMAND:
switch(LOWORD(wParam)) {
case IDCANCEL:
warnInfo->cancel=1;
case IDYES:
case IDNO:
warnInfo->warnNoMore=IsDlgButtonChecked(hwndDlg,IDC_WARNNOMORE);
EndDialog(hwndDlg,LOWORD(wParam));
break;
}
break;
}
return FALSE;
}
static void get_progfiles_dir(void)
{
HKEY hkey;
DWORD size = MAX_PATH;
RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion", &hkey);
RegQueryValueExA(hkey, "ProgramFilesDir", NULL, NULL, (LPBYTE)PROG_FILES_ROOT, &size);
RegCloseKey(hkey);
lstrcpyA(PROG_FILES, PROG_FILES_ROOT + 3); /* skip C:\ */
lstrcpyA(APP_PATH, PROG_FILES_ROOT);
lstrcatA(APP_PATH, TEST_STRING1);
APP_PATH_LEN = lstrlenA(APP_PATH) + 1;
}
void win_traceA(const char *pszFmt, ...){
CHAR tchbuf[1024] = {'$',0};
va_list argList = NULL;
va_start(argList, pszFmt);
wvsprintfA(&tchbuf[1], pszFmt, argList);
va_end(argList);
lstrcatA(tchbuf, "\r\n");
if(IsDebuggerPresent()){
OutputDebugStringA(tchbuf);
}else{
DWORD dwWrt;
WriteConsoleA(GetStdHandle(STD_ERROR_HANDLE), tchbuf, lstrlenA(tchbuf), &dwWrt, NULL);
}
}
static HRESULT WINAPI IShellExecuteHookA_fnExecute(IShellExecuteHookA *iface,
LPSHELLEXECUTEINFOA psei)
{
ICPanelImpl *This = impl_from_IShellExecuteHookA(iface);
SHELLEXECUTEINFOA sei_tmp;
PIDLCPanelStruct* pcpanel;
char path[MAX_PATH];
BOOL ret;
TRACE("(%p)->execute(%p)\n", This, psei);
if (!psei)
return E_INVALIDARG;
pcpanel = _ILGetCPanelPointer(ILFindLastID(psei->lpIDList));
if (!pcpanel)
return E_INVALIDARG;
path[0] = '\"';
lstrcpyA(path+1, pcpanel->szName);
/* pass applet name to Control_RunDLL to distinguish between applets in one .cpl file */
lstrcatA(path, "\" ");
lstrcatA(path, pcpanel->szName+pcpanel->offsDispName);
sei_tmp = *psei;
sei_tmp.lpFile = path;
sei_tmp.fMask &= ~SEE_MASK_INVOKEIDLIST;
ret = ShellExecuteExA(&sei_tmp);
if (ret)
return S_OK;
else
return S_FALSE;
}
static LPSTR __apxEvalPathPart(APXHANDLE hPool, LPSTR pStr, LPCSTR szPattern)
{
HANDLE hFind;
WIN32_FIND_DATAA stGlob;
char szJars[MAX_PATH + 1];
char szPath[MAX_PATH + 1];
if (lstrlenA(szPattern) > (sizeof(szJars) - 5)) {
return __apxStrnCatA(hPool, pStr, szPattern, NULL);
}
lstrcpyA(szJars, szPattern);
szPath[0] = ';';
szPath[1] = '\0';
lstrcatA(szPath, szPattern);
lstrcatA(szJars, ".jar");
/* Remove the trailing asterisk
*/
szPath[lstrlenA(szPath) - 1] = '\0';
if ((hFind = FindFirstFileA(szJars, &stGlob)) == INVALID_HANDLE_VALUE) {
/* Find failed
*/
return pStr;
}
pStr = __apxStrnCatA(hPool, pStr, &szPath[1], stGlob.cFileName);
if (pStr == NULL) {
FindClose(hFind);
return NULL;
}
while (FindNextFileA(hFind, &stGlob) != 0) {
pStr = __apxStrnCatA(hPool, pStr, szPath, stGlob.cFileName);
if (pStr == NULL)
break;
}
FindClose(hFind);
return pStr;
}
/***********************************************************************
* GetSystemDirectory (KERNEL.135)
*/
UINT16 WINAPI GetSystemDirectory16( LPSTR path, UINT16 count )
{
static const char * system16 = "\\SYSTEM";
char windir[MAX_PATH];
UINT16 len;
len = GetWindowsDirectory16(windir, sizeof(windir) - sizeof(system16)) + sizeof(system16);
if (count >= len)
{
lstrcpyA(path, windir);
lstrcatA(path, system16);
len--; /* space for the terminating zero is not included on success */
}
return len;
}
/*************************************************************************
* SHRestricted [SHELL32.100]
*
* Get the value associated with a policy Id.
*
* PARAMS
* pol [I] Policy Id
*
* RETURNS
* The queried value for the policy.
*
* NOTES
* Exported by ordinal.
* This function caches the retrieved values to prevent unnecessary registry access,
* if SHInitRestricted() was previously called.
*
* REFERENCES
* a: MS System Policy Editor.
* b: 98Lite 2.0 (which uses many of these policy keys) http://www.98lite.net/
* c: 'The Windows 95 Registry', by John Woram, 1996 MIS: Press
*/
DWORD WINAPI SHRestricted (RESTRICTIONS policy)
{
char regstr[256];
HKEY xhkey;
DWORD retval, datsize = 4;
LPPOLICYDATA p;
TRACE("(%08x)\n", policy);
/* scan to see if we know this policy ID */
for (p = sh32_policy_table; p->policy; p++)
{
if (policy == p->policy)
{
break;
}
}
if (p->policy == 0)
{
/* we don't know this policy, return 0 */
TRACE("unknown policy: (%08x)\n", policy);
return 0;
}
/* we have a known policy */
/* first check if this policy has been cached, return it if so */
if (p->cache != SHELL_NO_POLICY)
{
return p->cache;
}
lstrcpyA(regstr, strRegistryPolicyA);
lstrcatA(regstr, p->appstr);
/* return 0 and don't set the cache if any registry errors occur */
retval = 0;
if (RegOpenKeyA(HKEY_CURRENT_USER, regstr, &xhkey) == ERROR_SUCCESS)
{
if (RegQueryValueExA(xhkey, p->keystr, NULL, NULL, (LPBYTE)&retval, &datsize) == ERROR_SUCCESS)
{
p->cache = retval;
}
RegCloseKey(xhkey);
}
return retval;
}
void ipcGetSkinIcons(THeaderIPC *ipch)
{
TSlotProtoIcons spi;
char szTmp[64];
int protoCount;
PROTOACCOUNT **pp;
if ( CallService(MS_PROTO_ENUMACCOUNTS, WPARAM(&protoCount), LPARAM(&pp)) == 0 && protoCount != 0) {
spi.pid = GetCurrentProcessId();
while (protoCount > 0) {
PROTOACCOUNT *pa = *pp;
lstrcpyA(szTmp, pa->szModuleName);
lstrcatA(szTmp, PS_GETCAPS);
DWORD dwCaps = CallService(szTmp, PFLAGNUM_1, 0);
if (dwCaps & PF1_FILESEND) {
TSlotIPC *pct = ipcAlloc(ipch, sizeof(TSlotProtoIcons));
if (pct != NULL) {
// capture all the icons!
spi.hProto = murmur_hash(pa->szModuleName);
for (int j = 0; j <= 10; j++)
spi.hIcons[j] = LoadSkinnedProtoIcon(pa->szModuleName, ID_STATUS_OFFLINE + j);
pct->fType = REQUEST_NEWICONS;
memcpy(LPSTR(pct) + sizeof(TSlotIPC), &spi, sizeof(TSlotProtoIcons));
if (ipch->NewIconsBegin == NULL)
ipch->NewIconsBegin = pct;
}
}
pp++;
protoCount--;
}
}
// add Miranda icon
TSlotIPC *pct = ipcAlloc(ipch, sizeof(TSlotProtoIcons));
if (pct != NULL) {
ZeroMemory(&spi.hIcons, sizeof(spi.hIcons));
spi.hProto = 0; // no protocol
spi.hIcons[0] = LoadSkinnedIcon(SKINICON_OTHER_MIRANDA);
pct->fType = REQUEST_NEWICONS;
memcpy(LPSTR(pct) + sizeof(TSlotIPC), &spi, sizeof(TSlotProtoIcons));
if (ipch->NewIconsBegin == NULL)
ipch->NewIconsBegin = pct;
}
}
static void sttPreviewSkin(MODERNOPTOBJECT *obj, TCHAR *fn, LPDRAWITEMSTRUCT lps)
{
if (!fn) return;
char svc[128];
mir_snprintf(svc, SIZEOF(svc), "%s%s", obj->lpzThemeModuleName, TS_SKIN_PREVIEW);
if (ServiceExists(svc))
CallService(svc, (WPARAM)lps, (LPARAM)fn);
else {
char *afn = mir_t2a(fn);
char *fnpreview = (char *)mir_alloc(lstrlenA(afn) + 10);
lstrcpyA(fnpreview, afn);
lstrcatA(fnpreview, ".png");
HBITMAP hbmPreview = (HBITMAP)CallService(MS_UTILS_LOADBITMAP, 0, (LPARAM)fnpreview);
mir_free(afn);
mir_free(fnpreview);
if (!hbmPreview) return;
BITMAP bmp;
GetObject(hbmPreview, sizeof(bmp), &bmp);
SIZE szDst = { abs(bmp.bmWidth), abs(bmp.bmHeight) };
if ((szDst.cx > lps->rcItem.right-lps->rcItem.left) || (szDst.cy > lps->rcItem.bottom-lps->rcItem.top)) {
float q = min(
float(lps->rcItem.right-lps->rcItem.left) / szDst.cx,
float(lps->rcItem.bottom-lps->rcItem.top) / szDst.cy);
szDst.cx *= q;
szDst.cy *= q;
}
POINT ptDst = {
(lps->rcItem.left+lps->rcItem.right-szDst.cx) / 2,
(lps->rcItem.top+lps->rcItem.bottom-szDst.cy) / 2 };
HDC hdc = CreateCompatibleDC(lps->hDC);
SelectObject(hdc, hbmPreview);
SetStretchBltMode(hdc, HALFTONE);
StretchBlt(lps->hDC, ptDst.x, ptDst.y, szDst.cx, szDst.cy, hdc, 0, 0, abs(bmp.bmWidth), abs(bmp.bmHeight), SRCCOPY);
DeleteDC(hdc);
DeleteObject(hbmPreview);
}
}
static INT_PTR SendEMailCommand(WPARAM wParam,LPARAM lParam)
{
DBVARIANT dbv;
char *szUrl;
char *szProto;
szProto=(char*)CallService(MS_PROTO_GETCONTACTBASEPROTO,wParam,0);
if(szProto==NULL || DBGetContactSettingString((HANDLE)wParam,szProto,"e-mail",&dbv)) {
if(DBGetContactSettingString((HANDLE)wParam,"UserInfo","Mye-mail0",&dbv)) {
MessageBox((HWND)lParam,TranslateT("User has not registered an e-mail address"),TranslateT("Send e-mail"),MB_OK);
return 1;
}
}
szUrl=(char*)mir_alloc(lstrlenA(dbv.pszVal)+8);
lstrcpyA(szUrl,"mailto:");
lstrcatA(szUrl,dbv.pszVal);
mir_free(dbv.pszVal);
forkthread(SendEmailThread,0,szUrl);
return 0;
}
void WINAPI ServiceHandler(DWORD control)
// this function gets called when our service shall be stopped or started
{
HANDLE event;
CHAR evName [MAX_PATH];
if ((control == SERVICE_CONTROL_STOP) || (control == SERVICE_CONTROL_SHUTDOWN)) {
// our service is about to stop
UpdateStatus(SERVICE_STOP_PENDING);
// first we close the ipc queue
DestroyIpcQueue(CServiceName);
// then we set our shutdown event
lstrcpyA(evName, CServiceName);
lstrcatA(evName, "ShutdownEvent");
event = OpenGlobalEvent(evName);
SetEvent(event);
CloseHandle(event);
} else
UpdateStatus(SERVICE_RUNNING);
}
static
BOOL load_xinput_dll(HINSTANCE instance)
{
char sysdir[MAX_PATH];
char modname[MAX_PATH];
UINT sysdir_len;
DWORD modname_len;
DWORD namepos;
char *dllpath;
sysdir_len = GetSystemDirectoryA(sysdir, MAX_PATH);
if (sysdir_len == 0 || sysdir_len >= MAX_PATH) return FALSE;
modname_len = GetModuleFileNameA(instance, modname, MAX_PATH);
if (!modname_len) return FALSE;
namepos = cheap_find_last_of(modname, '\\');
dllpath = lstrcatA(sysdir, &modname[namepos]);
if (!dllpath) return FALSE;
XInput.dll = LoadLibraryA(dllpath);
if (!XInput.dll) return FALSE;
XInput.GetState = (t_XInputGetState)GetProcAddress(XInput.dll, "XInputGetState");
XInput.SetState = (t_XInputSetState)GetProcAddress(XInput.dll, "XInputSetState");
XInput.GetCapabilities = (t_XInputGetCapabilities)GetProcAddress(XInput.dll, "XInputGetCapabilities");
XInput.Enable = (t_XInputEnable)GetProcAddress(XInput.dll, "XInputEnable");
XInput.GetDSoundAudioDeviceGuids = (t_XInputGetDSoundAudioDeviceGuids)GetProcAddress(XInput.dll, "XInputGetDSoundAudioDeviceGuids");
XInput.GetBatteryInformation = (t_XInputGetBatteryInformation)GetProcAddress(XInput.dll, "XInputGetBatteryInformation");
XInput.GetKeystroke = (t_XInputGetKeystroke)GetProcAddress(XInput.dll, "XInputGetKeystroke");
XInput.GetAudioDeviceIds = (t_XInputGetAudioDeviceIds)GetProcAddress(XInput.dll, "XInputGetAudioDeviceIds");
XInput.GetStateEx = (t_XInputGetStateEx)GetProcAddress(XInput.dll, (LPCSTR)100);
XInput.WaitForGuideButton = (t_XInputWaitForGuideButton)GetProcAddress(XInput.dll, (LPCSTR)101);
XInput.CancelGuideButtonWait = (t_XInputCancelGuideButtonWait)GetProcAddress(XInput.dll, (LPCSTR)102);
XInput.PowerOffController = (t_XInputPowerOffController)GetProcAddress(XInput.dll, (LPCSTR)103);
XInput.GetBaseBusInformation = (t_XInputGetBaseBusInformation)GetProcAddress(XInput.dll, (LPCSTR)104);
XInput.GetCapabilitiesEx = (t_XInputGetCapabilitiesEx)GetProcAddress(XInput.dll, (LPCSTR)108);
return TRUE;
}
static char *StatusModeToDbSetting(int status,const char *suffix)
{
char *prefix;
static char str[64];
switch(status) {
case ID_STATUS_AWAY: prefix="Away"; break;
case ID_STATUS_NA: prefix="Na"; break;
case ID_STATUS_DND: prefix="Dnd"; break;
case ID_STATUS_OCCUPIED: prefix="Occupied"; break;
case ID_STATUS_FREECHAT: prefix="FreeChat"; break;
case ID_STATUS_ONLINE: prefix="On"; break;
case ID_STATUS_OFFLINE: prefix="Off"; break;
case ID_STATUS_INVISIBLE: prefix="Inv"; break;
case ID_STATUS_ONTHEPHONE: prefix="Otp"; break;
case ID_STATUS_OUTTOLUNCH: prefix="Otl"; break;
case ID_STATUS_IDLE: prefix="Idl"; break;
default: return NULL;
}
lstrcpyA(str,prefix); lstrcatA(str,suffix);
return str;
}
static BOOL TRASH_MoveFileToBucket(TRASH_BUCKET *pBucket, const char *unix_path)
{
struct stat file_stat;
char *trash_file_name = NULL;
char *trash_path = NULL;
BOOL ret = TRUE;
if (lstat(unix_path, &file_stat)==-1)
return FALSE;
if (!file_good_for_bucket(pBucket, &file_stat))
return FALSE;
trash_file_name = create_trashinfo(pBucket->info_dir, unix_path);
if (trash_file_name == NULL)
return FALSE;
trash_path = SHAlloc(strlen(pBucket->files_dir)+strlen(trash_file_name)+1);
if (trash_path == NULL) goto error;
lstrcpyA(trash_path, pBucket->files_dir);
lstrcatA(trash_path, trash_file_name);
if (rename(unix_path, trash_path)==0)
{
TRACE("rename succeeded\n");
goto cleanup;
}
/* TODO: try to manually move the file */
ERR("Couldn't move file\n");
error:
ret = FALSE;
remove_trashinfo_file(pBucket->info_dir, trash_file_name);
cleanup:
SHFree(trash_file_name);
SHFree(trash_path);
return ret;
}
/*
Does a stringSet exist on disk?
*/
bool AP_Win32App::doesStringSetExist(const char* pLocale)
{
HANDLE in;
const char * szDirectory = NULL;
UT_return_val_if_fail(pLocale, false);
getPrefsValueDirectory(true,AP_PREF_KEY_StringSetDirectory,&szDirectory);
UT_return_val_if_fail(((szDirectory) && (*szDirectory)), false);
char *szPathname = (char*) UT_calloc(sizeof(char),strlen(szDirectory)+strlen(pLocale)+100);
UT_return_val_if_fail(szPathname, false);
char *szDest = szPathname;
strcpy(szDest, szDirectory);
szDest += strlen(szDest);
if ((szDest > szPathname) && (szDest[-1]!='\\'))
*szDest++='\\';
lstrcpyA(szDest,pLocale);
lstrcatA(szDest,".strings");
UT_Win32LocaleString wsFilename;
wsFilename.fromUTF8(szPathname);
in = CreateFileW(wsFilename.c_str(),0,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,
OPEN_EXISTING,0,NULL);
g_free (szPathname);
if (in!=INVALID_HANDLE_VALUE)
{
CloseHandle(in);
return true;
}
return false;
}
static void test_AddDelBackupEntry(void)
{
BOOL ret;
HRESULT res;
CHAR path[MAX_PATH];
CHAR windir[MAX_PATH];
lstrcpyA(path, CURR_DIR);
lstrcatA(path, "\\backup\\basename.INI");
/* native AddDelBackupEntry crashes if lpcszBaseName is NULL */
/* try a NULL file list */
res = pAddDelBackupEntry(NULL, "backup", "basename", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ok(!DeleteFileA(path), "Expected path to not exist\n");
lstrcpyA(path, CURR_DIR);
lstrcatA(path, "\\backup\\.INI");
/* try an empty base name */
res = pAddDelBackupEntry("one\0two\0three\0", "backup", "", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ok(!DeleteFileA(path), "Expected path to not exist\n");
lstrcpyA(path, CURR_DIR);
lstrcatA(path, "\\basename.INI");
/* try an invalid flag */
res = pAddDelBackupEntry("one\0two\0three\0", NULL, "basename", 0);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ok(!DeleteFileA(path), "Expected path to not exist\n");
lstrcpyA(path, "c:\\basename.INI");
/* create the INF file */
res = pAddDelBackupEntry("one\0two\0three\0", "c:\\", "basename", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
if (GetFileAttributes(path) != INVALID_FILE_ATTRIBUTES)
{
ok(check_ini_file_attr(path), "Expected ini file to be hidden\n");
ok(DeleteFileA(path), "Expected path to exist\n");
}
else
win_skip("Test file could not be created\n");
lstrcpyA(path, CURR_DIR);
lstrcatA(path, "\\backup\\basename.INI");
/* try to create the INI file in a nonexistent directory */
RemoveDirectoryA("backup");
res = pAddDelBackupEntry("one\0two\0three\0", "backup", "basename", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ok(!check_ini_file_attr(path), "Expected ini file to not be hidden\n");
ok(!DeleteFileA(path), "Expected path to not exist\n");
/* try an existent, relative backup directory */
CreateDirectoryA("backup", NULL);
res = pAddDelBackupEntry("one\0two\0three\0", "backup", "basename", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ok(check_ini_file_attr(path), "Expected ini file to be hidden\n");
ok(DeleteFileA(path), "Expected path to exist\n");
RemoveDirectoryA("backup");
GetWindowsDirectoryA(windir, sizeof(windir));
sprintf(path, "%s\\basename.INI", windir);
/* try a NULL backup dir, INI is created in the windows directory */
res = pAddDelBackupEntry("one\0two\0three\0", NULL, "basename", AADBE_ADD_ENTRY);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
/* remove the entries with AADBE_DEL_ENTRY */
SetFileAttributesA(path, FILE_ATTRIBUTE_NORMAL);
res = pAddDelBackupEntry("one\0three\0", NULL, "basename", AADBE_DEL_ENTRY);
SetFileAttributesA(path, FILE_ATTRIBUTE_NORMAL);
ok(res == S_OK, "Expected S_OK, got %d\n", res);
ret = DeleteFileA(path);
ok(ret == TRUE ||
broken(ret == FALSE), /* win98 */
"Expected path to exist\n");
}
static void test_ExtractFiles(void)
{
HRESULT hr;
char destFolder[MAX_PATH];
lstrcpyA(destFolder, CURR_DIR);
lstrcatA(destFolder, "\\");
lstrcatA(destFolder, "dest");
/* try NULL cab file */
hr = pExtractFiles(NULL, destFolder, 0, NULL, NULL, 0);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr);
ok(RemoveDirectoryA("dest"), "Expected dest to exist\n");
/* try NULL destination */
hr = pExtractFiles("extract.cab", NULL, 0, NULL, NULL, 0);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got %d\n", hr);
ok(!RemoveDirectoryA("dest"), "Expected dest to not exist\n");
/* extract all files in the cab to nonexistent destination directory */
hr = pExtractFiles("extract.cab", destFolder, 0, NULL, NULL, 0);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) ||
hr == E_FAIL, /* win95 */
"Expected %08x or %08x, got %08x\n", E_FAIL,
HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), hr);
ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
ok(!RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to not exist\n");
ok(!RemoveDirectoryA("dest"), "Expected dest to not exist\n");
/* extract all files in the cab to the destination directory */
CreateDirectoryA("dest", NULL);
hr = pExtractFiles("extract.cab", destFolder, 0, NULL, NULL, 0);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
/* extract all files to a relative destination directory */
hr = pExtractFiles("extract.cab", "dest", 0, NULL, NULL, 0);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
ok(DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to exist\n");
ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
/* only extract two of the files from the cab */
hr = pExtractFiles("extract.cab", "dest", 0, "a.txt:testdir\\c.txt", NULL, 0);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
/* use valid chars before and after file list */
hr = pExtractFiles("extract.cab", "dest", 0, " :\t: a.txt:testdir\\c.txt \t:", NULL, 0);
ok(hr == S_OK, "Expected S_OK, got %d\n", hr);
ok(DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to exist\n");
ok(DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to exist\n");
ok(RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to exist\n");
ok(!DeleteFileA("dest\\b.txt"), "Expected dest\\b.txt to not exist\n");
ok(!DeleteFileA("dest\\testdir\\d.txt"), "Expected dest\\testdir\\d.txt to not exist\n");
/* use invalid chars before and after file list */
hr = pExtractFiles("extract.cab", "dest", 0, " +-\\ a.txt:testdir\\c.txt a_:", NULL, 0);
ok(hr == E_FAIL, "Expected E_FAIL, got %d\n", hr);
ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
ok(!RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to not exist\n");
/* try an empty file list */
hr = pExtractFiles("extract.cab", "dest", 0, "", NULL, 0);
ok(hr == E_FAIL, "Expected E_FAIL, got %d\n", hr);
ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
ok(!RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to not exist\n");
/* try a nonexistent file in the file list */
hr = pExtractFiles("extract.cab", "dest", 0, "a.txt:idontexist:testdir\\c.txt", NULL, 0);
ok(hr == E_FAIL, "Expected E_FAIL, got %d\n", hr);
ok(!DeleteFileA("dest\\a.txt"), "Expected dest\\a.txt to not exist\n");
ok(!DeleteFileA("dest\\testdir\\c.txt"), "Expected dest\\testdir\\c.txt to not exist\n");
ok(!RemoveDirectoryA("dest\\testdir"), "Expected dest\\testdir to not exist\n");
}
static void test_SetupGetTargetPath(void)
{
char buffer[MAX_PATH], inf_filename[MAX_PATH];
char destfile[MAX_PATH];
DWORD required;
HINF hinf;
INFCONTEXT ctx;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
ctx.Inf = hinf;
ctx.CurrentInf = hinf;
ctx.Section = 7;
ctx.Line = 0;
required = 0;
ret = SetupGetTargetPathA(hinf, &ctx, NULL, buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
ok(required == 10, "unexpected required size: %d\n", required);
/* Retrieve the system drive from the windows directory.
* (%SystemDrive% is not available on Win9x)
*/
lstrcpyA(destfile, WIN_DIR);
destfile[3] = '\0';
lstrcatA(destfile, "LANCOM");
ok(!lstrcmpiA(destfile, buffer), "unexpected result string: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data3, sizeof(inf_data3) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data4, sizeof(inf_data4) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.System32.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
GetSystemDirectoryA(destfile, MAX_PATH);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data5, sizeof(inf_data5) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
create_inf_file(inf_filename, inf_data6, sizeof(inf_data6) - 1);
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
ok(hinf != INVALID_HANDLE_VALUE, "could not open inf file\n");
required = 0;
ret = SetupGetTargetPathA(hinf, NULL, "CopyAlways.Windir.Files", buffer, sizeof(buffer), &required);
ok(ret, "SetupGetTargetPathA failed\n");
lstrcpyA(destfile, WIN_DIR);
ok(required == lstrlenA(destfile) + 1, "unexpected required size: %d\n", required);
ok(!lstrcmpiA(buffer, destfile), "unexpected path: %s\n", buffer);
SetupCloseInfFile(hinf);
DeleteFileA(inf_filename);
}
static void test_SetupGetInfInformation(void)
{
PSP_INF_INFORMATION info;
CHAR inf_filename[MAX_PATH];
CHAR inf_one[MAX_PATH], inf_two[MAX_PATH];
LPSTR revfile;
DWORD size;
HINF hinf;
BOOL ret;
lstrcpyA(inf_filename, CURR_DIR);
lstrcatA(inf_filename, "\\");
lstrcatA(inf_filename, "test.inf");
/* try an invalid inf handle */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(NULL, INFINFO_INF_SPEC_IS_HINF, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_HANDLE ||
broken(GetLastError() == ERROR_BAD_PATHNAME) || /* win95 */
broken(GetLastError() == ERROR_FILE_NOT_FOUND) || /* win98 */
broken(GetLastError() == ERROR_PATH_NOT_FOUND) || /* NT4 */
broken(GetLastError() == ERROR_INVALID_NAME) || /* win2k */
broken(GetLastError() == ERROR_GENERAL_SYNTAX), /* another win2k / winMe */
"Expected ERROR_INVALID_HANDLE, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* try an invalid inf filename */
/* do not use NULL as absolute inf filename on win9x/winMe (crash) */
if ((GetLastError() != ERROR_BAD_PATHNAME) && /* win95 */
(GetLastError() != ERROR_FILE_NOT_FOUND) && /* win98 */
(GetLastError() != ERROR_GENERAL_SYNTAX)) /* winMe */
{
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(NULL, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
}
create_inf_file(inf_filename, inf_data1, sizeof(inf_data1) - 1);
/* try an invalid search flag */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, -1, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* try a nonexistent inf file */
size = 0xdeadbeef;
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA("idontexist", INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_FILE_NOT_FOUND,
"Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
ok(size == 0xdeadbeef, "Expected size to remain unchanged\n");
/* successfully open the inf file */
size = 0xdeadbeef;
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(size != 0xdeadbeef, "Expected a valid size on return\n");
/* set ReturnBuffer to NULL and ReturnBufferSize to non-zero value 'size' */
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INVALID_PARAMETER,
"Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
/* set ReturnBuffer to NULL and ReturnBufferSize to non-zero value 'size-1' */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size-1, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
/* some tests for behaviour with a NULL RequiredSize pointer */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, 0, NULL);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size - 1, NULL);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, NULL, size, NULL);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
info = HeapAlloc(GetProcessHeap(), 0, size);
/* try valid ReturnBuffer but too small size */
SetLastError(0xbeefcafe);
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, info, size - 1, &size);
ok(ret == FALSE, "Expected SetupGetInfInformation to fail\n");
ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER,
"Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
/* successfully get the inf information */
ret = SetupGetInfInformationA(inf_filename, INFINFO_INF_NAME_IS_ABSOLUTE, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, inf_filename), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
/* try the INFINFO_INF_SPEC_IS_HINF search flag */
hinf = SetupOpenInfFileA(inf_filename, NULL, INF_STYLE_WIN4, NULL);
info = alloc_inf_info(hinf, INFINFO_INF_SPEC_IS_HINF, &size);
ret = SetupGetInfInformationA(hinf, INFINFO_INF_SPEC_IS_HINF, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, inf_filename), "Expected returned filename to be equal\n");
SetupCloseInfFile(hinf);
lstrcpyA(inf_two, WIN_DIR);
lstrcatA(inf_two, "\\system32\\");
lstrcatA(inf_two, "test.inf");
create_inf_file(inf_two, inf_data1, sizeof(inf_data1) - 1);
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_DEFAULT_SEARCH, &size);
/* check if system32 is searched for inf */
ret = SetupGetInfInformationA("test.inf", INFINFO_DEFAULT_SEARCH, info, size, &size);
if (!ret && GetLastError() == ERROR_FILE_NOT_FOUND)
revfile = inf_one; /* Vista */
else
revfile = inf_two;
lstrcpyA(inf_one, WIN_DIR);
lstrcatA(inf_one, "\\inf\\");
lstrcatA(inf_one, "test.inf");
create_inf_file(inf_one, inf_data1, sizeof(inf_data1) - 1);
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_DEFAULT_SEARCH, &size);
/* test the INFINFO_DEFAULT_SEARCH search flag */
ret = SetupGetInfInformationA("test.inf", INFINFO_DEFAULT_SEARCH, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed: %d\n", GetLastError());
ok(check_info_filename(info, inf_one), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
info = alloc_inf_info("test.inf", INFINFO_REVERSE_DEFAULT_SEARCH, &size);
/* test the INFINFO_REVERSE_DEFAULT_SEARCH search flag */
ret = SetupGetInfInformationA("test.inf", INFINFO_REVERSE_DEFAULT_SEARCH, info, size, &size);
ok(ret == TRUE, "Expected SetupGetInfInformation to succeed\n");
ok(check_info_filename(info, revfile), "Expected returned filename to be equal\n");
HeapFree(GetProcessHeap(), 0, info);
DeleteFileA(inf_filename);
DeleteFileA(inf_one);
DeleteFileA(inf_two);
}
void __cdecl CYahooProto::get_status_thread(void *param)
{
int l;
DBVARIANT dbv;
char *gm = NULL, *sm = NULL, *fm;
MCONTACT hContact = (MCONTACT)param;
Sleep(150);
/* Check Yahoo Games Message */
if (!getString(hContact, "YGMsg", &dbv)) {
gm = strdup(dbv.pszVal);
db_free(&dbv);
}
if (!db_get_s(hContact, "CList", "StatusMsg", &dbv)) {
if (lstrlenA(dbv.pszVal) >= 1)
sm = strdup(dbv.pszVal);
db_free(&dbv);
}
else {
int status = getWord(hContact, "YStatus", (WORD)YAHOO_STATUS_OFFLINE);
sm = yahoo_status_code(yahoo_status(status));
if (sm) sm = strdup(sm); /* we need this to go global FREE later */
}
l = 0;
if (gm)
l += lstrlenA(gm) + 3;
l += lstrlenA(sm) + 1;
fm = (char *)malloc(l);
fm[0] = '\0';
if (gm && lstrlenA(gm) > 0) {
/* BAH YAHOO SUCKS! WHAT A PAIN!
find first carriage return add status message then add the rest */
char *c = strchr(gm, '\r');
if (c != NULL) {
lstrcpynA(fm, gm, c - gm + 1);
fm[c - gm + 1] = '\0';
}
else
lstrcpyA(fm, gm);
if (sm) {
lstrcatA(fm, ": ");
lstrcatA(fm, sm);
}
if (c != NULL)
lstrcatA(fm, c);
}
else if (sm) {
lstrcatA(fm, sm);
}
FREE(sm);
ProtoBroadcastAck(hContact, ACKTYPE_AWAYMSG, ACKRESULT_SUCCESS, (HANDLE)1, (LPARAM)(TCHAR*)_A2T(fm));
}
void ProcessDebugEvent()
{
static wchar_t wszDbgText[1024];
static char szDbgText[1024];
BOOL lbNonContinuable = FALSE;
DEBUG_EVENT evt = {0};
BOOL lbEvent = WaitForDebugEvent(&evt,10);
#ifdef _DEBUG
DWORD dwErr = GetLastError();
#endif
static bool bFirstExitThreadEvent = false; // Чтобы вывести на экран подсказку по возможностям "дебаггера"
//HMODULE hCOMDLG32 = NULL;
//typedef BOOL (WINAPI* GetSaveFileName_t)(LPOPENFILENAMEW lpofn);
//GetSaveFileName_t _GetSaveFileName = NULL;
DWORD dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
if (lbEvent)
{
lbNonContinuable = FALSE;
switch (evt.dwDebugEventCode)
{
case CREATE_PROCESS_DEBUG_EVENT:
case CREATE_THREAD_DEBUG_EVENT:
case EXIT_PROCESS_DEBUG_EVENT:
case EXIT_THREAD_DEBUG_EVENT:
case RIP_EVENT:
{
LPCSTR pszName = "Unknown";
switch (evt.dwDebugEventCode)
{
case CREATE_PROCESS_DEBUG_EVENT: pszName = "CREATE_PROCESS_DEBUG_EVENT"; break;
case CREATE_THREAD_DEBUG_EVENT: pszName = "CREATE_THREAD_DEBUG_EVENT"; break;
case EXIT_PROCESS_DEBUG_EVENT: pszName = "EXIT_PROCESS_DEBUG_EVENT"; break;
case EXIT_THREAD_DEBUG_EVENT: pszName = "EXIT_THREAD_DEBUG_EVENT"; break;
case RIP_EVENT: pszName = "RIP_EVENT"; break;
}
_wsprintfA(szDbgText, SKIPLEN(countof(szDbgText)) "{%i.%i} %s\n", evt.dwProcessId,evt.dwThreadId, pszName);
_printf(szDbgText);
if (!bFirstExitThreadEvent && evt.dwDebugEventCode == EXIT_THREAD_DEBUG_EVENT)
{
bFirstExitThreadEvent = true;
if (gpSrv->DbgInfo.nDebugDumpProcess == 0)
{
_printf("ConEmuC: Press Ctrl+Break to create minidump of debugging process\n");
}
else
{
// Сразу сделать дамп и выйти
HandlerRoutine(CTRL_BREAK_EVENT);
}
}
if (evt.dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT)
{
gpSrv->DbgInfo.nProcessCount++;
_ASSERTE(gpSrv->DbgInfo.pDebugTreeProcesses!=NULL);
CEDebugProcessInfo pi = {evt.dwProcessId};
gpSrv->DbgInfo.pDebugTreeProcesses->Set(evt.dwProcessId, pi);
UpdateDebuggerTitle();
}
else if (evt.dwDebugEventCode == EXIT_PROCESS_DEBUG_EVENT)
{
CEDebugProcessInfo pi = {};
if (gpSrv->DbgInfo.pDebugTreeProcesses
&& gpSrv->DbgInfo.pDebugTreeProcesses->Get(evt.dwProcessId, &pi, true)
&& pi.hProcess)
{
CloseHandle(pi.hProcess);
}
if (gpSrv->DbgInfo.nProcessCount > 0)
gpSrv->DbgInfo.nProcessCount--;
UpdateDebuggerTitle();
}
break;
}
case LOAD_DLL_DEBUG_EVENT:
case UNLOAD_DLL_DEBUG_EVENT:
{
LPCSTR pszName = "Unknown";
char szBase[32] = {};
char szFile[MAX_PATH+128] = {};
struct MY_FILE_NAME_INFO
{
DWORD FileNameLength;
WCHAR FileName[1];
};
typedef BOOL (WINAPI* GetFileInformationByHandleEx_t)(HANDLE hFile, int FileInformationClass, LPVOID lpFileInformation, DWORD dwBufferSize);
static GetFileInformationByHandleEx_t _GetFileInformationByHandleEx = NULL;
switch (evt.dwDebugEventCode)
{
case LOAD_DLL_DEBUG_EVENT:
//6 Reports a load-dynamic-link-library (DLL) debugging event. The value of u.LoadDll specifies a LOAD_DLL_DEBUG_INFO structure.
pszName = "LOAD_DLL_DEBUG_EVENT";
if (evt.u.LoadDll.hFile)
{
if (gnOsVer >= 0x0600)
{
if (!_GetFileInformationByHandleEx)
_GetFileInformationByHandleEx = (GetFileInformationByHandleEx_t)GetProcAddress(GetModuleHandle(L"kernel32.dll"), "GetFileInformationByHandleEx");
if (_GetFileInformationByHandleEx)
{
DWORD nSize = sizeof(MY_FILE_NAME_INFO)+MAX_PATH*sizeof(wchar_t);
MY_FILE_NAME_INFO* pfi = (MY_FILE_NAME_INFO*)calloc(nSize+2,1);
if (pfi)
{
pfi->FileNameLength = MAX_PATH;
if (_GetFileInformationByHandleEx(evt.u.LoadDll.hFile, 2/*FileNameInfo*/, pfi, nSize)
&& pfi->FileName[0])
{
wchar_t szFullPath[MAX_PATH+1] = {}, *pszFile;
DWORD n = GetFullPathName(pfi->FileName, countof(szFullPath), szFullPath, &pszFile);
if (!n || (n >= countof(szFullPath)))
{
lstrcpyn(szFullPath, pfi->FileName, countof(szFullPath));
pszFile = (wchar_t*)PointToName(pfi->FileName);
}
else if (!pszFile)
{
pszFile = (wchar_t*)PointToName(szFullPath);
}
lstrcpyA(szFile, ", ");
WideCharToMultiByte(CP_OEMCP, 0, pszFile, -1, szFile+lstrlenA(szFile), 80, 0,0);
lstrcatA(szFile, "\n\t");
WideCharToMultiByte(CP_OEMCP, 0, szFullPath, -1, szFile+lstrlenA(szFile), MAX_PATH, 0,0);
}
free(pfi);
}
}
}
CloseHandle(evt.u.LoadDll.hFile);
}
_wsprintfA(szBase, SKIPLEN(countof(szBase))
" at " WIN3264TEST("0x%08X","0x%08X%08X"),
WIN3264WSPRINT((DWORD_PTR)evt.u.LoadDll.lpBaseOfDll));
break;
case UNLOAD_DLL_DEBUG_EVENT:
//7 Reports an unload-DLL debugging event. The value of u.UnloadDll specifies an UNLOAD_DLL_DEBUG_INFO structure.
pszName = "UNLOAD_DLL_DEBUG_EVENT";
_wsprintfA(szBase, SKIPLEN(countof(szBase))
" at " WIN3264TEST("0x%08X","0x%08X%08X"),
WIN3264WSPRINT((DWORD_PTR)evt.u.UnloadDll.lpBaseOfDll));
break;
}
_wsprintfA(szDbgText, SKIPLEN(countof(szDbgText)) "{%i.%i} %s%s%s\n", evt.dwProcessId,evt.dwThreadId, pszName, szBase, szFile);
_printf(szDbgText);
break;
}
case EXCEPTION_DEBUG_EVENT:
//1 Reports an exception debugging event. The value of u.Exception specifies an EXCEPTION_DEBUG_INFO structure.
{
lbNonContinuable = (evt.u.Exception.ExceptionRecord.ExceptionFlags&EXCEPTION_NONCONTINUABLE)==EXCEPTION_NONCONTINUABLE;
//static bool bAttachEventRecieved = false;
//if (!bAttachEventRecieved)
//{
// bAttachEventRecieved = true;
// StringCchPrintfA(szDbgText, countof(szDbgText),"{%i.%i} Debugger attached successfully. (0x%08X address 0x%08X flags 0x%08X%s)\n",
// evt.dwProcessId,evt.dwThreadId,
// evt.u.Exception.ExceptionRecord.ExceptionCode,
// evt.u.Exception.ExceptionRecord.ExceptionAddress,
// evt.u.Exception.ExceptionRecord.ExceptionFlags,
// (evt.u.Exception.ExceptionRecord.ExceptionFlags&EXCEPTION_NONCONTINUABLE) ? "(EXCEPTION_NONCONTINUABLE)" : "");
//}
//else
switch (evt.u.Exception.ExceptionRecord.ExceptionCode)
{
case EXCEPTION_ACCESS_VIOLATION: // The thread tried to read from or write to a virtual address for which it does not have the appropriate access.
{
if (evt.u.Exception.ExceptionRecord.NumberParameters>=2)
{
_wsprintfA(szDbgText, SKIPLEN(countof(szDbgText))
"{%i.%i} EXCEPTION_ACCESS_VIOLATION at " WIN3264TEST("0x%08X","0x%08X%08X") " flags 0x%08X%s %s of " WIN3264TEST("0x%08X","0x%08X%08X") " FC=%u\n", evt.dwProcessId,evt.dwThreadId,
WIN3264WSPRINT((DWORD_PTR)evt.u.Exception.ExceptionRecord.ExceptionAddress),
evt.u.Exception.ExceptionRecord.ExceptionFlags,
((evt.u.Exception.ExceptionRecord.ExceptionFlags&EXCEPTION_NONCONTINUABLE) ? "(EXCEPTION_NONCONTINUABLE)" : ""),
((evt.u.Exception.ExceptionRecord.ExceptionInformation[0]==0) ? "Read" :
(evt.u.Exception.ExceptionRecord.ExceptionInformation[0]==1) ? "Write" :
(evt.u.Exception.ExceptionRecord.ExceptionInformation[0]==8) ? "DEP" : "???"),
WIN3264WSPRINT(evt.u.Exception.ExceptionRecord.ExceptionInformation[1]),
evt.u.Exception.dwFirstChance
);
}
else
{
_wsprintfA(szDbgText, SKIPLEN(countof(szDbgText))
"{%i.%i} EXCEPTION_ACCESS_VIOLATION at " WIN3264TEST("0x%08X","0x%08X%08X") " flags 0x%08X%s FC=%u\n", evt.dwProcessId,evt.dwThreadId,
WIN3264WSPRINT((DWORD_PTR)evt.u.Exception.ExceptionRecord.ExceptionAddress),
evt.u.Exception.ExceptionRecord.ExceptionFlags,
(evt.u.Exception.ExceptionRecord.ExceptionFlags&EXCEPTION_NONCONTINUABLE) ? "(EXCEPTION_NONCONTINUABLE)" : "",
evt.u.Exception.dwFirstChance);
}
_printf(szDbgText);
}
break;
default:
{
char szName[32]; LPCSTR pszName; pszName = szName;
#define EXCASE(s) case s: pszName = #s; break
switch(evt.u.Exception.ExceptionRecord.ExceptionCode)
{
EXCASE(EXCEPTION_ARRAY_BOUNDS_EXCEEDED); // The thread tried to access an array element that is out of bounds and the underlying hardware supports bounds checking.
EXCASE(EXCEPTION_BREAKPOINT); // A breakpoint was encountered.
EXCASE(EXCEPTION_DATATYPE_MISALIGNMENT); // The thread tried to read or write data that is misaligned on hardware that does not provide alignment. For example, 16-bit values must be aligned on 2-byte boundaries; 32-bit values on 4-byte boundaries, and so on.
EXCASE(EXCEPTION_FLT_DENORMAL_OPERAND); // One of the operands in a floating-point operation is denormal. A denormal value is one that is too small to represent as a standard floating-point value.
EXCASE(EXCEPTION_FLT_DIVIDE_BY_ZERO); // The thread tried to divide a floating-point value by a floating-point divisor of zero.
EXCASE(EXCEPTION_FLT_INEXACT_RESULT); // The result of a floating-point operation cannot be represented exactly as a decimal fraction.
EXCASE(EXCEPTION_FLT_INVALID_OPERATION); // This exception represents any floating-point exception not included in this list.
EXCASE(EXCEPTION_FLT_OVERFLOW); // The exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type.
EXCASE(EXCEPTION_FLT_STACK_CHECK); // The stack overflowed or underflowed as the result of a floating-point operation.
EXCASE(EXCEPTION_FLT_UNDERFLOW); // The exponent of a floating-point operation is less than the magnitude allowed by the corresponding type.
EXCASE(EXCEPTION_ILLEGAL_INSTRUCTION); // The thread tried to execute an invalid instruction.
EXCASE(EXCEPTION_IN_PAGE_ERROR); // The thread tried to access a page that was not present, and the system was unable to load the page. For example, this exception might occur if a network connection is lost while running a program over the network.
EXCASE(EXCEPTION_INT_DIVIDE_BY_ZERO); // The thread tried to divide an integer value by an integer divisor of zero.
EXCASE(EXCEPTION_INT_OVERFLOW); // The result of an integer operation caused a carry out of the most significant bit of the result.
EXCASE(EXCEPTION_INVALID_DISPOSITION); // An exception handler returned an invalid disposition to the exception dispatcher. Programmers using a high-level language such as C should never encounter this exception.
EXCASE(EXCEPTION_NONCONTINUABLE_EXCEPTION); // The thread tried to continue execution after a noncontinuable exception occurred.
EXCASE(EXCEPTION_PRIV_INSTRUCTION); // The thread tried to execute an instruction whose operation is not allowed in the current machine mode.
EXCASE(EXCEPTION_SINGLE_STEP); // A trace trap or other single-instruction mechanism signaled that one instruction has been executed.
EXCASE(EXCEPTION_STACK_OVERFLOW); // The thread used up its stack.
default:
_wsprintfA(szName, SKIPLEN(countof(szName))
"Exception 0x%08X", evt.u.Exception.ExceptionRecord.ExceptionCode);
}
_wsprintfA(szDbgText, SKIPLEN(countof(szDbgText))
"{%i.%i} %s at " WIN3264TEST("0x%08X","0x%08X%08X") " flags 0x%08X%s FC=%u\n",
evt.dwProcessId,evt.dwThreadId,
pszName,
WIN3264WSPRINT((DWORD_PTR)evt.u.Exception.ExceptionRecord.ExceptionAddress),
evt.u.Exception.ExceptionRecord.ExceptionFlags,
(evt.u.Exception.ExceptionRecord.ExceptionFlags&EXCEPTION_NONCONTINUABLE)
? "(EXCEPTION_NONCONTINUABLE)" : "",
evt.u.Exception.dwFirstChance);
_printf(szDbgText);
}
}
BOOL bDumpOnBreakPoint = gpSrv->DbgInfo.bDebuggerRequestDump;
if (gpSrv->DbgInfo.bDebugProcessTree
&& (!lbNonContinuable && (evt.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_BREAKPOINT)))
{
// Когда отладчик цепляется к процессу в первый раз - возникает EXCEPTION_BREAKPOINT
CEDebugProcessInfo pi = {};
if (gpSrv->DbgInfo.pDebugTreeProcesses
&& gpSrv->DbgInfo.pDebugTreeProcesses->Get(evt.dwProcessId, &pi))
{
if (!pi.bWasBreak)
{
pi.bWasBreak = TRUE;
gpSrv->DbgInfo.pDebugTreeProcesses->Set(evt.dwProcessId, pi);
}
else
{
bDumpOnBreakPoint = TRUE;
}
}
}
if (gpSrv->DbgInfo.bDebuggerRequestDump
|| (!lbNonContinuable && !gpSrv->DbgInfo.bDebugProcessTree
&& (evt.u.Exception.ExceptionRecord.ExceptionCode != EXCEPTION_BREAKPOINT))
|| (gpSrv->DbgInfo.bDebugProcessTree
&& ((evt.u.Exception.ExceptionRecord.ExceptionCode>=0xC0000000)
|| (bDumpOnBreakPoint && (evt.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_BREAKPOINT))))
)
{
BOOL bGenerateTreeBreak = gpSrv->DbgInfo.bDebugProcessTree
&& (gpSrv->DbgInfo.bDebuggerRequestDump || lbNonContinuable);
if (gpSrv->DbgInfo.bDebugProcessTree
&& !bGenerateTreeBreak
&& (evt.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_BREAKPOINT))
{
if (gpSrv->DbgInfo.nWaitTreeBreaks == 0)
{
bGenerateTreeBreak = TRUE;
gpSrv->DbgInfo.nWaitTreeBreaks++;
}
}
gpSrv->DbgInfo.bDebuggerRequestDump = FALSE; // один раз
char szConfirm[2048];
if (evt.u.Exception.ExceptionRecord.ExceptionCode == EXCEPTION_BREAKPOINT)
{
if (gpSrv->DbgInfo.nDebugDumpProcess)
szConfirm[0] = 0;
else
lstrcpynA(szConfirm, szDbgText, countof(szConfirm));
}
else
{
_wsprintfA(szConfirm, SKIPLEN(countof(szConfirm)) "%s exception (FC=%u)\n",
lbNonContinuable ? "Non continuable" : "Continuable",
evt.u.Exception.dwFirstChance);
StringCchCatA(szConfirm, countof(szConfirm), szDbgText);
}
StringCchCatA(szConfirm, countof(szConfirm), "\nCreate minidump (<No> - fulldump)?");
//GenerateTreeDebugBreak
WriteMiniDump(evt.dwProcessId, evt.dwThreadId, &evt.u.Exception.ExceptionRecord, szConfirm, bGenerateTreeBreak);
if (gpSrv->DbgInfo.bDebugProcessTree && (evt.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_BREAKPOINT))
{
if (gpSrv->DbgInfo.nWaitTreeBreaks > 0)
gpSrv->DbgInfo.nWaitTreeBreaks--;
}
}
if (!lbNonContinuable /*|| (evt.u.Exception.ExceptionRecord.ExceptionCode==EXCEPTION_BREAKPOINT)*/)
{
dwContinueStatus = DBG_CONTINUE;
}
}
break;
case OUTPUT_DEBUG_STRING_EVENT:
//8 Reports an output-debugging-string debugging event. The value of u.DebugString specifies an OUTPUT_DEBUG_STRING_INFO structure.
{
wszDbgText[0] = 0;
if (evt.u.DebugString.nDebugStringLength >= 1024) evt.u.DebugString.nDebugStringLength = 1023;
DWORD_PTR nRead = 0;
HANDLE hProcess = GetProcessHandleForDebug(evt.dwProcessId);
if (evt.u.DebugString.fUnicode)
{
if (!ReadProcessMemory(hProcess, evt.u.DebugString.lpDebugStringData, wszDbgText, 2*evt.u.DebugString.nDebugStringLength, &nRead))
{
wcscpy_c(wszDbgText, L"???");
}
else
{
wszDbgText[min(1023,nRead+1)] = 0;
}
static int nPrefixLen = lstrlen(CONEMU_CONHOST_CREATED_MSG);
if (memcmp(wszDbgText, CONEMU_CONHOST_CREATED_MSG, nPrefixLen*sizeof(wszDbgText[0])) == 0)
{
LPWSTR pszEnd = NULL;
DWORD nConHostPID = wcstoul(wszDbgText+nPrefixLen, &pszEnd, 10);
if (nConHostPID && !gpSrv->DbgInfo.pDebugTreeProcesses->Get(nConHostPID, NULL))
{
AttachConHost(nConHostPID);
}
}
}
else
{
if (!ReadProcessMemory(hProcess, evt.u.DebugString.lpDebugStringData, szDbgText, evt.u.DebugString.nDebugStringLength, &nRead))
{
wcscpy_c(wszDbgText, L"???");
}
else
{
szDbgText[min(1023,nRead+1)] = 0;
// CP_ACP differs from CP_OEMCP, thats why we need some overhead...
MultiByteToWideChar(CP_ACP, 0, szDbgText, -1, wszDbgText, 1024);
}
}
WideCharToMultiByte(CP_OEMCP, 0, wszDbgText, -1, szDbgText, 1024, 0, 0);
#ifdef CRTPRINTF
{
_printf("{PID=%i.TID=%i} ", evt.dwProcessId,evt.dwThreadId, wszDbgText);
}
#else
{
_printf("{PID=%i.TID=%i} %s", evt.dwProcessId,evt.dwThreadId, szDbgText);
int nLen = lstrlenA(szDbgText);
if (nLen > 0 && szDbgText[nLen-1] != '\n')
_printf("\n");
}
#endif
dwContinueStatus = DBG_CONTINUE;
}
break;
}
// Продолжить отлаживаемый процесс
ContinueDebugEvent(evt.dwProcessId, evt.dwThreadId, dwContinueStatus);
}
//if (hCOMDLG32)
// FreeLibrary(hCOMDLG32);
}
static void test_CreateDirectoryA(void)
{
char tmpdir[MAX_PATH];
WCHAR curdir[MAX_PATH];
BOOL ret;
ret = CreateDirectoryA(NULL, NULL);
ok(ret == FALSE && (GetLastError() == ERROR_PATH_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER),
"CreateDirectoryA(NULL): ret=%d err=%d\n", ret, GetLastError());
ret = CreateDirectoryA("", NULL);
ok(ret == FALSE && (GetLastError() == ERROR_BAD_PATHNAME ||
GetLastError() == ERROR_PATH_NOT_FOUND),
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
ret = GetSystemDirectoryA(tmpdir, MAX_PATH);
ok(ret < MAX_PATH, "System directory should fit into MAX_PATH\n");
GetCurrentDirectoryW(MAX_PATH, curdir);
ret = SetCurrentDirectoryA(tmpdir);
ok(ret == TRUE, "could not chdir to the System directory\n");
ret = CreateDirectoryA(".", NULL);
ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
ret = CreateDirectoryA("..", NULL);
ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
GetTempPathA(MAX_PATH, tmpdir);
tmpdir[3] = 0; /* truncate the path */
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && (GetLastError() == ERROR_ALREADY_EXISTS ||
GetLastError() == ERROR_ACCESS_DENIED),
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE, "CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && GetLastError() == ERROR_ALREADY_EXISTS,
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
lstrcatA(tmpdir, "?");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
GetLastError() == ERROR_PATH_NOT_FOUND),
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
RemoveDirectoryA(tmpdir);
tmpdir[lstrlenA(tmpdir) - 1] = '*';
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && (GetLastError() == ERROR_INVALID_NAME ||
GetLastError() == ERROR_PATH_NOT_FOUND),
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
RemoveDirectoryA(tmpdir);
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me/Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND,
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
RemoveDirectoryA(tmpdir);
/* Test behavior with a trailing dot.
* The directory should be created without the dot.
*/
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me.");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE,
"CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
lstrcatA(tmpdir, "/Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE,
"CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me");
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
/* Test behavior with two trailing dots.
* The directory should be created without the trailing dots.
*/
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me..");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE,
"CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
lstrcatA(tmpdir, "/Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE || /* On Win98 */
(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
if (ret == TRUE)
{
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
}
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me");
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
/* Test behavior with a trailing space.
* The directory should be created without the trailing space.
*/
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me ");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE,
"CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
lstrcatA(tmpdir, "/Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE || /* On Win98 */
(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
if (ret == TRUE)
{
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
}
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me");
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
/* Test behavior with a trailing space.
* The directory should be created without the trailing spaces.
*/
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me ");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE,
"CreateDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
lstrcatA(tmpdir, "/Please Remove Me");
ret = CreateDirectoryA(tmpdir, NULL);
ok(ret == TRUE || /* On Win98 */
(ret == FALSE && GetLastError() == ERROR_PATH_NOT_FOUND), /* On NT! */
"CreateDirectoryA(%s): ret=%d err=%d\n", tmpdir, ret, GetLastError());
if (ret == TRUE)
{
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
}
GetTempPathA(MAX_PATH, tmpdir);
lstrcatA(tmpdir, "Please Remove Me");
ret = RemoveDirectoryA(tmpdir);
ok(ret == TRUE,
"RemoveDirectoryA(%s) failed err=%d\n", tmpdir, GetLastError());
SetCurrentDirectoryW(curdir);
}
static void init_strings(void)
{
char startup[MAX_PATH];
char commonprograms[MAX_PATH];
char programs[MAX_PATH];
if (pSHGetSpecialFolderPathA)
{
pSHGetSpecialFolderPathA(NULL, programs, CSIDL_PROGRAMS, FALSE);
pSHGetSpecialFolderPathA(NULL, commonprograms, CSIDL_COMMON_PROGRAMS, FALSE);
pSHGetSpecialFolderPathA(NULL, startup, CSIDL_STARTUP, FALSE);
}
else
{
HKEY key;
DWORD size;
/* Older Win9x and NT4 */
RegOpenKeyA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &key);
size = sizeof(programs);
RegQueryValueExA(key, "Programs", NULL, NULL, (LPBYTE)&programs, &size);
size = sizeof(startup);
RegQueryValueExA(key, "Startup", NULL, NULL, (LPBYTE)&startup, &size);
RegCloseKey(key);
RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &key);
size = sizeof(commonprograms);
RegQueryValueExA(key, "Common Programs", NULL, NULL, (LPBYTE)&commonprograms, &size);
RegCloseKey(key);
}
/* ProgramsDir on Vista+ is always the users one (CSIDL_PROGRAMS). Before Vista
* it depends on whether the user is an administrator (CSIDL_COMMON_PROGRAMS) or
* not (CSIDL_PROGRAMS).
*/
if (use_common())
lstrcpyA(ProgramsDir, commonprograms);
else
lstrcpyA(ProgramsDir, programs);
if (full_title())
{
lstrcpyA(Group1Title, ProgramsDir);
lstrcatA(Group1Title, "\\Group1");
lstrcpyA(Group2Title, ProgramsDir);
lstrcatA(Group2Title, "\\Group2");
lstrcpyA(Group3Title, ProgramsDir);
lstrcatA(Group3Title, "\\Group3");
lstrcpyA(StartupTitle, startup);
}
else
{
/* Vista has the nice habit of displaying the full path in English
* and the short one localized. CSIDL_STARTUP on Vista gives us the
* English version so we have to 'translate' this one.
*
* MSDN claims it should be used for files not folders but this one
* suits our purposes just fine.
*/
if (pSHGetLocalizedName)
{
WCHAR startupW[MAX_PATH];
WCHAR module[MAX_PATH];
WCHAR module_expanded[MAX_PATH];
WCHAR localized[MAX_PATH];
HRESULT hr;
int id;
MultiByteToWideChar(CP_ACP, 0, startup, -1, startupW, sizeof(startupW)/sizeof(WCHAR));
hr = pSHGetLocalizedName(startupW, module, MAX_PATH, &id);
todo_wine ok(hr == S_OK, "got 0x%08x\n", hr);
/* check to be removed when SHGetLocalizedName is implemented */
if (hr == S_OK)
{
ExpandEnvironmentStringsW(module, module_expanded, MAX_PATH);
LoadStringW(GetModuleHandleW(module_expanded), id, localized, MAX_PATH);
WideCharToMultiByte(CP_ACP, 0, localized, -1, StartupTitle, sizeof(StartupTitle), NULL, NULL);
}
else
lstrcpyA(StartupTitle, (strrchr(startup, '\\') + 1));
}
else
{
lstrcpyA(StartupTitle, (strrchr(startup, '\\') + 1));
}
}
}
/* 1st set of tests */
static int DdeTestProgman(DWORD instance, HCONV hConv)
{
HDDEDATA hData;
UINT error;
int testnum;
char temppath[MAX_PATH];
char f1g1[MAX_PATH], f2g1[MAX_PATH], f3g1[MAX_PATH], f1g3[MAX_PATH], f2g3[MAX_PATH];
char itemtext[MAX_PATH + 20];
char comptext[2 * (MAX_PATH + 20) + 21];
testnum = 1;
/* Invalid Command */
DdeExecuteCommand(instance, hConv, "[InvalidCommand()]", &hData, &error, DDE_TEST_MISC|testnum++);
ok (error == DMLERR_NOTPROCESSED, "InvalidCommand(), expected error %s, received %s.\n",
GetStringFromError(DMLERR_NOTPROCESSED), GetStringFromError(error));
/* On Vista+ the files have to exist when adding a link */
GetTempPathA(MAX_PATH, temppath);
GetTempFileNameA(temppath, "dde", 0, f1g1);
GetTempFileNameA(temppath, "dde", 0, f2g1);
GetTempFileNameA(temppath, "dde", 0, f3g1);
GetTempFileNameA(temppath, "dde", 0, f1g3);
GetTempFileNameA(temppath, "dde", 0, f2g3);
/* CreateGroup Tests (including AddItem, DeleteItem) */
CreateGroupTest(instance, hConv, "[CreateGroup(Group1)]", DMLERR_NO_ERROR, "Group1", Group1Title, DDE_TEST_CREATEGROUP|testnum++);
CreateAddItemText(itemtext, f1g1, "f1g1Name");
AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f1g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
CreateAddItemText(itemtext, f2g1, "f2g1Name");
AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f2g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
DeleteItemTest(instance, hConv, "[DeleteItem(f2g1Name)]", DMLERR_NO_ERROR, "f2g1Name.lnk", "Group1", DDE_TEST_DELETEITEM|testnum++);
CreateAddItemText(itemtext, f3g1, "f3g1Name");
AddItemTest(instance, hConv, itemtext, DMLERR_NO_ERROR, "f3g1Name.lnk", "Group1", DDE_TEST_ADDITEM|testnum++);
CreateGroupTest(instance, hConv, "[CreateGroup(Group2)]", DMLERR_NO_ERROR, "Group2", Group2Title, DDE_TEST_CREATEGROUP|testnum++);
/* Create Group that already exists - same instance */
CreateGroupTest(instance, hConv, "[CreateGroup(Group1)]", DMLERR_NO_ERROR, "Group1", Group1Title, DDE_TEST_CREATEGROUP|testnum++);
/* ShowGroup Tests */
ShowGroupTest(instance, hConv, "[ShowGroup(Group1)]", DMLERR_NOTPROCESSED, "Group1", Group1Title, TRUE, DDE_TEST_SHOWGROUP|testnum++);
DeleteItemTest(instance, hConv, "[DeleteItem(f3g1Name)]", DMLERR_NO_ERROR, "f3g1Name.lnk", "Group1", DDE_TEST_DELETEITEM|testnum++);
ShowGroupTest(instance, hConv, "[ShowGroup(Startup,0)]", DMLERR_NO_ERROR, "Startup", StartupTitle, TRUE, DDE_TEST_SHOWGROUP|testnum++);
ShowGroupTest(instance, hConv, "[ShowGroup(Group1,0)]", DMLERR_NO_ERROR, "Group1", Group1Title, FALSE, DDE_TEST_SHOWGROUP|testnum++);
/* DeleteGroup Test - Note that Window is Open for this test */
DeleteGroupTest(instance, hConv, "[DeleteGroup(Group1)]", DMLERR_NO_ERROR, "Group1", DDE_TEST_DELETEGROUP|testnum++);
/* Compound Execute String Command */
lstrcpyA(comptext, "[CreateGroup(Group3)]");
CreateAddItemText(itemtext, f1g3, "f1g3Name");
lstrcatA(comptext, itemtext);
CreateAddItemText(itemtext, f2g3, "f2g3Name");
lstrcatA(comptext, itemtext);
CompoundCommandTest(instance, hConv, comptext, DMLERR_NO_ERROR, "Group3", Group3Title, "f1g3Name.lnk", "f2g3Name.lnk", DDE_TEST_COMPOUND|testnum++);
DeleteGroupTest(instance, hConv, "[DeleteGroup(Group3)]", DMLERR_NO_ERROR, "Group3", DDE_TEST_DELETEGROUP|testnum++);
/* Full Parameters of Add Item */
/* AddItem(CmdLine[,Name[,IconPath[,IconIndex[,xPos,yPos[,DefDir[,HotKey[,fMinimize[fSeparateSpace]]]]]]]) */
DeleteFileA(f1g1);
DeleteFileA(f2g1);
DeleteFileA(f3g1);
DeleteFileA(f1g3);
DeleteFileA(f2g3);
return testnum;
}
bool OS::GetOS(char* buf)
{
OSVERSIONINFOEXA osvi;
SYSTEM_INFO si;
GetSystemInfo(&si);
buf[0] = 0x00;
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEXA);
if (GetVersionExA((LPOSVERSIONINFOA)&osvi))
{
if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT &&
osvi.dwMajorVersion > 4)
{
lstrcpyA(buf, "Microsoft ");
if (osvi.dwMajorVersion == 6)
{
if (osvi.dwMinorVersion == 0)
{
if (osvi.wProductType == VER_NT_WORKSTATION)
{
lstrcatA(buf, "Windows Vista ");
}
else
{
lstrcatA(buf, "Windows Server 2008 ");
}
}
else if (osvi.dwMinorVersion == 1)
{
if (osvi.wProductType == VER_NT_WORKSTATION)
{
lstrcatA(buf, "Windows 7 ");
}
else
{
lstrcatA(buf, "Windows Server 2008 R2 ");
}
}
}
else if (osvi.dwMajorVersion == 5)
{
if (osvi.dwMinorVersion == 2)
{
if (GetSystemMetrics(SM_SERVERR2))
{
lstrcatA(buf, "Windows Server 2003 R2 ");
}
else if (osvi.wSuiteMask & VER_SUITE_STORAGE_SERVER)
{
lstrcatA(buf, "Windows Storage Server 2003");
}
else if (osvi.wSuiteMask & VER_SUITE_WH_SERVER)
{
lstrcatA(buf, "Windows Home Server");
}
else if (osvi.wProductType == VER_NT_WORKSTATION &&
si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
{
lstrcatA(buf, "Windows XP Professional x64 Edition");
}
else
{
lstrcatA(buf, "Windows Server 2003 ");
}
if (osvi.wProductType != VER_NT_WORKSTATION)
{
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64)
{
if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
{
lstrcatA(buf, "Datacenter Edition for Itanium-based Systems");
}
else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
{
lstrcatA(buf, "Enterprise Edition for Itanium-based Systems");
}
}
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
{
if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
{
lstrcatA(buf, "Datacenter x64 Edition");
}
else if(osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
{
lstrcatA(buf, "Enterprise x64 Edition");
}
else
{
lstrcatA(buf, "Standard x64 Edition");
}
}
else
{
if (osvi.wSuiteMask & VER_SUITE_COMPUTE_SERVER)
{
lstrcatA(buf, "Compute Cluster Edition");
}
else
{
if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
{
lstrcatA(buf, "Datacenter Edition");
}
else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
{
lstrcatA(buf, "Enterprise Edition");
}
else if (osvi.wSuiteMask & VER_SUITE_BLADE)
{
lstrcatA(buf, "Web Edition");
}
else
{
lstrcatA(buf, "Standard Edition");
}
}
}
}
}
else if (osvi.dwMinorVersion == 1)
{
lstrcatA(buf, "Windows XP ");
if (osvi.wSuiteMask & VER_SUITE_PERSONAL)
{
lstrcatA(buf, "Home Edition");
}
else
{
lstrcatA(buf, "Professional");
}
}
else if (osvi.dwMinorVersion == 0)
{
lstrcatA(buf, "Windows 2000 ");
if (osvi.wProductType == VER_NT_WORKSTATION)
{
lstrcatA(buf, "Professional");
}
else
{
if (osvi.wSuiteMask & VER_SUITE_DATACENTER)
{
lstrcatA(buf, "Datacenter Server");
}
else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE)
{
lstrcatA(buf, "Advanced Server");
}
else
{
lstrcatA(buf, "Server");
}
}
}
}
if (osvi.szCSDVersion[0] != 0x00)
{
lstrcatA(buf, " ");
lstrcatA(buf, osvi.szCSDVersion);
}
if (osvi.dwMajorVersion >= 6)
{
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
{
lstrcatA(buf, " 64-bit");
}
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
{
lstrcatA(buf, " 32-bit");
}
}
}
}
else
{
lstrcatA(buf, "Unknown");
}
return true;
}
static void testLoadLibraryEx(void)
{
CHAR path[MAX_PATH];
HMODULE hmodule;
HANDLE hfile;
BOOL ret;
hfile = CreateFileA("testfile.dll", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
ok(hfile != INVALID_HANDLE_VALUE, "Expected a valid file handle\n");
/* NULL lpFileName */
if (is_unicode_enabled)
{
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
}
else
win_skip("NULL filename crashes on WinMe\n");
/* empty lpFileName */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_DLL_NOT_FOUND, /* win9x */
"Expected ERROR_MOD_NOT_FOUND or ERROR_DLL_NOT_FOUND, got %d\n",
GetLastError());
/* hFile is non-NULL */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_INVALID_PARAMETER || /* win2k3 */
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Unexpected last error, got %d\n", GetLastError());
}
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", (HANDLE)0xdeadbeef, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_INVALID_PARAMETER || /* win2k3 */
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Unexpected last error, got %d\n", GetLastError());
}
/* try to open a file that is locked */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_SHARING_VIOLATION ||
GetLastError() == ERROR_FILE_NOT_FOUND, /* win9x */
"Expected ERROR_SHARING_VIOLATION or ERROR_FILE_NOT_FOUND, got %d\n",
GetLastError());
}
/* lpFileName does not matter */
if (is_unicode_enabled)
{
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(NULL, hfile, 0);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
ok(GetLastError() == ERROR_MOD_NOT_FOUND ||
GetLastError() == ERROR_INVALID_PARAMETER, /* win2k3 */
"Expected ERROR_MOD_NOT_FOUND or ERROR_INVALID_PARAMETER, got %d\n",
GetLastError());
}
CloseHandle(hfile);
/* load empty file */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("testfile.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
todo_wine
{
ok(GetLastError() == ERROR_FILE_INVALID ||
GetLastError() == ERROR_BAD_FORMAT, /* win9x */
"Expected ERROR_FILE_INVALID or ERROR_BAD_FORMAT, got %d\n",
GetLastError());
}
DeleteFileA("testfile.dll");
GetSystemDirectoryA(path, MAX_PATH);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
/* try invalid file handle */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, (HANDLE)0xdeadbeef, 0);
if (!hmodule) /* succeeds on xp and older */
ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError());
CloseHandle(hmodule);
/* load kernel32.dll with no path */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("kernel32.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
ok(GetLastError() == 0xdeadbeef ||
GetLastError() == ERROR_SUCCESS, /* win9x */
"Expected 0xdeadbeef or ERROR_SUCCESS, got %d\n", GetLastError());
CloseHandle(hmodule);
GetCurrentDirectoryA(MAX_PATH, path);
if (path[lstrlenA(path) - 1] != '\\')
lstrcatA(path, "\\");
lstrcatA(path, "kernel32.dll");
/* load kernel32.dll with an absolute path that does not exist */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA(path, NULL, LOAD_LIBRARY_AS_DATAFILE);
todo_wine
{
ok(hmodule == 0, "Expected 0, got %p\n", hmodule);
}
ok(GetLastError() == ERROR_FILE_NOT_FOUND ||
broken(GetLastError() == ERROR_INVALID_HANDLE), /* nt4 */
"Expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
/* Free the loaded dll when its the first time this dll is loaded
in process - First time should pass, second fail */
SetLastError(0xdeadbeef);
hmodule = LoadLibraryExA("comctl32.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
ok(hmodule != 0, "Expected valid module handle\n");
SetLastError(0xdeadbeef);
ret = FreeLibrary(hmodule);
ok(ret, "Expected to be able to free the module, failed with %d\n", GetLastError());
SetLastError(0xdeadbeef);
ret = FreeLibrary(hmodule);
ok(!ret, "Unexpected ability to free the module, failed with %d\n", GetLastError());
CloseHandle(hmodule);
}
static void test_legacy_filter_registration(void)
{
IFilterMapper2 *pMapper2 = NULL;
IFilterMapper *pMapper = NULL;
HRESULT hr;
static const WCHAR wszFilterName[] = {'T', 'e', 's', 't', 'f', 'i', 'l', 't', 'e', 'r', 0 };
static const CHAR szFilterName[] = "Testfilter";
static const WCHAR wszPinName[] = {'P', 'i', 'n', '1', 0 };
CLSID clsidFilter;
CHAR szRegKey[MAX_PATH];
static const CHAR szClsid[] = "CLSID";
WCHAR wszGuidstring[MAX_PATH];
CHAR szGuidstring[MAX_PATH];
LONG lRet;
HKEY hKey = NULL;
IEnumMoniker *pEnum = NULL;
BOOL found;
IEnumRegFilters *pRegEnum = NULL;
/* Test if legacy filter registration scheme works (filter is added to HKCR\Filter). IFilterMapper_RegisterFilter
* registers in this way. Filters so registered must then be accessible through both IFilterMapper_EnumMatchingFilters
* and IFilterMapper2_EnumMatchingFilters. */
hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC_SERVER,
&IID_IFilterMapper2, (LPVOID*)&pMapper2);
ok(hr == S_OK, "CoCreateInstance failed with %x\n", hr);
if (FAILED(hr)) goto out;
hr = IFilterMapper2_QueryInterface(pMapper2, &IID_IFilterMapper, (void **)&pMapper);
ok(hr == S_OK, "IFilterMapper2_QueryInterface failed with %x\n", hr);
if (FAILED(hr)) goto out;
/* Register a test filter. */
hr = CoCreateGuid(&clsidFilter);
ok(hr == S_OK, "CoCreateGuid failed with %x\n", hr);
lRet = StringFromGUID2(&clsidFilter, wszGuidstring, MAX_PATH);
ok(lRet > 0, "StringFromGUID2 failed\n");
if (!lRet) goto out;
WideCharToMultiByte(CP_ACP, 0, wszGuidstring, -1, szGuidstring, MAX_PATH, 0, 0);
lstrcpyA(szRegKey, szClsid);
lstrcatA(szRegKey, "\\");
lstrcatA(szRegKey, szGuidstring);
/* Register---- functions need a filter class key to write pin and pin media type data to. Create a bogus
* class key for it. */
lRet = RegCreateKeyExA(HKEY_CLASSES_ROOT, szRegKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL);
if (lRet == ERROR_ACCESS_DENIED)
skip("Not authorized to register filters\n");
else
{
ok(lRet == ERROR_SUCCESS, "RegCreateKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
/* Set default value - this is interpreted as "friendly name" later. */
lRet = RegSetValueExA(hKey, NULL, 0, REG_SZ, (LPBYTE)szFilterName, lstrlenA(szFilterName) + 1);
ok(lRet == ERROR_SUCCESS, "RegSetValueExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
if (hKey) RegCloseKey(hKey);
hKey = NULL;
hr = IFilterMapper_RegisterFilter(pMapper, clsidFilter, wszFilterName, MERIT_UNLIKELY);
ok(hr == S_OK, "IFilterMapper_RegisterFilter failed with %x\n", hr);
hr = IFilterMapper_RegisterPin(pMapper, clsidFilter, wszPinName, TRUE, FALSE, FALSE, FALSE, GUID_NULL, NULL);
ok(hr == S_OK, "IFilterMapper_RegisterPin failed with %x\n", hr);
hr = IFilterMapper_RegisterPinType(pMapper, clsidFilter, wszPinName, GUID_NULL, GUID_NULL);
ok(hr == S_OK, "IFilterMapper_RegisterPinType failed with %x\n", hr);
hr = IFilterMapper2_EnumMatchingFilters(pMapper2, &pEnum, 0, TRUE, MERIT_UNLIKELY, TRUE,
0, NULL, NULL, &GUID_NULL, FALSE, FALSE, 0, NULL, NULL, &GUID_NULL);
ok(hr == S_OK, "IFilterMapper2_EnumMatchingFilters failed with %x\n", hr);
if (SUCCEEDED(hr) && pEnum)
{
found = enum_find_filter(wszFilterName, pEnum);
ok(found, "IFilterMapper2_EnumMatchingFilters failed to return the test filter\n");
}
if (pEnum) IEnumMoniker_Release(pEnum);
pEnum = NULL;
found = FALSE;
hr = IFilterMapper_EnumMatchingFilters(pMapper, &pRegEnum, MERIT_UNLIKELY, TRUE, GUID_NULL, GUID_NULL,
FALSE, FALSE, GUID_NULL, GUID_NULL);
ok(hr == S_OK, "IFilterMapper_EnumMatchingFilters failed with %x\n", hr);
if (SUCCEEDED(hr) && pRegEnum)
{
ULONG cFetched;
REGFILTER *prgf;
while(!found && IEnumRegFilters_Next(pRegEnum, 1, &prgf, &cFetched) == S_OK)
{
CHAR val[512];
WideCharToMultiByte(CP_ACP, 0, prgf->Name, -1, val, sizeof(val), 0, 0);
if (!lstrcmpA(val, szFilterName)) found = TRUE;
CoTaskMemFree(prgf);
}
IEnumRegFilters_Release(pRegEnum);
}
ok(found, "IFilterMapper_EnumMatchingFilters failed to return the test filter\n");
hr = IFilterMapper_UnregisterFilter(pMapper, clsidFilter);
ok(hr == S_OK, "FilterMapper_UnregisterFilter failed with %x\n", hr);
lRet = RegOpenKeyExA(HKEY_CLASSES_ROOT, szClsid, 0, KEY_WRITE | DELETE, &hKey);
ok(lRet == ERROR_SUCCESS, "RegOpenKeyExA failed with %x\n", HRESULT_FROM_WIN32(lRet));
lRet = RegDeleteKeyA(hKey, szGuidstring);
ok(lRet == ERROR_SUCCESS, "RegDeleteKeyA failed with %x\n", HRESULT_FROM_WIN32(lRet));
}
if (hKey) RegCloseKey(hKey);
hKey = NULL;
out:
if (pMapper) IFilterMapper_Release(pMapper);
if (pMapper2) IFilterMapper2_Release(pMapper2);
}