uzix/KernelEx
1
0
Fork 0
mirror of https://github.com/UzixLS/KernelEx.git synced 2025-07-18 15:01:17 +03:00
Code Issues Projects Releases Wiki Activity

import KernelEx-4.5-Beta2

Browse Source
This commit is contained in:
UzixLS
2018-11-03 16:21:44 +03:00
parent 09929b2b7d
commit 2e7f4ba60c
47 changed files with 9203 additions and 8829 deletions
Download Patch File Download Diff File Expand all files Collapse all files

20
CHANGELOG.txt
View File

@ -1,3 +1,23 @@
KernelEx v4.5 Beta 2 by Xeno86
2010-02-14
fixed incompatibility with Japanese WinME
implemented USP font cache
fix: kexFlushAppSettings didn't clear wildcard app settings
fix: EnumFontFamiliesEx should only fill TEXTMETRIC structure if font is not TrueType
FONTSIGNATURE sub-structure doesn't seem to contain valid information, accessing it could trigger a crash
changed AddFontMemResourceEx and RemoveFontMemResourceEx stubs for Opera 10.50 beta compatibility
implemented shell32.SHParseDisplayName [xp and above]
implemented winspool.EnumPrintersW
added advapi32.CreateProcessWithLogonW, InitiateSystemShutdownEx stubs
replaced thread-pool implementation with custom code
added timer-queue functions
updated jemalloc to version from FF3.6
added checks to alloc/realloc/free to make jemalloc more fault tolerant - better match Windows 9x behaviour
kexCOM: LoadLibrary(self) trick to prevent premature unload in buggy programs
---------------------------------------
KernelEx v4.5 Beta 1 by Xeno86
2010-01-18

2
KernelEx.nsi
View File

@ -1,4 +1,4 @@
!define _VERSION '4.5 Beta 1'
!define _VERSION '4.5 Beta 2'
!ifndef _DEBUG
!define FLAVOUR 'Release'

19
NEWS.txt
View File

@ -1,3 +1,22 @@
KernelEx v4.5 Beta 2 by Xeno86
2010-02-14
What's new:
----------------------------------
* Implemented Uniscribe font caching (improves Firefox 3 performance).
* New thread pool implementation (fixes IE6 problems).
* Fixed rare font related Firefox 3 crash.
* Implemted timer queue APIs.
* Implemented SHParseDisplayName and restricted to XP+ configs to fix Firefox mailto issues.
* Fixed premature kexCOM unloading crashing Photoshop 5 and other buggy apps.
* Updated jemalloc to version from FF3.6.
* Fixed jemalloc sensitiveness to invalid pointers. Fixes vmwareuser, cvtaplog crashing.
* Implemented EnumPrintersW (Foxit 3.1 Unicode printing support).
* Fixed Opera 10.50 Beta Acid3 crash.
* Other small fixes / stubs.
#################################################
KernelEx v4.5 Beta 1 by Xeno86
2010-01-18

3
apilibs/CORE.INI
View File

@ -27,6 +27,7 @@ GDI32.SetMapMode=std
KERNEL32.VerSetConditionMask=none
KERNEL32.VerifyVersionInfoA=none
KERNEL32.VerifyVersionInfoW=none
SHELL32.SHParseDisplayName=none
[DCFG1.names.Me]
KERNEL32.GetVersion=std
@ -43,6 +44,7 @@ KERNEL32.VerifyVersionInfoW=none
USER32.AllowSetForegroundWindow=std
USER32.LockSetForegroundWindow=std
USER32.GetMouseMovePointsEx=std
SHELL32.SHParseDisplayName=none
[WIN95]
inherit=DCFG1
@ -109,6 +111,7 @@ KERNEL32.GetVersionExA=kexbases.6
KERNEL32.GetVersionExW=kexbases.6
KERNEL32.VerifyVersionInfoA=kexbases.1
KERNEL32.VerifyVersionInfoW=kexbases.1
SHELL32.SHParseDisplayName=kexbasen.0
[WIN2K3]
inherit=WINXP

100
apilibs/kexbasen/gdi32/ScriptCache.cpp Executable file
View File

@ -0,0 +1,100 @@
/*
* KernelEx
* Copyright (C) 2010, Tihiy, Xeno86
*
* This file is part of KernelEx source code.
*
* KernelEx is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation; version 2 of the License.
*
* KernelEx is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include "ScriptCache.h"
ScriptCache ScriptCache::instance;
ScriptCache::ScriptCache()
{
InitializeCriticalSection(&cs);
}
ScriptCache::~ScriptCache()
{
DeleteCriticalSection(&cs);
}
SCRIPT_CACHE ScriptCache::GetCache(HFONT hFont)
{
list<FONTCACHE>::const_iterator it;
for (it = cache.begin(); it != cache.end(); it++)
{
if (it->hFont == hFont)
return it->cache;
}
return NULL;
}
void ScriptCache::SetCache(HFONT hFont,SCRIPT_CACHE newcache)
{
list<FONTCACHE>::iterator it;
for (it = cache.begin(); it != cache.end(); it++)
{
if (it->hFont == hFont)
break;
}
if (it == cache.end())
{
FONTCACHE fc;
fc.hFont = hFont;
fc.cache = newcache;
cache.push_front(fc);
}
else
{
it->cache = newcache;
cache.splice(cache.begin(), cache, it);
}
if (cache.size() > MAXSCRIPTCACHESIZE)
{
list<FONTCACHE>::reference ref = cache.back();
ScriptFreeCache(&ref.cache);
cache.pop_back();
}
}
void ScriptCache::ResetCache(HFONT hFont)
{
Lock();
list<FONTCACHE>::iterator it;
for (it = cache.begin(); it != cache.end(); it++)
{
if (it->hFont == hFont)
{
ScriptFreeCache(&it->cache);
cache.erase(it);
break;
}
}
Unlock();
}
void ScriptCache::Lock()
{
EnterCriticalSection(&cs);
}
void ScriptCache::Unlock()
{
LeaveCriticalSection(&cs);
}

59
apilibs/kexbasen/gdi32/ScriptCache.h Executable file
View File

@ -0,0 +1,59 @@
/*
* KernelEx
* Copyright (C) 2010, Tihiy, Xeno86
*
* This file is part of KernelEx source code.
*
* KernelEx is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation; version 2 of the License.
*
* KernelEx is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#ifndef __SCRIPTCACHE_H
#define __SCRIPTCACHE_H
#include <windows.h>
#include <usp10.h>
#pragma warning(disable:4530) //we don't do exception handling
#include <list>
#pragma warning(default:4530)
#define MAXSCRIPTCACHESIZE 10
typedef struct
{
HFONT hFont;
SCRIPT_CACHE cache;
} FONTCACHE, *PFONTCACHE;
using namespace std;
class ScriptCache
{
public:
static ScriptCache instance;
~ScriptCache();
SCRIPT_CACHE GetCache(HFONT hFont);
void SetCache(HFONT hFont, SCRIPT_CACHE newcache);
void ResetCache(HFONT hFont);
void Lock();
void Unlock();
private:
list<FONTCACHE> cache;
CRITICAL_SECTION cs;
ScriptCache();
};
#endif

63
apilibs/kexbasen/gdi32/UberGDI.c
View File

@ -1,14 +1,14 @@
/*
* KernelEx
*
* Copyright (C) 2008, 2010, Tihiy
* This file is part of KernelEx source code.
*
* Copyright 1993 Alexandre Julliard
* 1997 Alex Korobka
* Copyright 2002,2003 Shachar Shemesh
* Copyright 2003 CodeWeavers Inc. (Ulrich Czekalla)
*
* Copyright (C) 2008, Tihiy
* This file is part of KernelEx source code.
*
* KernelEx is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation; version 2 of the License.
@ -28,6 +28,17 @@
#include <windows.h>
#include "common.h"
#include <usp10.h>
#include "ScriptCache.h"
#ifdef __cplusplus
extern "C"
#endif
__declspec(dllexport)
void DeleteUSPFontCache(HFONT hFont)
{
ScriptCache::instance.ResetCache(hFont);
}
/* MAKE_EXPORT GetGlyphIndicesW_new=GetGlyphIndicesW */
int WINAPI GetGlyphIndicesW_new(
@ -39,10 +50,16 @@ int WINAPI GetGlyphIndicesW_new(
)
{
HRESULT result;
SCRIPT_CACHE cache = 0;
if (!hdc || !pgi || (UINT)lpstr<0xFFFFu || !c) return GDI_ERROR;
ScriptCache::instance.Lock();
HFONT hFont = (HFONT)GetCurrentObject(hdc,OBJ_FONT);
SCRIPT_CACHE cache = ScriptCache::instance.GetCache(hFont);
result = ScriptGetCMap(hdc,&cache,lpstr,c,0,pgi);
if ( !( result == S_OK || result == S_FALSE ) ) return GDI_ERROR;
if ( !( result == S_OK || result == S_FALSE ) )
{
ScriptCache::instance.Unlock();
return GDI_ERROR;
}
if ( fl && result == S_FALSE)
{
WORD* checkglyph = pgi;
@ -56,7 +73,8 @@ int WINAPI GetGlyphIndicesW_new(
checkglyph++;
}
}
ScriptFreeCache(&cache);
ScriptCache::instance.SetCache(hFont,cache); \
ScriptCache::instance.Unlock();
return c;
}
@ -115,7 +133,6 @@ BOOL WINAPI GetTextExtentExPointI_new(
LPSIZE lpSize // string dimensions
)
{
SCRIPT_CACHE cache = 0;
ABC abc;
WORD* glyph = pgiIn;
int* dxs = alpDx;
@ -129,6 +146,11 @@ BOOL WINAPI GetTextExtentExPointI_new(
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ScriptCache::instance.Lock();
HFONT hFont = (HFONT)GetCurrentObject(hdc,OBJ_FONT);
SCRIPT_CACHE cache = ScriptCache::instance.GetCache(hFont);
//in UberKern, ScriptPlace was used. However, it's too costly...
//so let's compute the info ourselves
for (i = 0; i < cgi; i++)
@ -145,8 +167,11 @@ BOOL WINAPI GetTextExtentExPointI_new(
glyph++;
}
lpSize->cx = sum;
ScriptCacheGetHeight(hdc,&cache,&lpSize->cy);
ScriptFreeCache(&cache);
ScriptCache::instance.SetCache(hFont,cache);
ScriptCache::instance.Unlock();
return TRUE;
}
@ -170,7 +195,6 @@ BOOL WINAPI GetCharWidthI_new(
INT* lpBuffer // buffer for widths
)
{
SCRIPT_CACHE cache = 0;
ABC abc;
WORD glyph;
@ -179,6 +203,11 @@ BOOL WINAPI GetCharWidthI_new(
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ScriptCache::instance.Lock();
HFONT hFont = (HFONT)GetCurrentObject(hdc,OBJ_FONT);
SCRIPT_CACHE cache = ScriptCache::instance.GetCache(hFont);
if ( !pgi ) //cgi glyphs starting giFirst
{
for ( glyph = giFirst; glyph < giFirst+cgi; glyph++)
@ -198,7 +227,9 @@ BOOL WINAPI GetCharWidthI_new(
lpBuffer++;
}
}
ScriptFreeCache(&cache);
ScriptCache::instance.SetCache(hFont,cache); \
ScriptCache::instance.Unlock();
return TRUE;
}
@ -213,14 +244,17 @@ BOOL WINAPI GetCharABCWidthsI_new(
LPABC lpabc // array of character widths
)
{
SCRIPT_CACHE cache = 0;
WORD glyph;
WORD glyph;
if ( !hdc || !lpabc || cgi<=0)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
ScriptCache::instance.Lock();
HFONT hFont = (HFONT)GetCurrentObject(hdc,OBJ_FONT);
SCRIPT_CACHE cache = ScriptCache::instance.GetCache(hFont);
if ( !pgi ) //cgi glyphs starting giFirst
{
for ( glyph = giFirst; glyph < giFirst+cgi; glyph++)
@ -238,7 +272,8 @@ BOOL WINAPI GetCharABCWidthsI_new(
lpabc++;
}
}
ScriptFreeCache(&cache);
ScriptCache::instance.SetCache(hFont,cache); \
ScriptCache::instance.Unlock();
return TRUE;
}

840
apilibs/kexbasen/kernel32/ThreadPool.c
View File

@ -1,7 +1,6 @@
/*
* KernelEx
* Copyright (C) 2009, Tihiy
* Copyright (c) 2006 Robert Shearman (WINE Project)
* Copyright (C) 2009-2010, Tihiy
*
* This file is part of KernelEx source code.
*
@ -21,6 +20,7 @@
*/
#include <windows.h>
#include <malloc.h>
#include "shlord.h"
/*
@ -30,13 +30,21 @@
* RegisterWaitForSingleObjectEx
* UnregisterWait
* UnregisterWaitEx
* CreateTimerQueue
* CreateTimerQueueTimer
* DeleteTimerQueue
* DeleteTimerQueueEx
* DeleteTimerQueueTimer
* all functions could be implemented with shlwapi,
* but they don't support async de-registration and most flags
* Also, Wine functions can cause problems in cases like
* when second unregister is called, or handle is reused...
* But Windows XP also fails hard in such cases.
* but they don't support async de-registration and most flags.
* Wine code was completely purged outta here - it's no good.
*/
/* RegisterWait/TimerQueues are implemented using waitable timers,
* unlike wine/shlwapi/whatever implementations exist.
*/
#define TPS_EXECUTEIO 0x00000001
#define TPS_LONGEXECTIME 0x00000008
@ -64,107 +72,379 @@ BOOL WINAPI QueueUserWorkItem_new( LPTHREAD_START_ROUTINE Function, PVOID Contex
return SHQueueUserWorkItem( Function, Context, 0, NULL, NULL, NULL, dwFlags );
}
//registerwait routines
//256h should be enough for everyone
#define MAX_WAIT_ITEMS (MAXIMUM_WAIT_OBJECTS / 2)
#define MAX_WAIT_THREADS 8
#define WAIT_STATE_ACTIVE 0 //item is in wait thread
#define WAIT_STATE_UNREGISTERED 1 //item is unregistered and queued to be removed from wait thread
#define WAIT_STATE_REMOVED 2 //item is removed from wait thread
#define WAIT_STATE_DELETESYNC 3 //item will be destroyed with removal
#define WAIT_STATE_GAMEOVER 4 //item is destroyed
#define WAIT_STATE_ABANDONED 5 //item expired and removed from wait thread but not yet unregistered
#define NONSENSE 10000
// RegisterWaitForSingleObject routines.
typedef struct
{
HANDLE Object;
HANDLE CancelEvent;
HANDLE TimerObject;
WAITORTIMERCALLBACK Callback;
PVOID Context;
ULONG Milliseconds;
ULONG Flags;
HANDLE CompletionEvent;
LONG DeleteCount;
BOOLEAN CallbackInProgress;
} wait_work_item_struct, *wait_work_item_ptr;
PVOID waitThread;
LONG State;
LONG CallbacksPending;
HANDLE CompletionEvent;
HANDLE CallbackEvent;
} WAIT_WORK_ITEM, *PWAIT_WORK_ITEM;
static void delete_wait_work_item(wait_work_item_ptr wait_work_item)
typedef struct
{
CloseHandle( wait_work_item->CancelEvent );
wait_work_item->CancelEvent = 0; //in case someone tries to work on deleted handle
HeapFree( GetProcessHeap(), 0, wait_work_item );
HANDLE hThread;
HANDLE WaitEvent;
BOOL InSyncCallback;
LONG nItems;
PWAIT_WORK_ITEM waitItems[MAX_WAIT_ITEMS];
} WAIT_THREAD, *PWAIT_THREAD;
typedef struct
{
PWAIT_WORK_ITEM item;
BOOLEAN TimerOrWaitFired;
} ASYNC_CALL, *PASYNC_CALL;
static PWAIT_THREAD waitthreads[MAX_WAIT_THREADS] = {0};
static CRITICAL_SECTION wait_cs;
BOOL init_threadpool()
{
InitializeCriticalSection(&wait_cs);
return TRUE;
}
static DWORD CALLBACK wait_thread_proc(LPVOID Arg)
static VOID ActivateTimer(PWAIT_WORK_ITEM workItem)
{
wait_work_item_ptr wait_work_item = (wait_work_item_ptr)Arg;
BOOL alertable = (wait_work_item->Flags & WT_EXECUTEINIOTHREAD) ? TRUE : FALSE;
HANDLE handles[2] = { wait_work_item->Object, wait_work_item->CancelEvent };
HANDLE completion_event;
DWORD status;
if (workItem->Milliseconds != INFINITE)
{
LARGE_INTEGER timeout;
timeout.QuadPart = workItem->Milliseconds*(LONGLONG)-10000;
SetWaitableTimer(workItem->TimerObject,&timeout,0,NULL,NULL,FALSE);
}
}
static VOID DestroyWaitItem(PWAIT_WORK_ITEM workItem)
{
CloseHandle(workItem->CallbackEvent);
CloseHandle(workItem->TimerObject);
HeapFree(GetProcessHeap(),0,workItem);
}
while (TRUE)
{
status = WaitForMultipleObjectsEx( 2, handles, FALSE, wait_work_item->Milliseconds, alertable );
if (status == STATUS_WAIT_0 || status == STATUS_TIMEOUT)
{
BOOL TimerOrWaitFired = (status == STATUS_WAIT_0) ? FALSE : TRUE;
static VOID CALLBACK AddWaitItem(ULONG_PTR Arg)
{
PWAIT_WORK_ITEM workItem = (PWAIT_WORK_ITEM)Arg;
PWAIT_THREAD waitThread = (PWAIT_THREAD)workItem->waitThread;
int i;
for (i=0;i<waitThread->nItems;i++)
{
//we can't have one handle several times
if (waitThread->waitItems[i]->Object == workItem->Object)
{
workItem->waitThread = NULL;
SetEvent(workItem->CompletionEvent);
return;
}
}
waitThread->waitItems[waitThread->nItems] = workItem;
waitThread->nItems++;
SetEvent(workItem->CompletionEvent);
//what if callback will fire before RegisterWait... returns?
ActivateTimer(workItem);
}
wait_work_item->CallbackInProgress = TRUE;
wait_work_item->Callback( wait_work_item->Context, TimerOrWaitFired );
wait_work_item->CallbackInProgress = FALSE;
static VOID CALLBACK RemoveWaitItem(ULONG_PTR Arg)
{
PWAIT_WORK_ITEM workItem = (PWAIT_WORK_ITEM)Arg;
PWAIT_THREAD waitThread = (PWAIT_THREAD)workItem->waitThread;
int i, j;
for (i=0;i<MAX_WAIT_ITEMS;i++)
if (waitThread->waitItems[i] == workItem)
break;
if (i<MAX_WAIT_ITEMS)
{
for (j=i;j<waitThread->nItems-1;j++)
{
waitThread->waitItems[j]=waitThread->waitItems[j+1];
waitThread->waitItems[j+1]=NULL;
}
waitThread->nItems--;
}
//if unregister marked it for delete, kill it here
if (InterlockedCompareExchange(&workItem->State,WAIT_STATE_GAMEOVER,WAIT_STATE_DELETESYNC) == WAIT_STATE_DELETESYNC)
{
if (workItem->CompletionEvent) SetEvent(workItem->CompletionEvent);
DestroyWaitItem(workItem);
}
else
{
InterlockedCompareExchange(&workItem->State,WAIT_STATE_ABANDONED,WAIT_STATE_ACTIVE);
InterlockedCompareExchange(&workItem->State,WAIT_STATE_REMOVED,WAIT_STATE_UNREGISTERED); //mark it removed
}
}
if (wait_work_item->Flags & WT_EXECUTEONLYONCE)
break;
}
else
break; //CancelEvent signalled
}
static DWORD CALLBACK AsyncWaiterCall(LPVOID Arg)
{
PASYNC_CALL waiter = (PASYNC_CALL)Arg;
PWAIT_WORK_ITEM workItem = waiter->item;
if (workItem->State == WAIT_STATE_ACTIVE || workItem->State == WAIT_STATE_ABANDONED)
workItem->Callback(workItem->Context,waiter->TimerOrWaitFired);
LONG CallbacksPending = InterlockedDecrement(&workItem->CallbacksPending);
SetEvent(workItem->CallbackEvent);
if (CallbacksPending == 0 && workItem->State != WAIT_STATE_ACTIVE)
{
//if it's removed, all fine, destroy it here
if (InterlockedCompareExchange(&workItem->State,WAIT_STATE_GAMEOVER,WAIT_STATE_REMOVED) == WAIT_STATE_REMOVED)
{
if (workItem->CompletionEvent) SetEvent(workItem->CompletionEvent);
DestroyWaitItem(workItem);
}
else //destroy it with removal
InterlockedCompareExchange(&workItem->State,WAIT_STATE_DELETESYNC,WAIT_STATE_UNREGISTERED);
}
completion_event = wait_work_item->CompletionEvent;
if (completion_event)
SetEvent( completion_event );
HeapFree(GetProcessHeap(),0,Arg);
return 0;
}
if ( InterlockedIncrement( &wait_work_item->DeleteCount ) == 2 )
delete_wait_work_item( wait_work_item );
static VOID TerminateWaitThread(PWAIT_THREAD threadinfo)
{
int i;
EnterCriticalSection(&wait_cs);
for (i=0;i<MAX_WAIT_THREADS;i++)
{
if (waitthreads[i] == threadinfo)
{
waitthreads[i] = NULL;
break;
}
}
LeaveCriticalSection(&wait_cs);
//if thread died of failure, mark all wait items abandoned
for (i=0;i<threadinfo->nItems;i++)
InterlockedCompareExchange(&threadinfo->waitItems[i]->State,WAIT_STATE_ABANDONED,WAIT_STATE_ACTIVE);
//make sure there aren't any outstanding APCs
SleepEx(0,TRUE);
CloseHandle(threadinfo->hThread);
CloseHandle(threadinfo->WaitEvent);
HeapFree(GetProcessHeap(),0,threadinfo);
}
return 0;
static DWORD WaitThreadWait(PWAIT_THREAD threadinfo)
{
int i;
int nCount = threadinfo->nItems * 2;
HANDLE* handles = (HANDLE*)alloca(sizeof(HANDLE)*nCount);
for (i=0;i<threadinfo->nItems;i++)
{
handles[i*2] = threadinfo->waitItems[i]->Object;
handles[(i*2)+1] = threadinfo->waitItems[i]->TimerObject;
}
return WaitForMultipleObjectsEx(nCount,handles,FALSE,INFINITE,TRUE);
}
static DWORD CALLBACK WaitThreadProc(LPVOID Arg)
{
PWAIT_THREAD threadinfo = (PWAIT_THREAD)Arg;
//wait for first APC to come
SleepEx(INFINITE,TRUE);
while (TRUE)
{
SetEvent(threadinfo->WaitEvent);
if (!threadinfo->nItems) //no things to do, wait 3 seconds and leave
{
if (SleepEx(3000,TRUE)!=WAIT_IO_COMPLETION)
break;
else
continue;
}
DWORD status = WaitThreadWait(threadinfo);
ResetEvent(threadinfo->WaitEvent);
if (status == WAIT_FAILED) break; //FFFFFUUUU
if (status >= WAIT_OBJECT_0 && status <= WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS )
{
status -= WAIT_OBJECT_0;
PWAIT_WORK_ITEM workItem = threadinfo->waitItems[status/2];
BOOL TimerFired = (status & 1);
if (workItem->State != WAIT_STATE_ACTIVE) continue; //don't run if removed
if (workItem->CallbackEvent == NULL) //sync callback
{
SetEvent(threadinfo->WaitEvent);
threadinfo->InSyncCallback = TRUE;
workItem->Callback(workItem->Context,TimerFired);
threadinfo->InSyncCallback = FALSE;
}
else
{
PASYNC_CALL waiter = (PASYNC_CALL)HeapAlloc(GetProcessHeap(),0,sizeof(*waiter));
if (waiter)
{
waiter->item = workItem;
waiter->TimerOrWaitFired = TimerFired;
InterlockedIncrement(&workItem->CallbacksPending);
QueueUserWorkItem_new(AsyncWaiterCall,waiter,workItem->Flags);
}
}
if (workItem->Flags & WT_EXECUTEONLYONCE || workItem->Milliseconds == 0)
RemoveWaitItem((ULONG_PTR)workItem);
else
ActivateTimer(workItem);
}
}
TerminateWaitThread(threadinfo);
return 0;
}
static BOOL RegisterWaitItem(PWAIT_WORK_ITEM workItem)
{
EnterCriticalSection(&wait_cs);
BOOL success = FALSE;
int i;
for (i=0;i<MAX_WAIT_THREADS;i++)
{
if (waitthreads[i] == NULL)
{
DWORD dummy;
waitthreads[i] = (PWAIT_THREAD)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*waitthreads[i]));
if (waitthreads[i] != NULL)
waitthreads[i]->hThread = CreateThread(NULL, 0, WaitThreadProc, waitthreads[i], 0, &dummy);
if (waitthreads[i]->hThread == NULL)
{
HeapFree(GetProcessHeap(),0,waitthreads[i]);
waitthreads[i]=NULL;
break;
}
waitthreads[i]->WaitEvent = CreateEvent(NULL,TRUE,TRUE,NULL);
}
if (waitthreads[i]->nItems == MAX_WAIT_ITEMS || waitthreads[i]->InSyncCallback) //full or busy, gtfo
continue;
else
{
//try adding it
workItem->waitThread = waitthreads[i];
workItem->CompletionEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
if ( QueueUserAPC(AddWaitItem,waitthreads[i]->hThread,(ULONG_PTR)workItem) )
{
//wait until item is added
WaitForSingleObject(workItem->CompletionEvent,INFINITE);
success = (workItem->waitThread != NULL);
}
CloseHandle(workItem->CompletionEvent);
workItem->CompletionEvent = NULL;
if (success) break;
}
}
LeaveCriticalSection(&wait_cs);
return success;
}
static BOOL IsValidHandle( HANDLE hObject )
{
HANDLE newobject = NULL;
BOOL success = DuplicateHandle(GetCurrentProcess(),hObject,GetCurrentProcess(),&newobject,0,0,DUPLICATE_SAME_ACCESS);
if (success) CloseHandle(newobject);
return success;
}
/* MAKE_EXPORT RegisterWaitForSingleObject_new=RegisterWaitForSingleObject */
BOOL WINAPI RegisterWaitForSingleObject_new(PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback,
PVOID Context, ULONG dwMilliseconds, ULONG dwFlags)
BOOL WINAPI RegisterWaitForSingleObject_new(
PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback,
PVOID Context, ULONG dwMilliseconds, ULONG dwFlags)
{
//validate stuff first. we aren't Wine.
if (!phNewWaitObject || IsBadCodePtr((FARPROC)Callback) || WaitForSingleObject(hObject,0) == WAIT_FAILED)
if (!phNewWaitObject || IsBadCodePtr((FARPROC)Callback) || !IsValidHandle(hObject))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
wait_work_item_ptr wait_work_item;
wait_work_item = (wait_work_item_ptr)HeapAlloc(GetProcessHeap(), 0, sizeof(*wait_work_item));
PWAIT_WORK_ITEM newWorkItem = (PWAIT_WORK_ITEM)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*newWorkItem));
if (!newWorkItem) return FALSE;
newWorkItem->Object = hObject;
newWorkItem->Callback = Callback;
newWorkItem->Context = Context;
newWorkItem->Milliseconds = dwMilliseconds;
newWorkItem->Flags = dwFlags;
if (!(dwFlags & WT_EXECUTEINWAITTHREAD))
newWorkItem->CallbackEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
newWorkItem->State = WAIT_STATE_ACTIVE;
if (dwMilliseconds != INFINITE)
newWorkItem->TimerObject = CreateWaitableTimer(NULL,FALSE,NULL);
else
newWorkItem->TimerObject = CreateEvent(NULL,FALSE,FALSE,NULL); //dummy event which never fires
if (!wait_work_item)
if (!RegisterWaitItem(newWorkItem))
{
DestroyWaitItem(newWorkItem);
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return FALSE;
return FALSE;
}
if ( dwMilliseconds == 0 ) dwFlags |= WT_EXECUTEONLYONCE;
wait_work_item->Object = hObject;
wait_work_item->Callback = Callback;
wait_work_item->Context = Context;
wait_work_item->Milliseconds = dwMilliseconds;
wait_work_item->Flags = dwFlags;
wait_work_item->CallbackInProgress = FALSE;
wait_work_item->DeleteCount = 0;
wait_work_item->CompletionEvent = NULL;
wait_work_item->CancelEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if (!wait_work_item->CancelEvent)
{
HeapFree( GetProcessHeap(), 0, wait_work_item );
return FALSE;
}
*phNewWaitObject = (HANDLE)newWorkItem;
return TRUE;
}
if ( !QueueUserWorkItem_new(wait_thread_proc, wait_work_item, dwFlags) )
{
delete_wait_work_item( wait_work_item );
return FALSE;
}
*phNewWaitObject = (HANDLE)wait_work_item;
return TRUE;
/* MAKE_EXPORT UnregisterWaitEx_new=UnregisterWaitEx */
BOOL WINAPI UnregisterWaitEx_new( HANDLE WaitHandle, HANDLE CompletionEvent)
{
PWAIT_WORK_ITEM workItem = (PWAIT_WORK_ITEM)WaitHandle;
if (!workItem)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
//9x dies if we queue an apc into dead thread so avoid it at all costs
if ( InterlockedCompareExchange(&workItem->State,WAIT_STATE_UNREGISTERED,WAIT_STATE_ACTIVE)==WAIT_STATE_ACTIVE )
{
PWAIT_THREAD waitthread = (PWAIT_THREAD)workItem->waitThread;
if (!QueueUserAPC(RemoveWaitItem,waitthread->hThread,(ULONG_PTR)workItem))
return FALSE;
//make sure thread is in wait state and isn't doing sth with item we delete
WaitForSingleObject(waitthread->WaitEvent,NONSENSE);
}
InterlockedCompareExchange(&workItem->State,WAIT_STATE_REMOVED,WAIT_STATE_ABANDONED);
BOOL pending = FALSE;
if (workItem->CallbacksPending)
{
pending = TRUE;
if (CompletionEvent != NULL)
{
if (CompletionEvent == INVALID_HANDLE_VALUE)
{
//wait for callbacks to finish
while (workItem->CallbacksPending)
WaitForSingleObject(workItem->CallbackEvent,INFINITE);
pending = FALSE;
}
else
InterlockedExchangePointer(&workItem->CompletionEvent, CompletionEvent);
}
}
//all async callbacks are finished for sure?
if (!pending)
{
//yes? and the item is removed from thread?
if (InterlockedCompareExchange(&workItem->State,WAIT_STATE_GAMEOVER,WAIT_STATE_REMOVED) == WAIT_STATE_REMOVED)
DestroyWaitItem(workItem);
else //not removed? okay, it will be destroyed with removal
InterlockedCompareExchange(&workItem->State,WAIT_STATE_DELETESYNC,WAIT_STATE_UNREGISTERED);
}
//otherwise, there are still pending callbacks and item will be destroyed as soon as all callbacks end
if (pending)
{
SetLastError(ERROR_IO_PENDING);
return FALSE;
}
return TRUE;
}
/* MAKE_EXPORT RegisterWaitForSingleObjectEx_new=RegisterWaitForSingleObjectEx */
@ -179,60 +459,366 @@ HANDLE WINAPI RegisterWaitForSingleObjectEx_new(HANDLE hObject,
return NULL;
}
/* MAKE_EXPORT UnregisterWaitEx_new=UnregisterWaitEx */
BOOL WINAPI UnregisterWaitEx_new(HANDLE WaitHandle, HANDLE CompletionEvent)
{
if (!WaitHandle)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
BOOL pending = FALSE;
wait_work_item_ptr wait_work_item = (wait_work_item_ptr)WaitHandle;
if ( !SetEvent( wait_work_item->CancelEvent ) ) //signal cancel
return FALSE;
if (wait_work_item->CallbackInProgress)
{
if (CompletionEvent != NULL)
{
if (CompletionEvent == INVALID_HANDLE_VALUE)
{
CompletionEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
if (!CompletionEvent)
return FALSE;
InterlockedExchangePointer( &wait_work_item->CompletionEvent, CompletionEvent );
if (wait_work_item->CallbackInProgress)
WaitForSingleObject( CompletionEvent, INFINITE );
CloseHandle( CompletionEvent );
}
else
{
InterlockedExchangePointer( &wait_work_item->CompletionEvent, CompletionEvent );
if (wait_work_item->CallbackInProgress)
pending = TRUE;
}
}
else
pending = TRUE;
}
if ( InterlockedIncrement(&wait_work_item->DeleteCount) == 2 )
{
pending = FALSE; //somehow callback is complete already
delete_wait_work_item( wait_work_item );
}
if ( pending )
{
SetLastError(ERROR_IO_PENDING);
return FALSE;
}
return TRUE;
}
/* MAKE_EXPORT UnregisterWait_new=UnregisterWait */
BOOL WINAPI UnregisterWait_new(HANDLE WaitHandle)
{
return UnregisterWaitEx_new(WaitHandle,NULL);
}
// Timer Queue routines
#define MAX_TIMERS MAXIMUM_WAIT_OBJECTS
typedef struct
{
HANDLE TimerObject;
WAITORTIMERCALLBACK Callback;
PVOID Parameter;
ULONG DueTime;
DWORD Period;
ULONG Flags;
PVOID TimerQueue;
LONG State;
LONG CallbacksPending;
HANDLE CompletionEvent;
HANDLE CallbackEvent;
} TIMER_ITEM, *PTIMER_ITEM;
typedef struct
{
HANDLE hThread;
HANDLE WaitEvent;
HANDLE CompletionEvent;
LONG nItems;
PTIMER_ITEM timers[MAX_TIMERS];
} TIMER_QUEUE, *PTIMER_QUEUE;
static PTIMER_QUEUE defaultTimerQueue = NULL;
static VOID DestroyTimerItem(PTIMER_ITEM timer)
{
CloseHandle(timer->CallbackEvent);
CloseHandle(timer->TimerObject);
HeapFree(GetProcessHeap(),0,timer);
}
static VOID CALLBACK ChangeTimerItem(PTIMER_ITEM timer)
{
//(re)activate waitable timer
LARGE_INTEGER timeout;
timeout.QuadPart = timer->DueTime * (LONGLONG)-10000;
SetWaitableTimer(timer->TimerObject,&timeout,(timer->Flags & WT_EXECUTEONLYONCE) ? 0 : timer->Period,NULL,NULL,FALSE);
}
static VOID CALLBACK AddTimerItem(ULONG_PTR Arg)
{
PTIMER_ITEM timer = (PTIMER_ITEM)Arg;
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)timer->TimerQueue;
if (timerqueue->nItems == MAX_TIMERS) //too much timers
{
timer->TimerQueue = NULL;
SetEvent(timer->CompletionEvent);
return;
}
timerqueue->timers[timerqueue->nItems] = timer;
timerqueue->nItems++;
SetEvent(timer->CompletionEvent);
ChangeTimerItem(timer);
}
static VOID CALLBACK RemoveTimerItem(ULONG_PTR Arg)
{
PTIMER_ITEM timer = (PTIMER_ITEM)Arg;
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)timer->TimerQueue;
int i, j;
for (i=0;i<MAX_TIMERS;i++)
if (timerqueue->timers[i] == timer)
break;
if (i<MAX_TIMERS)
{
for (j=i;j<timerqueue->nItems-1;j++)
{
timerqueue->timers[j]=timerqueue->timers[j+1];
timerqueue->timers[j+1]=NULL;
}
timerqueue->nItems--;
}
//if unregister marked it for delete, kill it here
if (InterlockedCompareExchange(&timer->State,WAIT_STATE_GAMEOVER,WAIT_STATE_DELETESYNC) == WAIT_STATE_DELETESYNC)
{
if (timer->CompletionEvent) SetEvent(timer->CompletionEvent);
DestroyTimerItem(timer);
}
else
InterlockedCompareExchange(&timer->State,WAIT_STATE_REMOVED,WAIT_STATE_UNREGISTERED); //mark it removed
}
static DWORD CALLBACK AsyncTimerCall(LPVOID Arg)
{
PTIMER_ITEM timer = PTIMER_ITEM(Arg);
if (timer->State == WAIT_STATE_ACTIVE)
timer->Callback(timer->Parameter,TRUE);
LONG CallbacksPending = InterlockedDecrement(&timer->CallbacksPending);
SetEvent(timer->CallbackEvent);
if (CallbacksPending == 0 && timer->State != WAIT_STATE_ACTIVE)
{
//if it's removed, all fine, destroy it here
if (InterlockedCompareExchange(&timer->State,WAIT_STATE_GAMEOVER,WAIT_STATE_REMOVED) == WAIT_STATE_REMOVED)
{
if (timer->CompletionEvent) SetEvent(timer->CompletionEvent);
DestroyTimerItem(timer);
}
else //destroy it with removal
InterlockedCompareExchange(&timer->State,WAIT_STATE_DELETESYNC,WAIT_STATE_UNREGISTERED);
}
return 0;
}
/* MAKE_EXPORT DeleteTimerQueueTimer_new=DeleteTimerQueueTimer */
BOOL WINAPI DeleteTimerQueueTimer_new( HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent)
{
//absolutely equal to UnregisterWaitEx
if (!Timer)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
PTIMER_ITEM timer = (PTIMER_ITEM)Timer;
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)timer->TimerQueue;
if ( InterlockedCompareExchange(&timer->State,WAIT_STATE_UNREGISTERED,WAIT_STATE_ACTIVE)==WAIT_STATE_ACTIVE )
{
if (!QueueUserAPC(RemoveTimerItem,timerqueue->hThread,(ULONG_PTR)timer))
return FALSE;
//make sure thread is in wait state and isn't doing sth with item we delete
WaitForSingleObject(timerqueue->WaitEvent,NONSENSE);
}
BOOL pending = FALSE;
if (timer->CallbacksPending)
{
pending = TRUE;
if (CompletionEvent != NULL)
{
if (CompletionEvent == INVALID_HANDLE_VALUE)
{
while (timer->CallbacksPending)
WaitForSingleObject(timer->CallbackEvent,INFINITE);
pending = FALSE;
}
else
InterlockedExchangePointer(&timer->CompletionEvent, CompletionEvent);
}
}
if (!pending)
{
if (InterlockedCompareExchange(&timer->State,WAIT_STATE_GAMEOVER,WAIT_STATE_REMOVED) == WAIT_STATE_REMOVED)
DestroyTimerItem(timer);
else
InterlockedCompareExchange(&timer->State,WAIT_STATE_DELETESYNC,WAIT_STATE_UNREGISTERED);
}
if (pending)
{
SetLastError(ERROR_IO_PENDING);
return FALSE;
}
return TRUE;
}
static VOID CALLBACK TerminateTimerQueue(ULONG_PTR Arg)
{
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)Arg;
CloseHandle(timerqueue->hThread);
CloseHandle(timerqueue->WaitEvent);
HeapFree(GetProcessHeap(),0,timerqueue);
ExitThread(0);
}
static VOID CALLBACK FinishTimerQueue(ULONG_PTR Arg)
{
int i;
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)Arg;
EnterCriticalSection(&wait_cs);
if (defaultTimerQueue == timerqueue)
defaultTimerQueue = NULL;
LeaveCriticalSection(&wait_cs);
//delete all timers, waiting
for (i=timerqueue->nItems-1;i>=0;i--)
DeleteTimerQueueTimer_new( timerqueue, timerqueue->timers[i], INVALID_HANDLE_VALUE );
if (timerqueue->CompletionEvent)
SetEvent(timerqueue->CompletionEvent);
//queue object termination
QueueUserAPC(TerminateTimerQueue,GetCurrentThread(),Arg);
}
static DWORD TimerQueueWait(PTIMER_QUEUE timerqueue)
{
int i;
HANDLE* handles = (HANDLE*)alloca(sizeof(HANDLE)*timerqueue->nItems);
for (i=0;i<timerqueue->nItems;i++)
handles[i] = timerqueue->timers[i]->TimerObject;
return WaitForMultipleObjectsEx(timerqueue->nItems,handles,FALSE,INFINITE,TRUE);
}
static DWORD CALLBACK TimerQueueProc(LPVOID Arg)
{
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)Arg;
while (TRUE)
{
SetEvent(timerqueue->WaitEvent);
if (!timerqueue->nItems) //wait for items
{
SleepEx(INFINITE,TRUE);
continue;
}
DWORD status = TimerQueueWait(timerqueue);
ResetEvent(timerqueue->WaitEvent);
if (status == WAIT_FAILED) break; //uberfail
if (status >= WAIT_OBJECT_0 && status <= WAIT_OBJECT_0+MAXIMUM_WAIT_OBJECTS )
{
PTIMER_ITEM timer = timerqueue->timers[status-WAIT_OBJECT_0];
if (timer->State != WAIT_STATE_ACTIVE) continue;
if (timer->CallbackEvent == NULL) //sync callback
{
SetEvent(timerqueue->WaitEvent);
timer->Callback(timer->Parameter,TRUE);
}
else
{
InterlockedIncrement(&timer->CallbacksPending);
QueueUserWorkItem_new(AsyncTimerCall,timer,timer->Flags);
}
}
}
FinishTimerQueue((ULONG_PTR)timerqueue);
SleepEx(0,TRUE);
return 0;
}
/* MAKE_EXPORT CreateTimerQueue_new=CreateTimerQueue */
HANDLE WINAPI CreateTimerQueue_new(VOID)
{
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*timerqueue));
if (timerqueue != NULL)
{
DWORD dummy;
timerqueue->WaitEvent = CreateEvent(NULL,TRUE,TRUE,NULL);
timerqueue->hThread = CreateThread(NULL,0,TimerQueueProc,timerqueue,0,&dummy);
if (!timerqueue->hThread)
{
HeapFree(GetProcessHeap(),HEAP_ZERO_MEMORY,timerqueue);
timerqueue = NULL;
}
}
return (HANDLE)timerqueue;
}
/* MAKE_EXPORT CreateTimerQueueTimer_new=CreateTimerQueueTimer */
BOOL WINAPI CreateTimerQueueTimer_new( PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback,
PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags)
{
if (!phNewTimer || IsBadCodePtr((FARPROC)Callback))
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
*phNewTimer = NULL;
if (TimerQueue == NULL)
{
EnterCriticalSection(&wait_cs);
if (defaultTimerQueue == NULL)
defaultTimerQueue = (PTIMER_QUEUE)CreateTimerQueue_new();
TimerQueue = defaultTimerQueue;
LeaveCriticalSection(&wait_cs);
if (TimerQueue == NULL) return FALSE;
}
PTIMER_ITEM timer = (PTIMER_ITEM)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*timer));
timer->TimerQueue = TimerQueue;
timer->Callback = Callback;
timer->Parameter = Parameter;
timer->DueTime = DueTime;
timer->Period = Period;
timer->Flags = Flags;
timer->State = WAIT_STATE_ACTIVE;
timer->TimerObject = CreateWaitableTimer(NULL,FALSE,NULL);
if (!(Flags & WT_EXECUTEINTIMERTHREAD))
timer->CallbackEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
timer->CompletionEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
BOOL success = (BOOL)QueueUserAPC(AddTimerItem,((PTIMER_QUEUE)TimerQueue)->hThread,(ULONG_PTR)timer);
if (success)
{
WaitForSingleObject(timer->CompletionEvent,INFINITE);
CloseHandle(timer->CompletionEvent);
timer->CompletionEvent = NULL;
success = (timer->TimerObject != NULL);
if (success) *phNewTimer = timer;
}
return success;
}
/* MAKE_EXPORT DeleteTimerQueueEx_new=DeleteTimerQueueEx */
BOOL WINAPI DeleteTimerQueueEx_new( HANDLE TimerQueue, HANDLE CompletionEvent)
{
PTIMER_QUEUE timerqueue = (PTIMER_QUEUE)TimerQueue;
if (!timerqueue)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
if (CompletionEvent != NULL)
{
if (CompletionEvent == INVALID_HANDLE_VALUE)
timerqueue->CompletionEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
else
timerqueue->CompletionEvent = CompletionEvent;
}
QueueUserAPC(FinishTimerQueue,timerqueue->hThread,(ULONG_PTR)timerqueue);
if (CompletionEvent == INVALID_HANDLE_VALUE)
{
WaitForSingleObject(timerqueue->CompletionEvent,INFINITE);
CloseHandle(timerqueue->CompletionEvent);
}
return TRUE;
}
/* MAKE_EXPORT DeleteTimerQueue_new=DeleteTimerQueue */
BOOL WINAPI DeleteTimerQueue_new( HANDLE TimerQueue)
{
return DeleteTimerQueueEx_new(TimerQueue,NULL);
}
/* MAKE_EXPORT ChangeTimerQueueTimer_new=ChangeTimerQueueTimer */
BOOL WINAPI ChangeTimerQueueTimer_new( HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period)
{
PTIMER_ITEM timer = (PTIMER_ITEM)Timer;
if (!timer || timer->State != WAIT_STATE_ACTIVE)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
timer->DueTime = DueTime;
timer->Period = Period;
return (BOOL)QueueUserAPC((PAPCFUNC)ChangeTimerItem,((PTIMER_QUEUE)timer->TimerQueue)->hThread,(ULONG_PTR)timer);
}
//some undocumented APIs too...
/* MAKE_EXPORT CancelTimerQueueTimer_new=CancelTimerQueueTimer */
BOOL WINAPI CancelTimerQueueTimer_new( HANDLE TimerQueue, HANDLE Timer)
{
PTIMER_ITEM timer = (PTIMER_ITEM)Timer;
if (!timer || timer->State != WAIT_STATE_ACTIVE)
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
return CancelWaitableTimer(timer->TimerObject);
}
/* MAKE_EXPORT SetTimerQueueTimer_new=SetTimerQueueTimer */
HANDLE WINAPI SetTimerQueueTimer_new( HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo )
{
HANDLE newHandle = NULL;
CreateTimerQueueTimer_new(&newHandle,TimerQueue,Callback,Parameter,DueTime,Period,PreferIo ? WT_EXECUTEINIOTHREAD : WT_EXECUTEDEFAULT);
return newHandle;
}

13
apilibs/kexbasen/kernel32/_kernel32_apilist.c
View File

@ -23,19 +23,18 @@
#include "kexcoresdk.h"
#include "_kernel32_apilist.h"
extern BOOL init_threadpool();
extern BOOL init_jemalloc();
extern BOOL init_exttls();
extern void uninit_jemalloc();
extern void detach_exttls();
BOOL init_kernel32()
{
return init_jemalloc() && init_exttls();
return init_jemalloc() && init_exttls() && init_threadpool();
}
void uninit_kernel32()
{
uninit_jemalloc();
}
void detach_kernel32()
@ -49,6 +48,8 @@ static const apilib_named_api kernel32_named_apis[] =
DECL_API("BuildCommDCBAndTimeoutsW", BuildCommDCBAndTimeoutsW_fwd),
DECL_API("BuildCommDCBW", BuildCommDCBW_fwd),
DECL_API("CallNamedPipeW", CallNamedPipeW_fwd),
DECL_API("CancelTimerQueueTimer", CancelTimerQueueTimer_new),
DECL_API("ChangeTimerQueueTimer", ChangeTimerQueueTimer_new),
DECL_API("CommConfigDialogW", CommConfigDialogW_fwd),
DECL_API("CreateEventW", CreateEventW_fwd),
DECL_API("CreateFileMappingW", CreateFileMappingW_fwd),
@ -56,8 +57,13 @@ static const apilib_named_api kernel32_named_apis[] =
DECL_API("CreateMutexW", CreateMutexW_fwd),
DECL_API("CreateProcessW", CreateProcessW_fwd),
DECL_API("CreateSemaphoreW", CreateSemaphoreW_fwd),
DECL_API("CreateTimerQueue", CreateTimerQueue_new),
DECL_API("CreateTimerQueueTimer", CreateTimerQueueTimer_new),
DECL_API("CreateWaitableTimerW", CreateWaitableTimerW_fwd),
DECL_API("DelayLoadFailureHook", DelayLoadFailureHook_new),
DECL_API("DeleteTimerQueue", DeleteTimerQueue_new),
DECL_API("DeleteTimerQueueEx", DeleteTimerQueueEx_new),
DECL_API("DeleteTimerQueueTimer", DeleteTimerQueueTimer_new),
DECL_API("EnumCalendarInfoExW", EnumCalendarInfoExW_fwd),
DECL_API("EnumCalendarInfoW", EnumCalendarInfoW_fwd),
DECL_API("EnumDateFormatsExW", EnumDateFormatsExW_fwd),
@ -118,6 +124,7 @@ static const apilib_named_api kernel32_named_apis[] =
DECL_API("SetDefaultCommConfigW", SetDefaultCommConfigW_fwd),
DECL_API("SetEnvironmentVariableW", SetEnvironmentVariableW_fwd),
DECL_API("SetLocaleInfoW", SetLocaleInfoW_fwd),
DECL_API("SetTimerQueueTimer", SetTimerQueueTimer_new),
DECL_API("SetVolumeLabelW", SetVolumeLabelW_fwd),
DECL_API("TlsAlloc", TlsAlloc_new),
DECL_API("TlsFree", TlsFree_new),

10
apilibs/kexbasen/kernel32/_kernel32_apilist.h
View File

@ -33,9 +33,17 @@ extern const apilib_api_table apitable_kernel32;
FARPROC WINAPI DelayLoadFailureHook_new(LPSTR pszDllName, LPSTR pszProcName);
BOOL WINAPI QueueUserWorkItem_new(LPTHREAD_START_ROUTINE Function, PVOID Context, ULONG Flags);
BOOL WINAPI RegisterWaitForSingleObject_new(PHANDLE phNewWaitObject, HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags);
HANDLE WINAPI RegisterWaitForSingleObjectEx_new(HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags);
BOOL WINAPI UnregisterWaitEx_new(HANDLE WaitHandle, HANDLE CompletionEvent);
HANDLE WINAPI RegisterWaitForSingleObjectEx_new(HANDLE hObject, WAITORTIMERCALLBACK Callback, PVOID Context, ULONG dwMilliseconds, ULONG dwFlags);
BOOL WINAPI UnregisterWait_new(HANDLE WaitHandle);
BOOL WINAPI DeleteTimerQueueTimer_new(HANDLE TimerQueue, HANDLE Timer, HANDLE CompletionEvent);
HANDLE WINAPI CreateTimerQueue_new(VOID);
BOOL WINAPI CreateTimerQueueTimer_new(PHANDLE phNewTimer, HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, ULONG Flags);
BOOL WINAPI DeleteTimerQueueEx_new(HANDLE TimerQueue, HANDLE CompletionEvent);
BOOL WINAPI DeleteTimerQueue_new(HANDLE TimerQueue);
BOOL WINAPI ChangeTimerQueueTimer_new(HANDLE TimerQueue, HANDLE Timer, ULONG DueTime, ULONG Period);
BOOL WINAPI CancelTimerQueueTimer_new(HANDLE TimerQueue, HANDLE Timer);
HANDLE WINAPI SetTimerQueueTimer_new(HANDLE TimerQueue, WAITORTIMERCALLBACK Callback, PVOID Parameter, DWORD DueTime, DWORD Period, BOOL PreferIo);
DWORD WINAPI TlsAlloc_new(void);
BOOL WINAPI TlsFree_new(DWORD dwTlsIndex);
LPVOID WINAPI TlsGetValue_new2(DWORD dwTlsIndex);

31
apilibs/kexbasen/kernel32/allocator.c
View File

@ -1,6 +1,6 @@
/*
* KernelEx
* Copyright (C) 2009, Xeno86
* Copyright (C) 2009-2010, Xeno86
*
* This file is part of KernelEx source code.
*
@ -43,6 +43,8 @@
/* M A C R O S A N D W R A P P E R S */
/************************************************************************/
#include <stdlib.h>
#define malloc(a) je_malloc(a)
#define valloc(a) je_valloc(a)
#define calloc(a, b) je_calloc(a, b)
@ -79,11 +81,6 @@ BOOL init_jemalloc()
return TRUE;
}
void uninit_jemalloc()
{
malloc_print_stats();
}
/************************************************************************/
/* T H E C O D E */
/************************************************************************/
@ -193,8 +190,15 @@ BOOL WINAPI HeapFree_new(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)
{
if (hHeap == JM_HEAP_NORM || hHeap == JM_HEAP_EXCP)
{
free(lpMem);
return TRUE;
if (lpMem && idalloc(lpMem))
{
return TRUE;
}
else
{
SetLastError(ERROR_INVALID_PARAMETER);
return FALSE;
}
}
else
return HeapFree(hHeap, dwFlags, lpMem);
@ -206,6 +210,8 @@ DWORD WINAPI HeapSize_new(HANDLE hHeap, DWORD dwFlags, LPCVOID lpMem)
if (hHeap == JM_HEAP_NORM || hHeap == JM_HEAP_EXCP)
{
size_t usable = malloc_usable_size(lpMem);
if (usable == 0)
return (DWORD) -1;
int fs = footer_size_for_usable_size(usable);
return read_footer(lpMem, usable, fs);
@ -221,7 +227,14 @@ LPVOID WINAPI HeapReAlloc_new(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, DWORD d
{
LPVOID ret;
int fs = footer_size(dwBytes);
size_t usable = malloc_usable_size(lpMem);
size_t usable = lpMem ? malloc_usable_size(lpMem) : 0;
if (lpMem && usable == 0)
{
if (hHeap == JM_HEAP_EXCP || (dwFlags & HEAP_GENERATE_EXCEPTIONS))
RaiseException(STATUS_ACCESS_VIOLATION, 0, 0, NULL);
return NULL;
}
if (dwFlags & HEAP_REALLOC_IN_PLACE_ONLY)
{

13673
apilibs/kexbasen/kernel32/jemalloc/jemalloc.c
View File

File diff suppressed because it is too large Load Diff

271
apilibs/kexbasen/kernel32/jemalloc/jemalloc.h
View File

@ -1,177 +1,94 @@
#ifndef MOZ_MEMORY_WINDOWS
# include <stdbool.h>
#else
# include <windows.h>
# ifndef bool
# define bool BOOL
# endif
#endif
extern const char *_malloc_options;
/*
* jemalloc_stats() is not a stable interface. When using jemalloc_stats_t, be
* sure that the compiled results of jemalloc.c are in sync with this header
* file.
*/
typedef struct {
/*
* Run-time configuration settings.
*/
bool opt_abort; /* abort(3) on error? */
bool opt_junk; /* Fill allocated/free memory with 0xa5/0x5a? */
bool opt_utrace; /* Trace all allocation events? */
bool opt_sysv; /* SysV semantics? */
bool opt_xmalloc; /* abort(3) on OOM? */
bool opt_zero; /* Fill allocated memory with 0x0? */
size_t narenas; /* Number of arenas. */
size_t balance_threshold; /* Arena contention rebalance threshold. */
size_t quantum; /* Allocation quantum. */
size_t small_max; /* Max quantum-spaced allocation size. */
size_t large_max; /* Max sub-chunksize allocation size. */
size_t chunksize; /* Size of each virtual memory mapping. */
size_t dirty_max; /* Max dirty pages per arena. */
size_t reserve_min; /* reserve_low callback threshold. */
size_t reserve_max; /* Maximum reserve size before unmapping. */
/*
* Current memory usage statistics.
*/
size_t mapped; /* Bytes mapped (not necessarily committed). */
size_t committed; /* Bytes committed (readable/writable). */
size_t allocated; /* Bytes allocted (in use by application). */
size_t dirty; /* Bytes dirty (committed unused pages). */
size_t reserve_cur; /* Current memory reserve. */
} jemalloc_stats_t;
#ifndef MOZ_MEMORY_DARWIN
void *malloc(size_t size);
void *valloc(size_t size);
void *calloc(size_t num, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);
#endif
int posix_memalign(void **memptr, size_t alignment, size_t size);
void *memalign(size_t alignment, size_t size);
size_t malloc_usable_size(const void *ptr);
void jemalloc_stats(jemalloc_stats_t *stats);
/* The x*() functions never return NULL. */
void *xmalloc(size_t size);
void *xcalloc(size_t num, size_t size);
void *xrealloc(void *ptr, size_t size);
void *xmemalign(size_t alignment, size_t size);
/*
* The allocator maintains a memory reserve that is used to satisfy allocation
* requests when no additional memory can be acquired from the operating
* system. Under normal operating conditions, the reserve size is at least
* reserve_min bytes. If the reserve is depleted or insufficient to satisfy an
* allocation request, then condition notifications are sent to one or more of
* the registered callback functions:
*
* RESERVE_CND_LOW: The reserve had to be used to satisfy an allocation
* request, which dropped the reserve size below the
* minimum. The callee should try to free memory in order
* to restore the reserve.
*
* RESERVE_CND_CRIT: The reserve was not large enough to satisfy a pending
* allocation request. Some callee must free adequate
* memory in order to prevent application failure (unless
* the condition spontaneously desists due to concurrent
* deallocation).
*
* RESERVE_CND_FAIL: An allocation request could not be satisfied, despite all
* attempts. The allocator is about to terminate the
* application.
*
* The order in which the callback functions are called is only loosely
* specified: in the absence of interposing callback
* registrations/unregistrations, enabled callbacks will be called in an
* arbitrary round-robin order.
*
* Condition notifications are sent to callbacks only while conditions exist.
* For example, just before the allocator sends a RESERVE_CND_LOW condition
* notification to a callback, the reserve is in fact depleted. However, due
* to allocator concurrency, the reserve may have been restored by the time the
* callback function executes. Furthermore, if the reserve is restored at some
* point during the delivery of condition notifications to callbacks, no
* further deliveries will occur, since the condition no longer exists.
*
* Callback functions can freely call back into the allocator (i.e. the
* allocator releases all internal resources before calling each callback
* function), though allocation is discouraged, since recursive callbacks are
* likely to result, which places extra burden on the application to avoid
* deadlock.
*
* Callback functions must be thread-safe, since it is possible that multiple
* threads will call into the same callback function concurrently.
*/
/* Memory reserve condition types. */
typedef enum {
RESERVE_CND_LOW,
RESERVE_CND_CRIT,
RESERVE_CND_FAIL
} reserve_cnd_t;
/*
* Reserve condition notification callback function type definition.
*
* Inputs:
* ctx: Opaque application data, as passed to reserve_cb_register().
* cnd: Condition type being delivered.
* size: Allocation request size for the allocation that caused the condition.
*/
typedef void reserve_cb_t(void *ctx, reserve_cnd_t cnd, size_t size);
/*
* Register a callback function.
*
* Inputs:
* cb: Callback function pointer.
* ctx: Opaque application data, passed to cb().
*
* Output:
* ret: If true, failure due to OOM; success otherwise.
*/
bool reserve_cb_register(reserve_cb_t *cb, void *ctx);
/*
* Unregister a callback function.
*
* Inputs:
* cb: Callback function pointer.
* ctx: Opaque application data, same as that passed to reserve_cb_register().
*
* Output:
* ret: False upon success, true if the {cb,ctx} registration could not be
* found.
*/
bool reserve_cb_unregister(reserve_cb_t *cb, void *ctx);
/*
* Get the current reserve size.
*
* ret: Current reserve size.
*/
size_t reserve_cur_get(void);
/*
* Get the minimum acceptable reserve size. If the reserve drops below this
* value, the RESERVE_CND_LOW condition notification is sent to the callbacks.
*
* ret: Minimum acceptable reserve size.
*/
size_t reserve_min_get(void);
/*
* Set the minimum acceptable reserve size.
*
* min: Reserve threshold. This value may be internally rounded up.
* ret: False if the reserve was successfully resized; true otherwise. Note
* that failure to resize the reserve also results in a RESERVE_CND_LOW
* condition.
*/
bool reserve_min_set(size_t min);
/* -*- Mode: C; tab-width: 8; c-basic-offset: 8 -*- */
/* vim:set softtabstop=8 shiftwidth=8: */
/*-
* Copyright (C) 2006-2008 Jason Evans <jasone@FreeBSD.org>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice(s), this list of conditions and the following disclaimer as
* the first lines of this file unmodified other than the possible
* addition of one or more copyright notices.
* 2. Redistributions in binary form must reproduce the above copyright
* notice(s), this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _JEMALLOC_H_
#define _JEMALLOC_H_
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef unsigned char jemalloc_bool;
extern const char *_malloc_options;
/*
* jemalloc_stats() is not a stable interface. When using jemalloc_stats_t, be
* sure that the compiled results of jemalloc.c are in sync with this header
* file.
*/
typedef struct {
/*
* Run-time configuration settings.
*/
jemalloc_bool opt_abort; /* abort(3) on error? */
jemalloc_bool opt_junk; /* Fill allocated/free memory with 0xa5/0x5a? */
jemalloc_bool opt_utrace; /* Trace all allocation events? */
jemalloc_bool opt_sysv; /* SysV semantics? */
jemalloc_bool opt_xmalloc; /* abort(3) on OOM? */
jemalloc_bool opt_zero; /* Fill allocated memory with 0x0? */
size_t narenas; /* Number of arenas. */
size_t balance_threshold; /* Arena contention rebalance threshold. */
size_t quantum; /* Allocation quantum. */
size_t small_max; /* Max quantum-spaced allocation size. */
size_t large_max; /* Max sub-chunksize allocation size. */
size_t chunksize; /* Size of each virtual memory mapping. */
size_t dirty_max; /* Max dirty pages per arena. */
/*
* Current memory usage statistics.
*/
size_t mapped; /* Bytes mapped (not necessarily committed). */
size_t committed; /* Bytes committed (readable/writable). */
size_t allocated; /* Bytes allocted (in use by application). */
size_t dirty; /* Bytes dirty (committed unused pages). */
} jemalloc_stats_t;
#ifndef MOZ_MEMORY_DARWIN
void *malloc(size_t size);
void *valloc(size_t size);
void *calloc(size_t num, size_t size);
void *realloc(void *ptr, size_t size);
void free(void *ptr);
#endif
int posix_memalign(void **memptr, size_t alignment, size_t size);
void *memalign(size_t alignment, size_t size);
size_t malloc_usable_size(const void *ptr);
void jemalloc_stats(jemalloc_stats_t *stats);
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif /* _JEMALLOC_H_ */

228
apilibs/kexbasen/kernel32/jemalloc/ql.h
View File

@ -1,114 +1,114 @@
/******************************************************************************
*
* Copyright (C) 2002 Jason Evans <jasone@canonware.com>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice(s), this list of conditions and the following disclaimer
* unmodified other than the allowable addition of one or more
* copyright notices.
* 2. Redistributions in binary form must reproduce the above copyright
* notice(s), this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/*
* List definitions.
*/
#define ql_head(a_type) \
struct { \
a_type *qlh_first; \
}
#define ql_head_initializer(a_head) {NULL}
#define ql_elm(a_type) qr(a_type)
/* List functions. */
#define ql_new(a_head) do { \
(a_head)->qlh_first = NULL; \
} while (0)
#define ql_elm_new(a_elm, a_field) qr_new((a_elm), a_field)
#define ql_first(a_head) ((a_head)->qlh_first)
#define ql_last(a_head, a_field) \
((ql_first(a_head) != NULL) \
? qr_prev(ql_first(a_head), a_field) : NULL)
#define ql_next(a_head, a_elm, a_field) \
((ql_last(a_head, a_field) != (a_elm)) \
? qr_next((a_elm), a_field) : NULL)
#define ql_prev(a_head, a_elm, a_field) \
((ql_first(a_head) != (a_elm)) ? qr_prev((a_elm), a_field) \
: NULL)
#define ql_before_insert(a_head, a_qlelm, a_elm, a_field) do { \
qr_before_insert((a_qlelm), (a_elm), a_field); \
if (ql_first(a_head) == (a_qlelm)) { \
ql_first(a_head) = (a_elm); \
} \
} while (0)
#define ql_after_insert(a_qlelm, a_elm, a_field) \
qr_after_insert((a_qlelm), (a_elm), a_field)
#define ql_head_insert(a_head, a_elm, a_field) do { \
if (ql_first(a_head) != NULL) { \
qr_before_insert(ql_first(a_head), (a_elm), a_field); \
} \
ql_first(a_head) = (a_elm); \
} while (0)
#define ql_tail_insert(a_head, a_elm, a_field) do { \
if (ql_first(a_head) != NULL) { \
qr_before_insert(ql_first(a_head), (a_elm), a_field); \
} \
ql_first(a_head) = qr_next((a_elm), a_field); \
} while (0)
#define ql_remove(a_head, a_elm, a_field) do { \
if (ql_first(a_head) == (a_elm)) { \
ql_first(a_head) = qr_next(ql_first(a_head), a_field); \
} \
if (ql_first(a_head) != (a_elm)) { \
qr_remove((a_elm), a_field); \
} else { \
ql_first(a_head) = NULL; \
} \
} while (0)
#define ql_head_remove(a_head, a_type, a_field) do { \
a_type *t = ql_first(a_head); \
ql_remove((a_head), t, a_field); \
} while (0)
#define ql_tail_remove(a_head, a_type, a_field) do { \
a_type *t = ql_last(a_head, a_field); \
ql_remove((a_head), t, a_field); \
} while (0)
#define ql_foreach(a_var, a_head, a_field) \
qr_foreach((a_var), ql_first(a_head), a_field)
#define ql_reverse_foreach(a_var, a_head, a_field) \
qr_reverse_foreach((a_var), ql_first(a_head), a_field)
/******************************************************************************
*
* Copyright (C) 2002 Jason Evans <jasone@canonware.com>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice(s), this list of conditions and the following disclaimer
* unmodified other than the allowable addition of one or more
* copyright notices.
* 2. Redistributions in binary form must reproduce the above copyright
* notice(s), this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/*
* List definitions.
*/
#define ql_head(a_type) \
struct { \
a_type *qlh_first; \
}
#define ql_head_initializer(a_head) {NULL}
#define ql_elm(a_type) qr(a_type)
/* List functions. */
#define ql_new(a_head) do { \
(a_head)->qlh_first = NULL; \
} while (0)
#define ql_elm_new(a_elm, a_field) qr_new((a_elm), a_field)
#define ql_first(a_head) ((a_head)->qlh_first)
#define ql_last(a_head, a_field) \
((ql_first(a_head) != NULL) \
? qr_prev(ql_first(a_head), a_field) : NULL)
#define ql_next(a_head, a_elm, a_field) \
((ql_last(a_head, a_field) != (a_elm)) \
? qr_next((a_elm), a_field) : NULL)
#define ql_prev(a_head, a_elm, a_field) \
((ql_first(a_head) != (a_elm)) ? qr_prev((a_elm), a_field) \
: NULL)
#define ql_before_insert(a_head, a_qlelm, a_elm, a_field) do { \
qr_before_insert((a_qlelm), (a_elm), a_field); \
if (ql_first(a_head) == (a_qlelm)) { \
ql_first(a_head) = (a_elm); \
} \
} while (0)
#define ql_after_insert(a_qlelm, a_elm, a_field) \
qr_after_insert((a_qlelm), (a_elm), a_field)
#define ql_head_insert(a_head, a_elm, a_field) do { \
if (ql_first(a_head) != NULL) { \
qr_before_insert(ql_first(a_head), (a_elm), a_field); \
} \
ql_first(a_head) = (a_elm); \
} while (0)
#define ql_tail_insert(a_head, a_elm, a_field) do { \
if (ql_first(a_head) != NULL) { \
qr_before_insert(ql_first(a_head), (a_elm), a_field); \
} \
ql_first(a_head) = qr_next((a_elm), a_field); \
} while (0)
#define ql_remove(a_head, a_elm, a_field) do { \
if (ql_first(a_head) == (a_elm)) { \
ql_first(a_head) = qr_next(ql_first(a_head), a_field); \
} \
if (ql_first(a_head) != (a_elm)) { \
qr_remove((a_elm), a_field); \
} else { \
ql_first(a_head) = NULL; \
} \
} while (0)
#define ql_head_remove(a_head, a_type, a_field) do { \
a_type *t = ql_first(a_head); \
ql_remove((a_head), t, a_field); \
} while (0)
#define ql_tail_remove(a_head, a_type, a_field) do { \
a_type *t = ql_last(a_head, a_field); \
ql_remove((a_head), t, a_field); \
} while (0)
#define ql_foreach(a_var, a_head, a_field) \
qr_foreach((a_var), ql_first(a_head), a_field)
#define ql_reverse_foreach(a_var, a_head, a_field) \
qr_reverse_foreach((a_var), ql_first(a_head), a_field)

196
apilibs/kexbasen/kernel32/jemalloc/qr.h
View File

@ -1,98 +1,98 @@
/******************************************************************************
*
* Copyright (C) 2002 Jason Evans <jasone@canonware.com>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice(s), this list of conditions and the following disclaimer
* unmodified other than the allowable addition of one or more
* copyright notices.
* 2. Redistributions in binary form must reproduce the above copyright
* notice(s), this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/* Ring definitions. */
#define qr(a_type) \
struct { \
a_type *qre_next; \
a_type *qre_prev; \
}
/* Ring functions. */
#define qr_new(a_qr, a_field) do { \
(a_qr)->a_field.qre_next = (a_qr); \
(a_qr)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_next(a_qr, a_field) ((a_qr)->a_field.qre_next)
#define qr_prev(a_qr, a_field) ((a_qr)->a_field.qre_prev)
#define qr_before_insert(a_qrelm, a_qr, a_field) do { \
(a_qr)->a_field.qre_prev = (a_qrelm)->a_field.qre_prev; \
(a_qr)->a_field.qre_next = (a_qrelm); \
(a_qr)->a_field.qre_prev->a_field.qre_next = (a_qr); \
(a_qrelm)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_after_insert(a_qrelm, a_qr, a_field) \
do \
{ \
(a_qr)->a_field.qre_next = (a_qrelm)->a_field.qre_next; \
(a_qr)->a_field.qre_prev = (a_qrelm); \
(a_qr)->a_field.qre_next->a_field.qre_prev = (a_qr); \
(a_qrelm)->a_field.qre_next = (a_qr); \
} while (0)
#define qr_meld(a_qr_a, a_qr_b, a_field) do { \
void *t; \
(a_qr_a)->a_field.qre_prev->a_field.qre_next = (a_qr_b); \
(a_qr_b)->a_field.qre_prev->a_field.qre_next = (a_qr_a); \
t = (a_qr_a)->a_field.qre_prev; \
(a_qr_a)->a_field.qre_prev = (a_qr_b)->a_field.qre_prev; \
(a_qr_b)->a_field.qre_prev = t; \
} while (0)
/* qr_meld() and qr_split() are functionally equivalent, so there's no need to
* have two copies of the code. */
#define qr_split(a_qr_a, a_qr_b, a_field) \
qr_meld((a_qr_a), (a_qr_b), a_field)
#define qr_remove(a_qr, a_field) do { \
(a_qr)->a_field.qre_prev->a_field.qre_next \
= (a_qr)->a_field.qre_next; \
(a_qr)->a_field.qre_next->a_field.qre_prev \
= (a_qr)->a_field.qre_prev; \
(a_qr)->a_field.qre_next = (a_qr); \
(a_qr)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_foreach(var, a_qr, a_field) \
for ((var) = (a_qr); \
(var) != NULL; \
(var) = (((var)->a_field.qre_next != (a_qr)) \
? (var)->a_field.qre_next : NULL))
#define qr_reverse_foreach(var, a_qr, a_field) \
for ((var) = ((a_qr) != NULL) ? qr_prev(a_qr, a_field) : NULL; \
(var) != NULL; \
(var) = (((var) != (a_qr)) \
? (var)->a_field.qre_prev : NULL))
/******************************************************************************
*
* Copyright (C) 2002 Jason Evans <jasone@canonware.com>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice(s), this list of conditions and the following disclaimer
* unmodified other than the allowable addition of one or more
* copyright notices.
* 2. Redistributions in binary form must reproduce the above copyright
* notice(s), this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************/
/* Ring definitions. */
#define qr(a_type) \
struct { \
a_type *qre_next; \
a_type *qre_prev; \
}
/* Ring functions. */
#define qr_new(a_qr, a_field) do { \
(a_qr)->a_field.qre_next = (a_qr); \
(a_qr)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_next(a_qr, a_field) ((a_qr)->a_field.qre_next)
#define qr_prev(a_qr, a_field) ((a_qr)->a_field.qre_prev)
#define qr_before_insert(a_qrelm, a_qr, a_field) do { \
(a_qr)->a_field.qre_prev = (a_qrelm)->a_field.qre_prev; \
(a_qr)->a_field.qre_next = (a_qrelm); \
(a_qr)->a_field.qre_prev->a_field.qre_next = (a_qr); \
(a_qrelm)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_after_insert(a_qrelm, a_qr, a_field) \
do \
{ \
(a_qr)->a_field.qre_next = (a_qrelm)->a_field.qre_next; \
(a_qr)->a_field.qre_prev = (a_qrelm); \
(a_qr)->a_field.qre_next->a_field.qre_prev = (a_qr); \
(a_qrelm)->a_field.qre_next = (a_qr); \
} while (0)
#define qr_meld(a_qr_a, a_qr_b, a_field) do { \
void *t; \
(a_qr_a)->a_field.qre_prev->a_field.qre_next = (a_qr_b); \
(a_qr_b)->a_field.qre_prev->a_field.qre_next = (a_qr_a); \
t = (a_qr_a)->a_field.qre_prev; \
(a_qr_a)->a_field.qre_prev = (a_qr_b)->a_field.qre_prev; \
(a_qr_b)->a_field.qre_prev = t; \
} while (0)
/* qr_meld() and qr_split() are functionally equivalent, so there's no need to
* have two copies of the code. */
#define qr_split(a_qr_a, a_qr_b, a_field) \
qr_meld((a_qr_a), (a_qr_b), a_field)
#define qr_remove(a_qr, a_field) do { \
(a_qr)->a_field.qre_prev->a_field.qre_next \
= (a_qr)->a_field.qre_next; \
(a_qr)->a_field.qre_next->a_field.qre_prev \
= (a_qr)->a_field.qre_prev; \
(a_qr)->a_field.qre_next = (a_qr); \
(a_qr)->a_field.qre_prev = (a_qr); \
} while (0)
#define qr_foreach(var, a_qr, a_field) \
for ((var) = (a_qr); \
(var) != NULL; \
(var) = (((var)->a_field.qre_next != (a_qr)) \
? (var)->a_field.qre_next : NULL))
#define qr_reverse_foreach(var, a_qr, a_field) \
for ((var) = ((a_qr) != NULL) ? qr_prev(a_qr, a_field) : NULL; \
(var) != NULL; \
(var) = (((var) != (a_qr)) \
? (var)->a_field.qre_prev : NULL))

1964
apilibs/kexbasen/kernel32/jemalloc/rb.h
View File

File diff suppressed because it is too large Load Diff

16
apilibs/kexbasen/kexbasen.dsp
View File

@ -53,7 +53,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shlwapi.lib shell32.lib rpcrt4.lib usp10.lib ../../common/KernelEx.lib ../../kexcrt/kexcrt.lib libc.lib delayimp.lib /nologo /dll /map /machine:I386 /nodefaultlib /OPT:NOWIN98 /DELAYLOAD:shell32.dll /DELAYLOAD:rpcrt4.dll /DELAYLOAD:usp10.dll /DELAYLOAD:comdlg32.dll /DELAYLOAD:winspool.drv
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shlwapi.lib shell32.lib rpcrt4.lib usp10.lib ../../common/KernelEx.lib ../../kexcrt/kexcrt.lib libc.lib delayimp.lib /nologo /dll /map /machine:I386 /nodefaultlib /OPT:NOWIN98 /DELAYLOAD:shell32.dll /DELAYLOAD:rpcrt4.dll /DELAYLOAD:usp10.dll /DELAYLOAD:comdlg32.dll /DELAYLOAD:winspool.drv /DELAYLOAD:shlwapi.dll
# SUBTRACT LINK32 /pdb:none
!ELSEIF "$(CFG)" == "KernelEx Base NonShared - Win32 Debug"
@ -80,7 +80,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shlwapi.lib shell32.lib rpcrt4.lib usp10.lib ../../common/KernelEx.lib ../../kexcrt/kexcrt.lib libc.lib delayimp.lib /nologo /dll /map /debug /machine:I386 /nodefaultlib /OPT:NOWIN98 /DELAYLOAD:shell32.dll /DELAYLOAD:rpcrt4.dll /DELAYLOAD:usp10.dll /DELAYLOAD:comdlg32.dll /DELAYLOAD:winspool.drv
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shlwapi.lib shell32.lib rpcrt4.lib usp10.lib ../../common/KernelEx.lib ../../kexcrt/kexcrt.lib libc.lib delayimp.lib /nologo /dll /map /debug /machine:I386 /nodefaultlib /OPT:NOWIN98 /DELAYLOAD:shell32.dll /DELAYLOAD:rpcrt4.dll /DELAYLOAD:usp10.dll /DELAYLOAD:comdlg32.dll /DELAYLOAD:winspool.drv /DELAYLOAD:shlwapi.dll
# SUBTRACT LINK32 /pdb:none
!ENDIF
@ -153,6 +153,14 @@ SOURCE=.\gdi32\_gdi32_apilist.h
# End Source File
# Begin Source File
SOURCE=.\gdi32\ScriptCache.cpp
# End Source File
# Begin Source File
SOURCE=.\gdi32\ScriptCache.h
# End Source File
# Begin Source File
SOURCE=.\gdi32\UberGDI.c
# End Source File
# Begin Source File
@ -225,6 +233,10 @@ SOURCE=.\shell32\SHGetSpecialFolder_fix.c
# End Source File
# Begin Source File
SOURCE=.\shell32\SHParseDisplayName.c
# End Source File
# Begin Source File
SOURCE=.\shell32\unishell32.c
# End Source File
# End Group

40
apilibs/kexbasen/shell32/SHParseDisplayName.c Executable file
View File

@ -0,0 +1,40 @@
/*
* KernelEx
* Copyright (C) 2010, Tihiy
*
* This file is part of KernelEx source code.
*
* KernelEx is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published
* by the Free Software Foundation; version 2 of the License.
*
* KernelEx is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include <shlobj.h>
#include <shlwapi.h>
/* MAKE_EXPORT SHParseDisplayName_new=SHParseDisplayName */
HRESULT WINAPI SHParseDisplayName_new(PCWSTR pszName, IBindCtx *pbc, LPITEMIDLIST *ppidl, SFGAOF sfgaoIn, SFGAOF *psfgaoOut)
{
IShellFolder *psf;
HRESULT ret = SHGetDesktopFolder(&psf);
if (SUCCEEDED(ret))
{
ULONG attrs = sfgaoIn;
LPOLESTR pszNameCopyW = StrDupW(pszName);
ret = psf->ParseDisplayName(NULL,pbc,pszNameCopyW,NULL,ppidl,&attrs);
if (psfgaoOut) *psfgaoOut = attrs;
psf->Release();
LocalFree(pszNameCopyW);
}
return ret;
}

1
apilibs/kexbasen/shell32/_shell32_apilist.c
View File

@ -45,6 +45,7 @@ static const apilib_named_api shell32_named_apis[] =
DECL_API("SHGetSpecialFolderLocation", SHGetSpecialFolderLocation_fix),
DECL_API("SHGetSpecialFolderPathA", SHGetSpecialFolderPathA_fix),
DECL_API("SHGetSpecialFolderPathW", SHGetSpecialFolderPathW_fix),
DECL_API("SHParseDisplayName", SHParseDisplayName_new),
DECL_API("ShellAboutW", ShellAboutW_fwd),
DECL_API("ShellExecuteExW", ShellExecuteExW_fwd),
DECL_API("ShellExecuteW", ShellExecuteW_fwd),

2
apilibs/kexbasen/shell32/_shell32_apilist.h
View File

@ -22,6 +22,7 @@
#ifndef _SHELL32_APILIST_H
#define _SHELL32_APILIST_H
#include <shlobj.h>
#include "kexcoresdk.h"
BOOL init_shell32();
@ -34,6 +35,7 @@ HRESULT WINAPI SHGetFolderPathW_new(HWND hwndOwner, int nFolder, HANDLE hToken,
HRESULT WINAPI SHGetSpecialFolderLocation_fix(HWND hwndOwner, int nFolder, LPVOID *_ppidl);
BOOL WINAPI SHGetSpecialFolderPathA_fix(HWND hwndOwner, LPSTR lpszPath, int nFolder, BOOL fCreate);
BOOL WINAPI SHGetSpecialFolderPathW_fix(HWND hwndOwner, LPWSTR lpszPath, int nFolder, BOOL fCreate);
HRESULT WINAPI SHParseDisplayName_new(PCWSTR pszName, IBindCtx *pbc, LPITEMIDLIST *ppidl, SFGAOF sfgaoIn, SFGAOF *psfgaoOut);
FWDPROC DragQueryFileW_fwd;
FWDPROC ExtractIconExW_fwd;
FWDPROC ExtractIconW_fwd;

1
apilibs/kexbasen/winspool/_winspool_apilist.c
View File

@ -47,6 +47,7 @@ static const apilib_named_api winspool_named_apis[] =
DECL_API("DeletePrinterDriverW", DeletePrinterDriverW_fwd),
DECL_API("DeviceCapabilitiesW", DeviceCapabilitiesW_fwd),
DECL_API("DocumentPropertiesW", DocumentPropertiesW_fwd),
DECL_API("EnumPrintersW", EnumPrintersW_new),
DECL_API("GetDefaultPrinterA", GetDefaultPrinterA),
DECL_API("GetDefaultPrinterW", GetDefaultPrinterW),
DECL_API("GetPrintProcessorDirectoryW", GetPrintProcessorDirectoryW_fwd),

1
apilibs/kexbasen/winspool/_winspool_apilist.h
View File

@ -58,6 +58,7 @@ FWDPROC SetJobW_fwd;
FWDPROC SetPrinterDataW_fwd;
FWDPROC SetPrinterW_fwd;
FWDPROC StartDocPrinterW_fwd;
BOOL WINAPI EnumPrintersW_new(DWORD Flags, LPWSTR NameW, DWORD Level, LPBYTE pPrinterEnumW, DWORD cbBuf, LPDWORD pcbNeeded, LPDWORD pcReturned);
/*** AUTOGENERATED APILIST DECLARATIONS END ***/
#endif

303
apilibs/kexbasen/winspool/uniwinspool.c
View File

@ -1,6 +1,15 @@
/*
* KernelEx
* Copyright (C) 2010, Tihiy
* Copyright (C) 2010, Xeno86
*
* Parts adapted from WINE Project.
* Copyright 1996 John Harvey
* Copyright 1998 Andreas Mohr
* Copyright 1999 Klaas van Gend
* Copyright 1999, 2000 Huw D M Davies
* Copyright 2001 Marcus Meissner
* Copyright 2005-2009 Detlef Riekenberg
*
* This file is part of KernelEx source code.
*
@ -19,9 +28,255 @@
*
*/
#include <windows.h>
#include "common.h"
#include "unifwd.h"
static const DWORD pi_sizeof[] = {0, sizeof(PRINTER_INFO_1), sizeof(PRINTER_INFO_2),
sizeof(PRINTER_INFO_3), sizeof(PRINTER_INFO_4),
sizeof(PRINTER_INFO_5)};
/***********************************************************
* DEVMODEdupWtoA
* Creates an ansi copy of supplied devmode
*/
static LPDEVMODEW DEVMODEdupAtoW(const DEVMODEA *dmA)
{
LPDEVMODEW dmW;
WORD size;
if (!dmA) return NULL;
size = dmA->dmSize + CCHDEVICENAME +
((dmA->dmSize > FIELD_OFFSET(DEVMODEA, dmFormName)) ? CCHFORMNAME : 0);
dmW = (LPDEVMODEW) HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size + dmA->dmDriverExtra);
if (!dmW) return NULL;
MultiByteToWideChar(CP_ACP, 0, (LPSTR)dmA->dmDeviceName, -1,
dmW->dmDeviceName, CCHDEVICENAME);
if (FIELD_OFFSET(DEVMODEA, dmFormName) >= dmA->dmSize) {
memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
dmA->dmSize - FIELD_OFFSET(DEVMODEA, dmSpecVersion));
}
else
{
memcpy(&dmW->dmSpecVersion, &dmA->dmSpecVersion,
FIELD_OFFSET(DEVMODEA, dmFormName) - FIELD_OFFSET(DEVMODEA, dmSpecVersion));
MultiByteToWideChar(CP_ACP, 0, (LPSTR)dmA->dmFormName, -1,
dmW->dmFormName, CCHFORMNAME);
memcpy(&dmW->dmLogPixels, &dmA->dmLogPixels, dmA->dmSize - FIELD_OFFSET(DEVMODEA, dmLogPixels));
}
dmW->dmSize = size;
memcpy((char *)dmW + dmW->dmSize, (const char *)dmA + dmA->dmSize, dmA->dmDriverExtra);
return dmW;
}
static void convert_printerinfo_WtoA(LPBYTE outW, LPBYTE pPrintersA,
DWORD level, DWORD outlen, DWORD numentries)
{
DWORD id = 0;
LPWSTR ptr;
INT len;
len = pi_sizeof[level] * numentries;
ptr = (LPWSTR) (outW + len);
/* first structures */
outlen -= len;
/* then text in unicode (we count in wchars from now on) */
outlen /= 2;
/* copy the numbers of all PRINTER_INFO_* first */
memcpy(outW, pPrintersA, len);
while (id < numentries) {
switch (level) {
case 1:
{
PRINTER_INFO_1W * piW = (PRINTER_INFO_1W *) outW;
PRINTER_INFO_1A * piA = (PRINTER_INFO_1A *) pPrintersA;
if (piA->pDescription) {
piW->pDescription = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pDescription, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pName) {
piW->pName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pComment) {
piW->pComment = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pComment, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
break;
}
case 2:
{
PRINTER_INFO_2W * piW = (PRINTER_INFO_2W *) outW;
PRINTER_INFO_2A * piA = (PRINTER_INFO_2A *) pPrintersA;
LPDEVMODEW dmW;
if (piA->pServerName) {
piW->pServerName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pServerName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pPrinterName) {
piW->pPrinterName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPrinterName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pShareName) {
piW->pShareName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pShareName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pPortName) {
piW->pPortName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPortName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pDriverName) {
piW->pDriverName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pDriverName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pComment) {
piW->pComment = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pComment, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pLocation) {
piW->pLocation = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pLocation, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
dmW = DEVMODEdupAtoW(piA->pDevMode);
if (dmW) {
/* align DEVMODEA to a DWORD boundary */
len = (2 - ( (DWORD_PTR) ptr & 1)) & 1;
ptr += len;
outlen -= len;
piW->pDevMode = (LPDEVMODEW) ptr;
len = dmW->dmSize + dmW->dmDriverExtra;
memcpy(ptr, dmW, len);
HeapFree(GetProcessHeap(), 0, dmW);
ptr += len/2+1;
outlen -= len/2+1;
}
if (piA->pSepFile) {
piW->pSepFile = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pSepFile, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pPrintProcessor) {
piW->pPrintProcessor = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPrintProcessor, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pDatatype) {
piW->pDatatype = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pDatatype, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pParameters) {
piW->pParameters = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pParameters, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pSecurityDescriptor) {
piW->pSecurityDescriptor = NULL;
}
break;
}
case 4:
{
PRINTER_INFO_4W * piW = (PRINTER_INFO_4W *) outW;
PRINTER_INFO_4A * piA = (PRINTER_INFO_4A *) pPrintersA;
if (piA->pPrinterName) {
piW->pPrinterName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPrinterName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pServerName) {
piW->pServerName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pServerName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
break;
}
case 5:
{
PRINTER_INFO_5W * piW = (PRINTER_INFO_5W *) outW;
PRINTER_INFO_5A * piA = (PRINTER_INFO_5A *) pPrintersA;
if (piA->pPrinterName) {
piW->pPrinterName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPrinterName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
if (piA->pPortName) {
piW->pPortName = ptr;
len = MultiByteToWideChar(CP_ACP, 0, piA->pPortName, -1,
ptr, outlen);
ptr += len;
outlen -= len;
}
break;
}
}
pPrintersA += pi_sizeof[level];
outW += pi_sizeof[level];
id++;
}
}
//AddForm - not supported
FORWARD_TO_UNICOWS(AddJobW);
FORWARD_TO_UNICOWS(AddMonitorW);
@ -47,7 +302,51 @@ FORWARD_TO_UNICOWS(DocumentPropertiesW);
//EnumMonitorsW - not implemented
//EnumPortsW - not implemented
//EnumPrinterDriversW - not implemented
//EnumPrintersW - not implemented
/* MAKE_EXPORT EnumPrintersW_new=EnumPrintersW */
BOOL WINAPI EnumPrintersW_new(
DWORD Flags,
LPWSTR NameW,
DWORD Level,
LPBYTE pPrinterEnumW,
DWORD cbBuf,
LPDWORD pcbNeeded,
LPDWORD pcReturned
)
{
BOOL ret;
DWORD needed;
DWORD returned;
LPBYTE pPrinterEnumA;
ALLOC_WtoA(Name);
pPrinterEnumA = (pPrinterEnumW && cbBuf) ? (LPBYTE) HeapAlloc(GetProcessHeap(), 0, cbBuf) : NULL;
ret = EnumPrintersA(Flags, NameA, Level, pPrinterEnumA, cbBuf, &needed, &returned);
if (Level <= 5)
needed = (needed - pi_sizeof[Level]) * 2 + pi_sizeof[Level];
if (pcbNeeded)
*pcbNeeded = needed;
if (pcReturned)
*pcReturned = returned;
if (ret)
{
if (cbBuf >= needed)
{
convert_printerinfo_WtoA(pPrinterEnumW, pPrinterEnumA, Level, needed, returned);
}
else
{
SetLastError(ERROR_INSUFFICIENT_BUFFER);
if (pcReturned)
*pcReturned = 0;
ret = FALSE;
}
}
HeapFree(GetProcessHeap(), 0, pPrinterEnumA);
return ret;
}
//EnumPrintProcessorDatatypesW - not implemented
//EnumPrintProcessorsW - not implemented
//GetForm - not supported

3
apilibs/kexbases/Advapi32/_advapi32_apilist.c
View File

@ -45,6 +45,7 @@ static const apilib_named_api advapi32_named_apis[] =
DECL_API("ConvertStringSidToSidA", ConvertStringSidToSidA_stub),
DECL_API("ConvertStringSidToSidW", ConvertStringSidToSidW_stub),
DECL_API("CopySid", CopySid_new),
DECL_API("CreateProcessWithLogonW", CreateProcessWithLogonW_stub),
DECL_API("CreateRestrictedToken", CreateRestrictedToken_new),
DECL_API("CreateWellKnownSid", CreateWellKnownSid_new),
DECL_API("CryptAcquireContextW", CryptAcquireContextW_stub),
@ -82,6 +83,8 @@ static const apilib_named_api advapi32_named_apis[] =
DECL_API("InitializeAcl", InitializeAcl_new),
DECL_API("InitializeSecurityDescriptor", InitializeSecurityDescriptor_new),
DECL_API("InitializeSid", InitializeSid_new),
DECL_API("InitiateSystemShutdownExA", InitiateSystemShutdownExA_stub),
DECL_API("InitiateSystemShutdownExW", InitiateSystemShutdownExW_stub),
DECL_API("IsValidSecurityDescriptor", IsValidSecurityDescriptor_new),
DECL_API("IsValidSid", IsValidSid_new),
DECL_API("IsWellKnownSid", IsWellKnownSid_stub),

3
apilibs/kexbases/Advapi32/_advapi32_apilist.h
View File

@ -58,6 +58,9 @@ STUB QueryWindows31FilesMigration_stub;
STUB SynchronizeWindows31FilesAndWindowsNTRegistry_stub;
STUB EnumServicesStatusExA_stub;
STUB EnumServicesStatusExW_stub;
STUB CreateProcessWithLogonW_stub;
STUB InitiateSystemShutdownExA_stub;
STUB InitiateSystemShutdownExW_stub;
BOOL WINAPI OpenProcessToken_new(HANDLE ProcessHandle, DWORD DesiredAccess, HANDLE *TokenHandle);
BOOL WINAPI OpenThreadToken_new(HANDLE ThreadHandle, DWORD DesiredAccess, BOOL OpenAsSelf, HANDLE *TokenHandle);
BOOL WINAPI DuplicateTokenEx_new(HANDLE ExistingTokenHandle, DWORD dwDesiredAccess, LPSECURITY_ATTRIBUTES lpTokenAttributes, SECURITY_IMPERSONATION_LEVEL ImpersonationLevel, TOKEN_TYPE TokenType, PHANDLE DuplicateTokenHandle);

4
apilibs/kexbases/Advapi32/_advapi32_stubs.c
View File

@ -51,3 +51,7 @@ UNIMPL_FUNC(SynchronizeWindows31FilesAndWindowsNTRegistry,4);
UNIMPL_FUNC(EnumServicesStatusExA, 10);
UNIMPL_FUNC(EnumServicesStatusExW, 10);
UNIMPL_FUNC(CreateProcessWithLogonW, 11);
UNIMPL_FUNC(InitiateSystemShutdownExA, 6);
UNIMPL_FUNC(InitiateSystemShutdownExW, 6);

15
apilibs/kexbases/Gdi32/FontResourceExA.c → apilibs/kexbases/Gdi32/FontResourceEx.c
View File

@ -32,3 +32,18 @@ BOOL WINAPI RemoveFontResourceExA_new(LPCSTR str, DWORD fl, PVOID pdv)
{
return RemoveFontResourceA(str);
}
/* MAKE_EXPORT AddFontMemResourceEx_stub=AddFontMemResourceEx */
HANDLE WINAPI AddFontMemResourceEx_stub(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts)
{
if (!pbFont || !cbFont || !pcFonts)
return NULL;
*pcFonts = 1;
return (HANDLE) 0x10000;
}
/* MAKE_EXPORT RemoveFontMemResourceEx_stub=RemoveFontMemResourceEx */
BOOL WINAPI RemoveFontMemResourceEx_stub(HANDLE fh)
{
return (fh == (HANDLE) 0x10000) ? TRUE : FALSE;
}

14
apilibs/kexbases/Gdi32/GdiObjects.c
View File

@ -28,6 +28,7 @@
static BOOL blockkexgdiobj;
static WORD g_GDILH_addr;
static DWORD g_GdiBase;
static int script_cache_psidx;
#define REBASEGDI(x) ((PVOID)( g_GdiBase + LOWORD((DWORD)(x)) ))
#define REBASEGDIHIGH(x) ( g_GdiBase + (DWORD)(x) )
@ -40,6 +41,7 @@ BOOL InitGDIObjects(void)
g_GdiBase = MapSL( LoadLibrary16("gdi") << 16 );
g_GDILH_addr = ((PINSTANCE16)g_GdiBase)->pLocalHeap;
blockkexgdiobj = (BOOL)GetProcAddress(GetModuleHandle("rp10.dll"),"blockkexgdiobj");
script_cache_psidx = kexPsAllocIndex();
return (BOOL)g_GdiBase;
}
@ -159,6 +161,18 @@ BOOL WINAPI DeleteObject_fix( HGDIOBJ hObject )
DWORD violated = 0;
if ( obj->wOwner ) //not system objects
{
if (obj->wType == GDI_TYPE_FONT)
{
typedef void (*DeleteUSPFontCache_fn)(HFONT hFont);
DeleteUSPFontCache_fn DeleteUSPFontCache = (DeleteUSPFontCache_fn) kexPsGetValue(script_cache_psidx);
if (!DeleteUSPFontCache)
{
DeleteUSPFontCache = (DeleteUSPFontCache_fn)GetProcAddress(LoadLibrary("KEXBASEN.DLL"), "DeleteUSPFontCache");
kexPsSetValue(script_cache_psidx, DeleteUSPFontCache);
}
if (DeleteUSPFontCache)
DeleteUSPFontCache((HFONT)hObject);
}
if (obj->wType == GDI_TYPE_FONT && ((PFONTOBJ16)obj)->wSelCount >= SEL_FONT_ONCE )
{
DBGPRINTF(("somebody is trying to delete selected font %p\n",hObject));

4
apilibs/kexbases/Gdi32/_gdi32_apilist.h
View File

@ -30,6 +30,8 @@ extern const apilib_api_table apitable_gdi32;
/*** AUTOGENERATED APILIST DECLARATIONS BEGIN ***/
INT WINAPI AddFontResourceExA_new(LPCSTR str, DWORD fl, PVOID pdv);
BOOL WINAPI RemoveFontResourceExA_new(LPCSTR str, DWORD fl, PVOID pdv);
HANDLE WINAPI AddFontMemResourceEx_stub(PVOID pbFont, DWORD cbFont, PVOID pdv, DWORD *pcFonts);
BOOL WINAPI RemoveFontMemResourceEx_stub(HANDLE fh);
DWORD WINAPI GetObjectType_fix(HGDIOBJ hgdiobj);
BOOL WINAPI DeleteObject_fix(HGDIOBJ hObject);
HGDIOBJ WINAPI SelectObject_fix(HDC hdc, HGDIOBJ hgdiobj);
@ -53,8 +55,6 @@ STUB SetDCBrushColor_stub;
STUB SetDCPenColor_stub;
STUB GetDCBrushColor_stub;
STUB GetDCPenColor_stub;
STUB AddFontMemResourceEx_stub;
STUB RemoveFontMemResourceEx_stub;
INT WINAPI AddFontResourceExW_new(LPCWSTR strW, DWORD fl, PVOID pdv);
INT WINAPI AddFontResourceW_new(LPCWSTR strW);
int WINAPI EnumFontFamiliesExA_new(HDC hdc, LPLOGFONTA pLogfontA, FONTENUMPROCA pEnumFontFamExProc, LPARAM lParam, DWORD dwFlags);

2
apilibs/kexbases/Gdi32/_gdi32_stubs.c
View File

@ -25,5 +25,3 @@ UNIMPL_FUNC(SetDCBrushColor, 2);
UNIMPL_FUNC(SetDCPenColor, 2);
UNIMPL_FUNC(GetDCBrushColor, 1);
UNIMPL_FUNC(GetDCPenColor, 1);
UNIMPL_FUNC(AddFontMemResourceEx, 4);
UNIMPL_FUNC(RemoveFontMemResourceEx, 1);

20
apilibs/kexbases/Gdi32/unigdi32.c
View File

@ -1,6 +1,6 @@
/*
* KernelEx
* Copyright (C) 2009, Xeno86
* Copyright (C) 2009-2010, Xeno86
* Copyright (C) 2009, Tihiy
*
* This file is part of KernelEx source code.
@ -107,11 +107,19 @@ static int CALLBACK EnumFontFamExConv(const LOGFONTA *plfA,
tmW->ntmTm.tmBreakChar = tmA->ntmTm.tmBreakChar;
#endif
tmW->ntmTm.ntmFlags = tmA->ntmTm.ntmFlags;
tmW->ntmTm.ntmSizeEM = tmA->ntmTm.ntmSizeEM;
tmW->ntmTm.ntmCellHeight = tmA->ntmTm.ntmCellHeight;
tmW->ntmTm.ntmAvgWidth = tmA->ntmTm.ntmAvgWidth;
memcpy(&tmW->ntmFontSig, &tmA->ntmFontSig, sizeof(FONTSIGNATURE));
if (FontType == TRUETYPE_FONTTYPE)
{
tmW->ntmTm.ntmFlags = tmA->ntmTm.ntmFlags;
tmW->ntmTm.ntmSizeEM = tmA->ntmTm.ntmSizeEM;
tmW->ntmTm.ntmCellHeight = tmA->ntmTm.ntmCellHeight;
tmW->ntmTm.ntmAvgWidth = tmA->ntmTm.ntmAvgWidth;
memset(&tmW->ntmFontSig, 0, sizeof(FONTSIGNATURE));
}
else
{
memset(&tmW->ntmTm.ntmFlags, 0, sizeof(NEWTEXTMETRICEXW)
- FIELD_OFFSET(NEWTEXTMETRICEXW, ntmTm.ntmFlags));
}
return pef->EnumProcW((LOGFONTW*) &elfeW, (TEXTMETRICW*) &ntmeW, FontType, pef->lParam);
}

2
apilibs/kexbases/Kernel32/FileApis_fix.c
View File

@ -128,12 +128,12 @@ BOOL WINAPI WriteFile_fix(HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesTo
UINT WINAPI GetTempFileNameA_fix(LPCSTR lpPathName, LPCSTR lpPrefixString, UINT uUnique, LPTSTR lpTempFileName)
{
static int g_tempprefix = 0;
char temppref[2];
if (!lpPathName)
lpPathName = "\\";
if (!lpPrefixString)
{
char temppref[2];
g_tempprefix++;
g_tempprefix %= 5;
temppref[0] = '0' + g_tempprefix;

4
apilibs/kexbases/User32/thuni_conv.c
View File

@ -223,9 +223,9 @@ LRESULT WINAPI CallProcAnsiWithUnicode( WNDPROC callback, HWND hwnd, UINT msg, W
{
LPSTR textA;
int len = CallWindowProcA( callback, hwnd, msg == LB_GETTEXT ? LB_GETTEXTLEN : CB_GETLBTEXTLEN, wParam, 0 );
ABUFFER_ALLOC(textA,len);
ABUFFER_ALLOC(textA,len); //note that len does not include null
LRESULT ret = CallWindowProcA( callback, hwnd, msg, wParam,(LPARAM)textA );
ABUFFER_toW(textA,lParam,len);
ABUFFER_toW(textA,lParam,len+1);
BUFFER_FREE(textA);
return ret;
}

7
apilibs/kexbases/User32/thuni_macro.h
View File

@ -62,7 +62,9 @@
} \
else \
buffer = (LPSTR)alloca( buffer##size ); \
*buffer='\0';
buffer[0]='\0'; \
buffer[len]='\0'; \
buffer[buffer##size-1]='\0';
#define WBUFFER_ALLOC(buffer,len) \
int buffer##size = ((len+1) * sizeof(WCHAR)); \
@ -74,7 +76,8 @@
} \
else \
buffer = (LPWSTR)alloca( buffer##size ); \
*buffer='\0';
buffer[0]='\0'; \
buffer[len]='\0';
#define ABUFFER_toW(bufferA,bufferW,lenW) MultiByteToWideChar(CP_ACP, 0, bufferA, -1, (LPWSTR)bufferW, lenW);
#define WBUFFER_toA(bufferW,bufferA,lenA) WideCharToMultiByte(CP_ACP, 0, bufferW, -1, (LPSTR)bufferA, lenA, NULL, NULL);

2
apilibs/kexbases/kexbases.dsp
View File

@ -365,7 +365,7 @@ SOURCE=.\Gdi32\_gdi32_stubs.c
# End Source File
# Begin Source File
SOURCE=.\Gdi32\FontResourceExA.c
SOURCE=.\Gdi32\FontResourceEx.c
# End Source File
# Begin Source File

1
apilibs/kexbases/shell32/_shell32_apilist.c
View File

@ -35,7 +35,6 @@ static const apilib_named_api shell32_named_apis[] =
DECL_API("IsUserAnAdmin", IsUserAnAdmin_new),
DECL_API("SHCreateShellItem", SHCreateShellItem_stub),
DECL_API("SHOpenFolderAndSelectItems", SHOpenFolderAndSelectItems_stub),
DECL_API("SHParseDisplayName", SHParseDisplayName_stub),
/*** AUTOGENERATED APILIST NAMED EXPORTS END ***/
};

1
apilibs/kexbases/shell32/_shell32_apilist.h
View File

@ -30,7 +30,6 @@ extern const apilib_api_table apitable_shell32;
/*** AUTOGENERATED APILIST DECLARATIONS BEGIN ***/
LPWSTR* WINAPI CommandLineToArgvW_new(LPCWSTR lpCmdline, int* numargs);
BOOL WINAPI IsUserAnAdmin_new(void);
STUB SHParseDisplayName_stub;
STUB SHCreateShellItem_stub;
STUB SHOpenFolderAndSelectItems_stub;
/*** AUTOGENERATED APILIST DECLARATIONS END ***/

1
apilibs/kexbases/shell32/_shell32_stubs.c
View File

@ -21,6 +21,5 @@
#include "common.h"
UNIMPL_FUNC(SHParseDisplayName, 5);
UNIMPL_FUNC(SHCreateShellItem, 4);
UNIMPL_FUNC(SHOpenFolderAndSelectItems, 4);

8
apilibs/settings.reg
View File

@ -10,15 +10,15 @@ REGEDIT4
"*\\FIREFOX SETUP 3*.EXE"="WINXP"
"*FIREFOX\\UNINSTALL\\HELPER.EXE"="WINXP"
"*\\FIREFOX*PRE*.INSTALLER.EXE"="WINXP"
"*\\XUL.DLL"="WINXP"
"*\\XUL.DLL"="NT2K"
"*\\FIREFOX.EXE"="DCFG1"
"*\\SEAMONKEY.EXE"="DCFG1"
;-Java
"*\\JAVA.EXE"="DCFG1"
"*\\JAVAW.EXE"="DCFG1"
;-GIMP
"*\\BIN\\GIMP-2.6.EXE"="WIN2K"
"*\\GIMP-2.6*-SETUP.EXE"="WIN2K"
"*\\BIN\\GIMP-2.6.EXE"="NT2K"
"*\\GIMP-2.6*-SETUP.EXE"="NT2K"
;-Webkit
"*\\QTWEBKIT4.DLL"="WINXP"
;-AbiWord
@ -55,4 +55,6 @@ REGEDIT4
;-DirectX installer
"*\\DXSETUP.EXE"=dword:00000001
"*\\DXWEBSETUP.EXE"=dword:00000001
;-OpenOffice.org
"*\\PROGRAM\\CRASHREP.EXE"=dword:00000001

8
common/version.h
View File

@ -22,9 +22,9 @@
#ifndef __VERSION_H
#define __VERSION_H
#define VERSION_STR "4.5 Beta 1"
#define VERSION_CODE 0x04050001
#define RCVERSION 4, 5, 0, 1
#define _RCVERSION_ "4, 5, 0, 1"
#define VERSION_STR "4.5 Beta 2"
#define VERSION_CODE 0x04050002
#define RCVERSION 4, 5, 0, 2
#define _RCVERSION_ "4, 5, 0, 2"
#endif

9
core/SettingsDB.cpp
View File

@ -44,6 +44,7 @@ void SettingsDB::clear()
{
EnterCriticalSection(&cs);
db.clear();
db_wild.clear();
appsetting as;
as.flags = LDR_KEX_DISABLE;
db.insert(pair<sstring,appsetting>(own_path, as));
@ -263,19 +264,19 @@ void SettingsDB::dump_db()
{
map<sstring, appsetting>::const_iterator it;
dbgprintf("User settings:\n");
printf("User settings:\n");
for (it = db.begin() ; it != db.end() ; it++)
{
ApiConfiguration* conf = it->second.conf;
dbgprintf("%-40s %-10s %02x\n", static_cast<const char*>(it->first),
printf("%-40s %-10s %02x\n", static_cast<const char*>(it->first),
conf ? conf->get_name() : "unknown", it->second.flags);
}
dbgprintf("\nPredefined settings:\n");
printf("\nPredefined settings:\n");
for (it = db_wild.begin() ; it != db_wild.end() ; it++)
{
ApiConfiguration* conf = it->second.conf;
dbgprintf("%-40s %-10s %02x\n", static_cast<const char*>(it->first),
printf("%-40s %-10s %02x\n", static_cast<const char*>(it->first),
conf ? conf->get_name() : "unknown", it->second.flags);
}
}

16
core/apiconf.cpp
View File

@ -542,20 +542,20 @@ bool ApiConfiguration::is_initialized()
void ApiConfiguration::dump()
{
dbgprintf("ApiConfiguration %s\n", get_name());
printf("ApiConfiguration %s\n", get_name());
for (int i = 0 ; i < api_tables_count ; i++)
{
dbgprintf("Covered module #%d: %s\n", i, overridden_module_names[i]);
dbgprintf("Named apis (count = %d)\n", api_tables[i].named_apis_count);
printf("Covered module #%d: %s\n", i, overridden_module_names[i]);
printf("Named apis (count = %d)\n", api_tables[i].named_apis_count);
for (int j = 0 ; j < api_tables[i].named_apis_count ; j++)
dbgprintf("\t%-32s %08x\n", api_tables[i].named_apis[j].api_name,
printf("\t%-32s %08x\n", api_tables[i].named_apis[j].api_name,
api_tables[i].named_apis[j].address);
dbgprintf("Unnamed apis (count = %d)\n", api_tables[i].unnamed_apis_count);
printf("Unnamed apis (count = %d)\n", api_tables[i].unnamed_apis_count);
for (int j = 0 ; j < api_tables[i].unnamed_apis_count ; j++)
dbgprintf("\t%-5d %08x\n", j, api_tables[i].unnamed_apis[j]);
dbgprintf("\n");
printf("\t%-5d %08x\n", j, api_tables[i].unnamed_apis[j]);
printf("\n");
}
dbgprintf("\n");
printf("\n");
}
#endif

4
core/apiconfmgr.cpp
View File

@ -416,12 +416,12 @@ bool ApiConfigurationManager::parse_overrides(ApiConfiguration* apiconf)
void ApiConfigurationManager::dump_configurations()
{
dbgprintf("Dumping all api configurations (count = %d) ...\n\n", apiconf_cnt);
printf("Dumping all api configurations (count = %d) ...\n\n", apiconf_cnt);
for (int i = 0 ; i < apiconf_cnt ; i++)
{
apiconf_ptrs[i]->dump();
}
dbgprintf("End dump\n\n");
printf("End dump\n\n");
}
#endif

8
core/resolver.cpp
View File

@ -713,18 +713,18 @@ void dump_imtes(void)
IMTE** pmteModTable = *ppmteModTable;
int total = 0;
dbgprintf("Dumping IMTEs...\n");
printf("Dumping IMTEs...\n");
for (WORD i = 0 ; i < imteMax ; i++)
{
IMTE_KEX* imte = (IMTE_KEX*) pmteModTable[i];
if (imte)
{
dbgprintf("%s\n", imte->pszFileName);
printf("%s\n", imte->pszFileName);
for (MODREF* mr = imte->pMR ; mr != NULL ; mr = mr->pNextMteMR)
{
MODREF_KEX kmr(mr);
dbgprintf("\t%02x %-7s %-12s\n",
printf("\t%02x %-7s %-12s\n",
kmr.as.flags,
kmr.as.conf ? kmr.as.conf->get_name() : "none",
pmteModTable[mr->ppdb->pExeMODREF->mteIndex]->pszModName);
@ -733,7 +733,7 @@ void dump_imtes(void)
total++;
}
}
dbgprintf("\nEnd dump total %d IMTEs\n\n", total);
printf("\nEnd dump total %d IMTEs\n\n", total);
}
#endif

35
kexCOM/server.cpp
View File

@ -31,24 +31,6 @@ static HMODULE hShell32;
static LPFNGETCLASSOBJECT SHGetClassObject;
/* Hall of shame */
static const char* blacklist[] = {
"COOLTYPE.DLL", /* Adobe Acrobat Reader 5.0.5, Adobe Photoshop 7.0 */
NULL,
};
static bool is_blacklisted()
{
for (int i = 0 ; blacklist[i] ; i++)
{
if (GetModuleHandle(blacklist[i]))
return true;
}
return false;
}
static bool is_shell32_v5()
{
DLLGETVERSIONPROC DllGetVersion;
@ -146,12 +128,25 @@ STDAPI DllGetClassObject(const CLSID& clsid, const IID& iid, void** ppv)
}
HMODULE GetCurrentModule()
{
MEMORY_BASIC_INFORMATION mbi;
static int dummy;
VirtualQuery(&dummy, &mbi, sizeof(mbi));
return (HMODULE)mbi.AllocationBase;
}
BOOL APIENTRY DllMain(HINSTANCE hModule, DWORD dwReason, LPVOID lpReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
if (is_blacklisted())
return FALSE;
char szPath[MAX_PATH];
/* LoadLibrary(self) trick to prevent premature unload in buggy programs
* such as Adobe Photoshop, Acrobat Reader,... */
GetModuleFileName(GetCurrentModule(), szPath, sizeof(szPath));
LoadLibrary(szPath);
g_hModule = hModule;
DisableThreadLibraryCalls(hModule);

3
kexcontrol/kexcontrol.cpp
View File

@ -70,6 +70,9 @@ bool kill_all_referents()
}
CloseHandle(h);
//let the processes die before proceeding
Sleep(1000);
return true;
}

2
setup/setup.cpp
View File

@ -367,7 +367,7 @@ void Setup::find_ExportFromX()
{
static const short pattern[] = {
0x8B,0x0D,-1,-1,-1,-1,0x0F,0xBF,0x40,0x10,0x8B,0x14,0x81,0x8B,0x44,
0x24,0x14,0x3D,0x00,0x00,0x01,0x00,0x8B,0x4A,0x04,0x73,0x15,0x3B,0x1D,
0x24,0x14,0x3D,0x00,0x00,0x01,0x00,0x8B,0x4A,0x04,0x73,0x15,-1,0x1D,
-1,-1,-1,-1,0x75,0x04,0x6A,0x32,0xEB,0x3E,0x50,0x51,0xE8,-2,-2,-2,-2,
0xEB,0x0C,0xFF,0x74,0x24,0x14,0x6A,0x00,0x51,0xE8,-2,-2,-2,-2,0x83,
0x7F,0x54,0x00,0x8B,0xF0