-- Протестировано на SAMPFUNCS v5.7.1 rel.25 (SA-MP 0.3.7-R1)
local settings = {
enabled = true,
consoleCommand = "clipboardfix",
}
local ffi = require("ffi")
ffi.cdef[[
int VirtualProtect(void* lpAddress, unsigned long dwSize, unsigned long flNewProtect, unsigned long* lpflOldProtect);
void* VirtualAlloc(void* lpAddress, unsigned long dwSize, unsigned long flAllocationType, unsigned long flProtect);
int VirtualFree(void* lpAddress, unsigned long dwSize, unsigned long dwFreeType);
typedef unsigned int uint32;
typedef int BOOL;
typedef void* HGLOBAL;
typedef void* HANDLE;
typedef char* LPSTR;
typedef const char* LPCSTR;
typedef wchar_t* LPCWSTR;
typedef wchar_t* LPWSTR;
typedef BOOL* LPBOOL;
typedef unsigned int UINT;
typedef unsigned long DWORD;
BOOL OpenClipboard(void* hWndNewOwner);
BOOL CloseClipboard();
BOOL EmptyClipboard();
HANDLE SetClipboardData(UINT uFormat, HANDLE hMem);
HANDLE GetClipboardData(UINT uFormat);
UINT EnumClipboardFormats(UINT format);
HGLOBAL GlobalAlloc(UINT uFlags, size_t dwBytes);
void* GlobalLock(HGLOBAL hMem);
BOOL GlobalUnlock(HGLOBAL hMem);
int MultiByteToWideChar(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cbMultiByte, LPWSTR lpWideCharStr, int cchWideChar);
int WideCharToMultiByte(
UINT CodePage,
DWORD dwFlags,
LPCWSTR lpWideCharStr,
int cchWideChar,
LPSTR lpMultiByteStr,
int cbMultiByte,
LPCSTR lpDefaultChar,
LPBOOL lpUsedDefaultChar
);
enum {
CF_UNICODETEXT = 13,
CF_TEXT = 1,
GMEM_MOVEABLE = 0x0002,
CP1251 = 1251,
};
]]
-- hooks от @RTD (https://www.blast.hk/threads/55743/)
-- module hooks -----------------------------------------------
local function copy(dst, src, len)
return ffi.copy(ffi.cast('void*', dst), ffi.cast('const void*', src), len)
end
local buff = {free = {}}
local function VirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect)
return ffi.C.VirtualProtect(ffi.cast('void*', lpAddress), dwSize, flNewProtect, lpflOldProtect)
end
local function VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect, blFree)
local alloc = ffi.C.VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
if blFree then
table.insert(buff.free, alloc)
end
return ffi.cast('intptr_t', alloc)
end
local jmp_hook = {hooks = {}}
function jmp_hook.new(cast, callback, hook_addr, size, trampoline, org_bytes_tramp)
jit.off(callback, true) --off jit compilation | thx FYP
local size = size or 5
local trampoline = trampoline or false
local new_hook, mt = {}, {}
local detour_addr = tonumber(ffi.cast('intptr_t', ffi.cast(cast, callback)))
local old_prot = ffi.new('unsigned long[1]')
local org_bytes = ffi.new('uint8_t[?]', size)
copy(org_bytes, hook_addr, size)
if trampoline then
local alloc_addr = VirtualAlloc(nil, size + 5, 0x1000, 0x40, true)
local trampoline_bytes = ffi.new('uint8_t[?]', size + 5, 0x90)
if org_bytes_tramp then
local i = 0
for byte in org_bytes_tramp:gmatch('(%x%x)') do
trampoline_bytes[i] = tonumber(byte, 16)
i = i + 1
end
else
copy(trampoline_bytes, org_bytes, size)
end
trampoline_bytes[size] = 0xE9
ffi.cast('int32_t*', trampoline_bytes + size + 1)[0] = hook_addr - tonumber(alloc_addr) - size + (size - 5)
copy(alloc_addr, trampoline_bytes, size + 5)
new_hook.call = ffi.cast(cast, alloc_addr)
mt = {__call = function(self, ...)
return self.call(...)
end}
else
new_hook.call = ffi.cast(cast, hook_addr)
mt = {__call = function(self, ...)
self.stop()
local res = self.call(...)
self.start()
return res
end}
end
local hook_bytes = ffi.new('uint8_t[?]', size, 0x90)
hook_bytes[0] = 0xE9
ffi.cast('int32_t*', hook_bytes + 1)[0] = detour_addr - hook_addr - 5
new_hook.status = false
local function set_status(bool)
new_hook.status = bool
VirtualProtect(hook_addr, size, 0x40, old_prot)
copy(hook_addr, bool and hook_bytes or org_bytes, size)
VirtualProtect(hook_addr, size, old_prot[0], old_prot)
end
new_hook.stop = function() set_status(false) end
new_hook.start = function() set_status(true) end
new_hook.start()
if org_bytes[0] == 0xE9 or org_bytes[0] == 0xE8 then
print('[WARNING] rewrote another hook'.. (trampoline and ' (old hook was disabled, through trampoline)' or ''))
end
table.insert(jmp_hook.hooks, new_hook)
return setmetatable(new_hook, mt)
end
addEventHandler('onScriptTerminate', function(scr)
if scr == script.this then
for i, hook in ipairs(jmp_hook.hooks) do
if hook.status then
hook.stop()
end
end
for i, addr in ipairs(buff.free) do
ffi.C.VirtualFree(addr, 0, 0x8000)
end
end
end)
---------------------------------------------------------------
local base = getModuleHandle("SAMPFUNCS.asi")
assert(base and base ~= 0, "Can't find SAMPFUNCS.asi file")
local pasteToConsoleInputOrig
local copyToClipboardOrig
local function toggle()
settings.enabled = not settings.enabled
print("ClipboardFix " .. (settings.enabled and "{00ff00}enabled" or "{ff0000}disabled"))
end
local function extract_inline_string(Src, a2, a3, a4, Size)
local data = ffi.new("uint8_t[15]")
ffi.copy(data, ffi.new("uint32_t[1]", tonumber(ffi.cast("uint32_t", Src))), 4)
ffi.copy(data + 4, ffi.new("uint32_t[1]", a2), 4)
ffi.copy(data + 8, ffi.new("uint32_t[1]", a3), 4)
ffi.copy(data + 12, ffi.new("uint32_t[1]", a4), 3) -- максимум 15 байт
return ffi.string(data, Size)
end
local function cp1251ToUtf16(str)
local len = #str
local wideLen = ffi.C.MultiByteToWideChar(ffi.C.CP1251, 0, str, len, nil, 0)
if wideLen == 0 then return nil end
local wchar_buf = ffi.new("wchar_t[?]", wideLen + 1)
ffi.C.MultiByteToWideChar(ffi.C.CP1251, 0, str, len, wchar_buf, wideLen)
wchar_buf[wideLen] = 0 -- null-terminate
return wchar_buf, (wideLen + 1) * 2
end
local function utf16ToCp1251(wstr)
local wlen = 0
while wstr[wlen] ~= 0 do wlen = wlen + 1 end
local mbLen = ffi.C.WideCharToMultiByte(ffi.C.CP1251, 0, wstr, wlen, nil, 0, nil, nil)
if mbLen == 0 then return nil end
local char_buf = ffi.new("char[?]", mbLen + 1)
ffi.C.WideCharToMultiByte(ffi.C.CP1251, 0, wstr, wlen, char_buf, mbLen, nil, nil)
char_buf[mbLen] = 0 -- null-terminate
return ffi.string(char_buf, mbLen)
end
local initialised = false
function main()
if not initialised then
initialised = true
lua_thread.create(function ()
main = nil
end)
if (not isSampLoaded()) or (not isSampfuncsLoaded()) then return false end
while not isSampAvailable() do wait(100) end
-- Переводит формат копируемого текста с CF_TEXT на CF_UNICODETEXT (UTF-16, формат копирования текстов на Windows по большей части)
copyToClipboardOrig = jmp_hook.new("char (__cdecl *)(void **Src, int a2, int a3, int a4, size_t Size, unsigned int a6)",
function (Src, a2, a3, a4, Size, a6)
if not settings.enabled then return copyToClipboardOrig(Src, a2, a3, a4, Size, a6) end
local text
if a6 <= 0xF then
text = extract_inline_string(Src, a2, a3, a4, Size)
else
local str_ptr = ffi.cast("char*", Src)
text = ffi.string(str_ptr, Size)
end
local utf16_text, utf16_len = cp1251ToUtf16(text)
local new_uFormat = ffi.C.CF_UNICODETEXT
if utf16_text == nil then return copyToClipboardOrig(Src, a2, a3, a4, Size, a6) end
local hNew = ffi.C.GlobalAlloc(ffi.C.GMEM_MOVEABLE, utf16_len)
if hNew == nil then return copyToClipboardOrig(Src, a2, a3, a4, Size, a6) end
local new_ptr = ffi.C.GlobalLock(hNew)
if new_ptr == nil then return copyToClipboardOrig(Src, a2, a3, a4, Size, a6) end
ffi.copy(new_ptr, utf16_text, utf16_len)
ffi.C.GlobalUnlock(hNew)
if ffi.C.OpenClipboard(nil) == 0 then return copyToClipboardOrig(Src, a2, a3, a4, Size, a6) end
ffi.C.EmptyClipboard()
ffi.C.SetClipboardData(new_uFormat, hNew)
ffi.C.CloseClipboard()
return 0
end, base + 0x14864)
-- Переводит формат вставляемого текста в поле ввода консоли с CF_UNICODETEXT на CF_TEXT (ANSI/CP1251, стандарт консоли SAMPFUNCS)
pasteToConsoleInputOrig = jmp_hook.new("int (__thiscall *)(int this)",
function (this)
if not settings.enabled then return pasteToConsoleInputOrig(this) end
if ffi.C.OpenClipboard(nil) == 0 then return pasteToConsoleInputOrig(this) end
if ffi.C.EnumClipboardFormats(0) == ffi.C.CF_UNICODETEXT then
local hMem = ffi.C.GetClipboardData(ffi.C.CF_UNICODETEXT)
if hMem == nil then return pasteToConsoleInputOrig(this) end
local ptr = ffi.C.GlobalLock(hMem)
if ptr == nil then return pasteToConsoleInputOrig(this) end
local text = utf16ToCp1251(ffi.cast("wchar_t*", ptr))
local text_len = #text
local text_buf = ffi.new("char[?]", text_len + 1, text)
text_buf[text_len] = 0 -- null-terminated
local uint32_ptr = ffi.cast("uint32_t*", this)
uint32_ptr[0] = 0
uint32_ptr[1] = 0
uint32_ptr[2] = 0
uint32_ptr[3] = 0
uint32_ptr[4] = 0
uint32_ptr[5] = 15
local uint8_ptr = ffi.cast("uint8_t*", this)
uint8_ptr[0] = 0
local sub_10002619 = ffi.cast("void **(__thiscall *)(void **this, void *Src, size_t Size)", base + 0x2619)
sub_10002619(ffi.cast("void**", this), text_buf, text_len)
ffi.C.GlobalUnlock(hMem)
ffi.C.CloseClipboard()
return this
end
ffi.C.CloseClipboard()
return pasteToConsoleInputOrig(this)
end, base + 0x148F1)
sampfuncsRegisterConsoleCommand(settings.consoleCommand, toggle)
print("ClipboardFix " .. (settings.enabled and "{00ff00}enabled" or "{ff0000}disabled"))
while true do
wait(0)
end
end
end
