128 lines
3.8 KiB
C++
128 lines
3.8 KiB
C++
/*
|
|
* Injectors - Function Calls Using Variadic Templates
|
|
*
|
|
* Copyright (C) 2014 LINK/2012 <dma_2012@hotmail.com>
|
|
*
|
|
* This software is provided 'as-is', without any express or implied
|
|
* warranty. In no event will the authors be held liable for any damages
|
|
* arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute it
|
|
* freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not
|
|
* claim that you wrote the original software. If you use this software
|
|
* in a product, an acknowledgment in the product documentation would be
|
|
* appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
|
* misrepresented as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source
|
|
* distribution.
|
|
*
|
|
*/
|
|
#pragma once
|
|
#include "injector.hpp"
|
|
#include <utility>
|
|
#include <tuple>
|
|
|
|
#if __cplusplus >= 201103L || _MSC_VER >= 1800 // MSVC 2013
|
|
#else
|
|
#error "This feature is not supported on this compiler"
|
|
#endif
|
|
|
|
namespace injector
|
|
{
|
|
template<class Prototype>
|
|
struct cstd;
|
|
|
|
template<class Ret, class ...Args>
|
|
struct cstd<Ret(Args...)>
|
|
{
|
|
// Call function at @p returning @Ret with args @Args
|
|
static Ret call(memory_pointer_tr p, Args... a)
|
|
{
|
|
auto fn = (Ret(*)(Args...)) p.get<void>();
|
|
return fn(std::forward<Args>(a)...);
|
|
}
|
|
|
|
template<uintptr_t addr> // Uses lazy pointer
|
|
static Ret call(Args... a)
|
|
{
|
|
return call(lazy_pointer<addr>::get(), std::forward<Args>(a)...);
|
|
}
|
|
};
|
|
|
|
template<class Prototype>
|
|
struct stdcall;
|
|
|
|
template<class Ret, class ...Args>
|
|
struct stdcall<Ret(Args...)>
|
|
{
|
|
// Call function at @p returning @Ret with args @Args
|
|
static Ret call(memory_pointer_tr p, Args... a)
|
|
{
|
|
auto fn = (Ret(__stdcall *)(Args...)) p.get<void>();
|
|
return fn(std::forward<Args>(a)...);
|
|
}
|
|
|
|
template<uintptr_t addr> // Uses lazy pointer
|
|
static Ret call(Args... a)
|
|
{
|
|
return call(lazy_pointer<addr>::get(), std::forward<Args>(a)...);
|
|
}
|
|
};
|
|
|
|
template<class Prototype>
|
|
struct fastcall;
|
|
|
|
template<class Ret, class ...Args>
|
|
struct fastcall<Ret(Args...)>
|
|
{
|
|
// Call function at @p returning @Ret with args @Args
|
|
static Ret call(memory_pointer_tr p, Args... a)
|
|
{
|
|
auto fn = (Ret(__fastcall *)(Args...)) p.get<void>();;
|
|
return fn(std::forward<Args>(a)...);
|
|
}
|
|
|
|
template<uintptr_t addr> // Uses lazy pointer
|
|
static Ret call(Args... a)
|
|
{
|
|
return call(lazy_pointer<addr>::get(), std::forward<Args>(a)...);
|
|
}
|
|
};
|
|
|
|
template<class Prototype>
|
|
struct thiscall;
|
|
|
|
template<class Ret, class ...Args>
|
|
struct thiscall<Ret(Args...)>
|
|
{
|
|
// Call function at @p returning @Ret with args @Args
|
|
static Ret call(memory_pointer_tr p, Args... a)
|
|
{
|
|
auto fn = (Ret(__thiscall *)(Args...)) p.get<void>();
|
|
return fn(std::forward<Args>(a)...);
|
|
}
|
|
|
|
// Call function at the index @i from the vtable of the object @a[0]
|
|
template<size_t i>
|
|
static Ret vtbl(Args... a)
|
|
{
|
|
auto obj = raw_ptr(std::get<0>(std::forward_as_tuple(a...)));
|
|
auto p = raw_ptr( (*obj.template get<void**>()) [i] );
|
|
return call(p, std::forward<Args>(a)...);
|
|
}
|
|
|
|
template<uintptr_t addr> // Uses lazy pointer
|
|
static Ret call(Args... a)
|
|
{
|
|
return call(lazy_pointer<addr>::get(), std::forward<Args>(a)...);
|
|
}
|
|
};
|
|
}
|
|
|