LunaHook-mirror/LunaHost/GUI/pluginmanager.cpp
恍兮惚兮 035795a693 safe
2024-06-25 20:39:02 +08:00

417 lines
13 KiB
C++

#include"pluginmanager.h"
#include<filesystem>
#include"Plugin/extension.h"
#include<fstream>
#include <commdlg.h>
#include"LunaHost.h"
#include"Lang/Lang.h"
#include"host.h"
std::optional<std::wstring>SelectFile(HWND hwnd,LPCWSTR lpstrFilter){
OPENFILENAME ofn;
wchar_t szFileName[MAX_PATH] = { 0 };
ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hwnd;
ofn.lpstrFilter = lpstrFilter;
ofn.lpstrFile = szFileName;
ofn.nMaxFile = sizeof(szFileName);
ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_NOCHANGEDIR;
if (GetOpenFileName(&ofn))
{
return szFileName;
}
else return {};
}
typedef std::vector<HMODULE>* (*QtLoadLibrary_t)(std::vector<std::wstring>* dlls);
typedef std::vector<HMODULE>* (*QtLoadLibraryBatch_t)(std::vector<std::wstring>* dlls);
typedef void (*QtFreeLibrary_t)(HMODULE hd);
void tryaddqttoenv(std::vector<std::wstring>&collectQtplugs){
static HMODULE qt5core=0;
if(qt5core==0)
{
wchar_t env[65535];
GetEnvironmentVariableW(L"PATH",env,65535);
auto envs=std::wstring(env);
for(auto&p:collectQtplugs){
envs+=L";";envs+=std::filesystem::path(p).parent_path();
}
SetEnvironmentVariableW(L"PATH",envs.c_str());
qt5core= LoadLibrary(L"Qt5Core.dll");
}
}
std::vector<HMODULE>loadqtdllsX(std::vector<std::wstring>&collectQtplugs){
if(collectQtplugs.empty())return {};
tryaddqttoenv(collectQtplugs);
#if 1
HMODULE base=GetModuleHandle(0);
#else
HMODULE base=LoadLibrary((std::filesystem::current_path()/(x64?"plugin64":"plugin32")/"QtLoader.dll").wstring().c_str());
#endif
//auto QtLoadLibrary = (QtLoadLibrary_t)GetProcAddress(base, "QtLoadLibrary");
auto QtLoadLibrary = (QtLoadLibrary_t)GetProcAddress(base, "QtLoadLibraryBatch");
auto modules=QtLoadLibrary(&collectQtplugs);
std::vector<HMODULE> _{*modules};
delete modules;
return _;
}
HMODULE loadqtdllsX(const std::wstring&collectQtplugs){
std::vector<std::wstring> _ {collectQtplugs};
return loadqtdllsX(_)[0];
}
void Pluginmanager::loadqtdlls(std::vector<std::wstring>&collectQtplugs){
auto modules=loadqtdllsX(collectQtplugs);
for(int i=0;i<collectQtplugs.size();i++){
OnNewSentenceS[collectQtplugs[i]]={collectQtplugs[i],this,true,modules[i]};
}
}
Pluginmanager::Pluginmanager(LunaHost* _host):host(_host),configs(_host->configs){
try {
std::scoped_lock lock(OnNewSentenceSLock);
std::vector<std::wstring>collectQtplugs;
for (auto i=0;i<count();i++) {
auto plg=get(i);
bool isqt=plg.isQt;
auto path=plg.wpath();
OnNewSentenceS[path]={};
if(isqt){
if(plg.enable==false)continue;
collectQtplugs.push_back((path));
}
else{
auto base=LoadLibraryW(path.c_str());
OnNewSentenceS[path]={path,this,false,base};
}
}
loadqtdlls(collectQtplugs);
OnNewSentenceS[L"InternalClipBoard"]={L"",this,false,GetModuleHandle(0)};//内部链接的剪贴板插件
} catch (const std::exception& ex) {
std::wcerr << "Error: " << ex.what() << std::endl;
}
}
bool Pluginmanager::dispatch(TextThread& thread, std::wstring& sentence){
auto sentenceInfo=GetSentenceInfo(thread).data();
wchar_t* sentenceBuffer = (wchar_t*)HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, (sentence.size() + 1) * sizeof(wchar_t));
wcscpy_s(sentenceBuffer, sentence.size() + 1, sentence.c_str());
concurrency::reader_writer_lock::scoped_lock_read readLock(OnNewSentenceSLock);
for(int i=0;i<count()+1;i++){
std::wstring path;
if(i==count())path=L"InternalClipBoard";
else {
if(getenable(i)==false)continue;
path=getname(i);
}
auto funptr=OnNewSentenceS[path].OnNewSentence;
if(funptr==0)continue;
if (!*(sentenceBuffer = funptr(sentenceBuffer, sentenceInfo)))
break;
}
sentence = sentenceBuffer;
HeapFree(GetProcessHeap(), 0, sentenceBuffer);
return !sentence.empty();
}
void Pluginmanager::add(const pluginitem& item){
configs->configs["plugins"].push_back(item.dump());
}
int Pluginmanager::count(){
return configs->configs["plugins"].size();
}
pluginitem Pluginmanager::get(int i){
return pluginitem{configs->configs["plugins"][i]};
}
void Pluginmanager::set(int i,const pluginitem& item){
configs->configs["plugins"][i]=item.dump();
}
pluginitem::pluginitem(const nlohmann::json& js){
path=js["path"];
isQt=safequeryjson(js,"isQt",false);
isref=safequeryjson(js,"isref",false);
enable=safequeryjson(js,"enable",true);
vissetting=safequeryjson(js,"vissetting",true);
}
std::wstring pluginitem::wpath(){
auto wp=StringToWideString(path);
if(isref)return std::filesystem::current_path()/wp;
else return wp;
}
std::pair<std::wstring,bool> castabs2ref(const std::wstring&p){
auto curr=std::filesystem::current_path().wstring();
if(startWith(p,curr)){
return {p.substr(curr.size()+1),true};
}
return {p,false};
}
pluginitem::pluginitem(const std::wstring& pabs,bool _isQt){
isQt=_isQt;
auto [p,_isref]=castabs2ref(pabs);
isref=_isref;
path=WideStringToString(p);
enable=true;
vissetting=true;
}
nlohmann::json pluginitem::dump() const{
return {
{"path",path},
{"isQt",isQt},
{"isref",isref},
{"enable",enable},
{"vissetting",vissetting}
};
}
bool Pluginmanager::getvisible_setable(int idx){
return OnNewSentenceS[getname(idx)].VisSetting;
}
bool Pluginmanager::getvisible(int idx){
return get(idx).vissetting;
}
void Pluginmanager::setvisible(int idx,bool vis){
auto item=get(idx);
item.vissetting=vis;
set(idx,item);
OnNewSentenceS[getname(idx)].VisSetting(vis);
}
bool Pluginmanager::getenable(int idx){
return get(idx).enable;
}
void Pluginmanager::setenable(int idx,bool en){
auto item=get(idx);
item.enable=en;
set(idx,item);
}
std::wstring Pluginmanager::getname(int idx){
return get(idx).wpath();
}
bool Pluginmanager::checkisdump(const std::wstring& dll){
for(auto& p:OnNewSentenceS){
if(p.first==dll)return true;
}
return false;
}
void Pluginmanager::unload(const std::wstring& wss){
auto hm=OnNewSentenceS[wss].hmodule;
if(OnNewSentenceS[wss].isQt && hm){
((QtFreeLibrary_t)GetProcAddress(GetModuleHandle(0),"QtFreeLibrary"))(hm);
}
else
FreeLibrary(hm);
OnNewSentenceS[wss].clear();
}
void plugindata::clear(){
hmodule=0;
OnNewSentence=0;
VisSetting=0;
}
void Pluginmanager::remove(const std::wstring& wss){
unload(wss);
auto s=WideStringToString(wss);
auto &plgs=configs->configs["plugins"];
auto it=std::remove_if(plgs.begin(),plgs.end(),[&](auto&t){
std::string p=t["path"];
return p==s;
});
plgs.erase(it, plgs.end());
OnNewSentenceS.erase(wss);
}
std::optional<std::wstring>Pluginmanager::selectpluginfile(){
return SelectFile(0,L"Plugin Files\0*.dll;*.xdll\0");
}
void Pluginmanager::swaprank(int a,int b){
auto &plgs=configs->configs["plugins"];
auto _b=plgs[b];
plgs[b]=plgs[a];
plgs[a]=_b;
}
DWORD Rva2Offset(DWORD rva, PIMAGE_SECTION_HEADER psh, PIMAGE_NT_HEADERS pnt)
{
size_t i = 0;
PIMAGE_SECTION_HEADER pSeh;
if (rva == 0)
{
return (rva);
}
pSeh = psh;
for (i = 0; i < pnt->FileHeader.NumberOfSections; i++)
{
if (rva >= pSeh->VirtualAddress && rva < pSeh->VirtualAddress +
pSeh->Misc.VirtualSize)
{
break;
}
pSeh++;
}
if(pSeh->VirtualAddress==0||pSeh->PointerToRawData==0)return -1;
return (rva - pSeh->VirtualAddress + pSeh->PointerToRawData);
}
std::set<std::string> getimporttable(const std::wstring&pe){
AutoHandle handle = CreateFile(pe.c_str(), GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
if(!handle)return {};
DWORD byteread, size = GetFileSize(handle, NULL);
PVOID virtualpointer = VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_READWRITE);
if(!virtualpointer) return {};
ReadFile(handle, virtualpointer, size, &byteread, NULL);
struct __{
PVOID _ptr;DWORD size;
__(PVOID ptr,DWORD sz):_ptr(ptr),size(sz){}
~__(){
VirtualFree(_ptr, size, MEM_DECOMMIT);
}
}_(virtualpointer,size);
if(PIMAGE_DOS_HEADER(virtualpointer)->e_magic!=0x5a4d)
return {};
PIMAGE_NT_HEADERS ntheaders = (PIMAGE_NT_HEADERS)(PCHAR(virtualpointer) + PIMAGE_DOS_HEADER(virtualpointer)->e_lfanew);
auto magic=ntheaders->OptionalHeader.Magic;
if(x64 && (magic!=IMAGE_NT_OPTIONAL_HDR64_MAGIC))return {};
if((!x64)&&(magic!=IMAGE_NT_OPTIONAL_HDR32_MAGIC))return {};
PIMAGE_SECTION_HEADER pSech = IMAGE_FIRST_SECTION(ntheaders);//Pointer to first section header
PIMAGE_IMPORT_DESCRIPTOR pImportDescriptor; //Pointer to import descriptor
if (ntheaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size == 0)/*if size of the table is 0 - Import Table does not exist */
return {};
std::set<std::string> ret;
pImportDescriptor = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD_PTR)virtualpointer + \
Rva2Offset(ntheaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress, pSech, ntheaders));
while (pImportDescriptor->Name != NULL)
{
//Get the name of each DLL
auto nameoffset=Rva2Offset(pImportDescriptor->Name, pSech, ntheaders);
if(nameoffset==(DWORD)-1)
//无导入
return {};
ret.insert((PCHAR)((DWORD_PTR)virtualpointer + nameoffset ));
pImportDescriptor++; //advance to next IMAGE_IMPORT_DESCRIPTOR
}
return ret;
}
bool qtchecker(const std::set<std::string>& dll)
{
for(auto qt5:{"Qt5Widgets.dll","Qt5Gui.dll","Qt5Core.dll"})
if(dll.find(qt5)!=dll.end())
return true;
return false;
}
addpluginresult Pluginmanager::load(const std::wstring& p,bool*isqt){
auto importtable=getimporttable(p);
if(importtable.empty())return addpluginresult::invaliddll;
auto isQt=qtchecker(importtable);
if(isqt)*isqt=isQt;
HMODULE base;
if(isQt){
base=loadqtdllsX(p);
}
else{
base=LoadLibraryW(p.c_str());
}
if(base==0)return addpluginresult::invaliddll;
std::scoped_lock lock(OnNewSentenceSLock);
OnNewSentenceS[p]={p,this,isQt,base};
if(!OnNewSentenceS[p].valid())
return addpluginresult::isnotaplugins;
return addpluginresult::success;
}
bool plugindata::valid(){
return OnNewSentence;
}
plugindata::plugindata(const std::wstring& p,Pluginmanager* manager,bool _isQt,HMODULE hm){
hmodule=hm;
isQt=_isQt;
OnNewSentence=(OnNewSentence_t)GetProcAddress(hm,"OnNewSentence");
VisSetting=(VisSetting_t)GetProcAddress(hm,"VisSetting");
refpath=p;
if(VisSetting)
{
auto vis=true;
if(auto plg=manager->get(p))
vis=plg.value().vissetting;
VisSetting(vis);
}
}
void plugindata::initstatus(const pluginitem& plg){
if(plg.vissetting && VisSetting)
VisSetting(true);
}
std::optional<pluginitem> Pluginmanager::get(const std::wstring&p){
for(int i=0;i<count();i++)
{
if(getname(i)==p){
return get(i);
}
}
return {};
}
addpluginresult Pluginmanager::addplugin(const std::wstring& p){
if(checkisdump(p))return addpluginresult::dumplicate;
bool isQt;
auto ret=load(p,&isQt);
if(ret==addpluginresult::success){
add({p,isQt});
}
return ret;
}
std::array<InfoForExtension, 20> Pluginmanager::GetSentenceInfo(TextThread& thread)
{
void (*AddText)(int64_t, const wchar_t*) = [](int64_t number, const wchar_t* text)
{
if (TextThread* thread = Host::GetThread(number)) thread->Push(text);
};
void (*AddSentence)(int64_t, const wchar_t*) = [](int64_t number, const wchar_t* sentence)
{
if (TextThread* thread = Host::GetThread(number)) thread->AddSentence(sentence);;
};
static DWORD SelectedProcessId;
auto currthread=(TextThread*)host->currentselect;
SelectedProcessId=(currthread!=0)?currthread->tp.processId:0;
DWORD (*GetSelectedProcessId)() = [] { return SelectedProcessId; };
return
{ {
{ "HostHWND",(int64_t)host->winId },
{ "toclipboard", host->check_toclipboard },
{ "current select", &thread == currthread },
{ "text number", thread.handle },
{ "process id", thread.tp.processId },
{ "hook address", (int64_t)thread.tp.addr },
{ "text handle", thread.handle },
{ "text name", (int64_t)thread.name.c_str() },
{ "add sentence", (int64_t)AddSentence },
{ "add text", (int64_t)AddText },
{ "get selected process id", (int64_t)GetSelectedProcessId },
{ "void (*AddSentence)(int64_t number, const wchar_t* sentence)", (int64_t)AddSentence },
{ "void (*AddText)(int64_t number, const wchar_t* text)", (int64_t)AddText },
{ "DWORD (*GetSelectedProcessId)()", (int64_t)GetSelectedProcessId },
{ nullptr, 0 } // nullptr marks end of info array
} };
}