Public-Mirror/Textractor
1
0
Fork 1
mirror of https://github.com/Artikash/Textractor.git synced 2024-12-23 17:04:12 +08:00
Code Issues Projects Releases Wiki Activity

clean up textthread some more

Browse Source
This commit is contained in:
Akash Mozumdar 2018-06-10 19:15:05 -04:00
parent c80f36efff
commit 5f24f1efd7
4 changed files with 29 additions and 317 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
gui/window.cpp
View File

@ -424,7 +424,7 @@ void ClickButton(HWND hWnd, HWND h)
// return len; // return len;
//} //}
DWORD ThreadOutput(TextThread* thread, BYTE* out, DWORD len, DWORD new_line, PVOID data, bool space) DWORD ThreadOutput(TextThread* thread, BYTE* out, DWORD len, DWORD new_line, bool space)
{ {
if (len == 0) if (len == 0)
return len; return len;

26
vnr/texthook/host/hookman.cc
View File

@ -88,21 +88,21 @@ bool operator==(const ThreadParameter& one, const ThreadParameter& two)
#define NAMED_PIPE_DISCONNECT 1 #define NAMED_PIPE_DISCONNECT 1
//Class member of HookManger //Class member of HookManger
HookManager::HookManager() : HookManager::HookManager() :
// jichi 9/21/2013: Zero memory // jichi 9/21/2013: Zero memory
//CRITICAL_SECTION hmcs; //CRITICAL_SECTION hmcs;
current(nullptr) current(nullptr)
, create(nullptr) , create(nullptr)
, remove(nullptr) , remove(nullptr)
, reset(nullptr) , reset(nullptr)
, attach(nullptr) , attach(nullptr)
, detach(nullptr) , detach(nullptr)
, hook(nullptr) , hook(nullptr)
, current_pid(0) , current_pid(0)
, new_thread_number(0) , new_thread_number(0)
, threadTable() , threadTable()
, processRecordsByIds() , processRecordsByIds()
{ {
TextThread* consoleTextThread = threadTable[{0, -1UL, -1UL, -1UL}] = new TextThread(0, -1, -1, -1, new_thread_number++); TextThread* consoleTextThread = threadTable[{0, -1UL, -1UL, -1UL}] = new TextThread({ 0, -1UL, -1UL, -1UL }, new_thread_number++);
consoleTextThread->Status() |= USING_UNICODE; consoleTextThread->Status() |= USING_UNICODE;
SetCurrent(consoleTextThread); SetCurrent(consoleTextThread);
} }
@ -304,7 +304,7 @@ void HookManager::DispatchText(DWORD pid, const BYTE *text, DWORD hook, DWORD re
TextThread *it; TextThread *it;
if (!(it = threadTable[tp])) if (!(it = threadTable[tp]))
{ {
it = threadTable[tp] = new TextThread(pid, hook, retn, spl, new_thread_number++); it = threadTable[tp] = new TextThread(tp, new_thread_number++);
if (create) if (create)
{ {
create(it); create(it);

287
vnr/texthook/host/textthread.cc
View File

@ -43,82 +43,19 @@ void CALLBACK NewLineBuff(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
id->SetNewLineFlag(); id->SetNewLineFlag();
} }
// jichi 10/27/2013: removed TextThread::TextThread(ThreadParameter tp, WORD num) :
//void CALLBACK NewLineConsole(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
//{
// KillTimer(hwnd,idEvent);
// TextThread *id=(TextThread*)idEvent;
// if (id->Status()&USING_UNICODE)
// id->AddText((BYTE*)L"\r\n",4,true,true);
// if (id->Status()&CURRENT_SELECT)
// {
// //texts->SetLine();
// }
//}
// jichi 10/27/2013: removed
//void ReplaceSentence(BYTE* text, int len)
//{
// __asm int 3
//}
TextThread::TextThread(DWORD id, DWORD hook, DWORD retn, DWORD spl, WORD num) :
//,tp //,tp
thread_number(num) thread_number(num)
// jichi 9/21/2013: zero all fields
, link_number(-1)
, last (0)
, align_space(0)
, repeat_single(0)
, repeat_single_current(0)
, repeat_single_count(0)
, repeat_detect_count(0)
, head(new RepeatCountNode())
, link(nullptr)
//, filter(nullptr)
, output(nullptr) , output(nullptr)
, app_data(nullptr)
//, comment(nullptr) //, comment(nullptr)
, thread_string(nullptr)
, timer(0) , timer(0)
, status (0) , status (0)
, repeat_detect_limit(0x80)
, last_sentence(0) , last_sentence(0)
, prev_sentence(0)
, sentence_length(0) , sentence_length(0)
, repeat_index(0) , tp(tp)
, last_time(0)
// , tp({id, hook, retn, spl})
{ {
tp.pid = id;
tp.hook = hook;
tp.retn = retn;
tp.spl = spl;
//head = new RepeatCountNode;
//::memset(head, 0, sizeof(RepeatCountNode)); // jichi 9/21/2013: zero memory
//link_number = -1;
//repeat_detect_limit = 0x80;
//filter = nullptr;
//output = nullptr;
}
TextThread::~TextThread()
{
//KillTimer(dummyWindow,timer);
RepeatCountNode *t = head,
*tt;
while (t) {
tt = t;
t = tt->next;
delete tt;
}
head = nullptr;
//if (comment) {
// delete[] comment;
// comment = nullptr;
//}
if (thread_string)
delete[] thread_string;
} }
void TextThread::Reset() void TextThread::Reset()
{ {
//timer=0; //timer=0;
@ -129,165 +66,31 @@ void TextThread::Reset()
//} //}
MyVector::Reset(); MyVector::Reset();
} }
void TextThread::RemoveSingleRepeatAuto(const BYTE *con, int &len)
{
#ifdef ITH_DISABLE_REPEAT // jichi 9/28/2013: only for debugging purpose
return;
#endif // ITH_DISABLE_REPEAT
WORD *text = (WORD *)con;
if (len <= 2) {
if (repeat_single) {
if (repeat_single_count<repeat_single&&
last == *text) {
len = 0;
repeat_single_count++;
} else {
last = *text;
repeat_single_count=0;
}
}
if (status & REPEAT_NUMBER_DECIDED) {
if (++repeat_detect_count>MIN_REDETECT) {
repeat_detect_count = 0;
status ^= REPEAT_NUMBER_DECIDED;
last = 0;
RepeatCountNode *t = head,
*tt;
while (t) {
tt = t;
t = tt->next;
delete tt;
}
head = new RepeatCountNode;
::memset(head, 0, sizeof(RepeatCountNode)); // jichi 9/21/2013: zero memory
}
} else {
repeat_detect_count++;
if (last == *text)
repeat_single_current++;
else {
if (last == 0) {
last = *text;
return;
}
if (repeat_single_current == 0) {
status |= REPEAT_NUMBER_DECIDED;
repeat_single = 0;
return;
}
last = *text;
RepeatCountNode *it = head;
if (repeat_detect_count > MIN_DETECT) {
while (it = it->next)
if (it->count>head->count) {
head->count=it->count;
head->repeat=it->repeat;
}
repeat_single = head->repeat;
repeat_single_current = 0;
repeat_detect_count = 0;
status |= REPEAT_NUMBER_DECIDED;
DWORD repeat_sc = repeat_single*4;
if (repeat_sc > MIN_DETECT) {
MIN_DETECT <<= 1;
MIN_REDETECT <<= 1;
}
} else {
bool flag=true;
while (it) {
if (it->repeat == repeat_single_current) {
it->count++;
flag = false;
break;
}
it=it->next;
}
if (flag) {
RepeatCountNode *n = new RepeatCountNode;
n->count = 1;
n->repeat = repeat_single_current;
n->next = head->next;
head->next = n;
}
repeat_single_current = 0;
} //Decide repeat_single
} //Check Repeat
} //repeat_single decided?
} //len
else {
status |= REPEAT_NUMBER_DECIDED;
repeat_single = 0;
}
}
void TextThread::AddLineBreak() void TextThread::AddLineBreak()
{ {
if (sentence_length == 0) return; if (sentence_length == 0) return;
if (status&BUFF_NEWLINE) if (status&BUFF_NEWLINE)
{ {
prev_sentence=last_sentence;
sentence_length=0; sentence_length=0;
if (status & USING_UNICODE) if (status & USING_UNICODE)
AddToStore((BYTE *)L"\r\n\r\n", 8); AddToStore((BYTE *)L"\r\n\r\n", 8);
else else
AddToStore((BYTE *)"\r\n\r\n", 4); AddToStore((BYTE *)"\r\n\r\n", 4);
if (output) if (output)
output(this, 0, 8, TRUE, app_data, false); // jichi 10/27/2013: space is false output(this, 0, 8, TRUE, false); // jichi 10/27/2013: space is false
last_sentence = used; last_sentence = used;
status &= ~BUFF_NEWLINE; status &= ~BUFF_NEWLINE;
} }
} }
void TextThread::AddText(const BYTE *con, int len, bool new_line, bool space) void TextThread::AddText(const BYTE *con, int len, bool new_line, bool space)
{ {
if (!con || (len <= 0 && !space))
return;
if (len && !new_line) {
// jichi 9/1/2013: manual repetition count removed
//if (setman->GetValue(SETTING_REPEAT_COUNT)) {
// status|=REPEAT_NUMBER_DECIDED;
// RemoveSingleRepeatForce(con,len);
//}
//else
RemoveSingleRepeatAuto(con, len);
if (len <= 0 && !space)
return;
}
// jichi 9/1/2013: manual repetition count removed
//if(setman->GetValue(SETTING_CYCLIC_REMOVE)) {
// //if (status & REPEAT_NUMBER_DECIDED)
// RemoveCyclicRepeat(con,len);
//}
//if (len <= 0)
// return;
// jichi 10/27/2013: User-defined filter callback is disabled
//if (filter)
// len = filter(this, con,len, new_line, app_data);
//if (len <= 0)
// return;
if (len && sentence_length == 0) {
if (status & USING_UNICODE) {
if (*(WORD *)con == 0x3000) { // jichi 10/27/2013: why skip unicode space?!
con += 2;
len -= 2;
}
} else if (*(WORD *)con == 0x4081) {
con += 2;
len -= 2;
}
if (len <= 0 && !space)
return;
}
if (status & BUFF_NEWLINE) if (status & BUFF_NEWLINE)
AddLineBreak(); AddLineBreak();
if (len) if (len)
if (new_line) { if (new_line) {
prev_sentence = last_sentence;
last_sentence = used + 4; last_sentence = used + 4;
if (status & USING_UNICODE) if (status & USING_UNICODE)
last_sentence += 4; last_sentence += 4;
@ -297,9 +100,10 @@ void TextThread::AddText(const BYTE *con, int len, bool new_line, bool space)
sentence_length += len; sentence_length += len;
} }
if (len <= 0) return;
BYTE *data = const_cast<BYTE *>(con); // jichi 10/27/2013: TODO: Figure out where con is modified BYTE *data = const_cast<BYTE *>(con); // jichi 10/27/2013: TODO: Figure out where con is modified
if (output) if (output)
len = output(this, data, len, new_line, app_data, space); len = output(this, data, len, new_line, space);
if (AddToStore(data, len)) { if (AddToStore(data, len)) {
//sentence_length += len; //sentence_length += len;
/*ResetRepeatStatus(); /*ResetRepeatStatus();
@ -311,40 +115,11 @@ void TextThread::AddText(const BYTE *con, int len, bool new_line, bool space)
} }
} }
DWORD TextThread::GetEntryString(LPSTR str, DWORD max) void TextThread::GetEntryString(LPSTR buffer, DWORD max)
{ {
DWORD len = 0; int len = sprintf(buffer, "%.4X:%.4d:0x%08X:0x%08X:0x%08X:",
if (str && max > 0x40) {
max--;
if (thread_string) {
len = ::strlen(thread_string);
len = len < max ? len : max;
memcpy(str, thread_string, len);
str[len] = 0;
} else {
len = ::sprintf(str, "%.4X:%.4d:0x%08X:0x%08X:0x%08X:",
thread_number, tp. pid, tp.hook, tp.retn, tp.spl); thread_number, tp. pid, tp.hook, tp.retn, tp.spl);
GetHookName(buffer + len, tp.pid, tp.hook, max - len);
len += GetHookName(str + len, tp.pid, tp.hook, max - len);
thread_string = new char[len + 1];
//::memset(thread_string, 0, (len+1) * sizeof(wchar_t)); // jichi 9/26/2013: zero memory
thread_string[len] = 0;
::memcpy(thread_string, str, len);
}
//if (comment) {
// str += len;
// max--;
// DWORD cl = wcslen(comment);
// if (len + cl >= max)
// cl = max - len;
// *str++ = L'-';
// memcpy(str, comment, cl << 1);
// str[cl] = 0;
// len += cl;
//}
}
return len;
} }
// jichi 9/28/2013: removed // jichi 9/28/2013: removed
//void TextThread::CopyLastSentence(LPWSTR str) //void TextThread::CopyLastSentence(LPWSTR str)
@ -443,50 +218,6 @@ void TextThread::DispatchLastSentence()
} }
//void TextThread::ResetEditText()
//{
// //__asm int 3;
// WCHAR str[0x20];
// swprintf(str,L"%.8X",_ReturnAddress());
//}
// jichi 9/25/2013: Removed
//void TextThread::ExportTextToFile(LPWSTR) //filename)
//{
// HANDLE hFile=IthCreateFile(filename,FILE_WRITE_DATA,0,FILE_OPEN_IF);
// if (hFile==INVALID_HANDLE_VALUE) return;
// EnterCriticalSection(&cs_store);
// IO_STATUS_BLOCK ios;
// LPVOID buffer=storage;
// DWORD len=used;
// BYTE bom[4]={0xFF,0xFE,0,0};
// LARGE_INTEGER offset={2,0};
// if ((status&USING_UNICODE)==0)
// {
// len=MB_WC_count((char*)storage,used);
// buffer = new wchar_t[len+1];
// MB_WC((char*)storage,(wchar_t*)buffer);
// len<<=1;
// }
// NtWriteFile(hFile,0,0,0,&ios,bom,2,0,0);
// NtWriteFile(hFile,0,0,0,&ios,buffer,len,&offset,0);
// NtFlushBuffersFile(hFile,&ios);
// if (buffer !=storage)
// delete[] buffer;
// NtClose(hFile);
// LeaveCriticalSection(&cs_store);
//}
//void TextThread::SetComment(LPWSTR str)
//{
// if (comment)
// delete[] comment;
// size_t sz = wcslen(str);
// comment = new wchar_t[sz + 1];
// comment[sz] = 0;
// wcscpy(comment, str);
//}
void TextThread::SetNewLineFlag() { status |= BUFF_NEWLINE; } void TextThread::SetNewLineFlag() { status |= BUFF_NEWLINE; }
void TextThread::SetNewLineTimer() void TextThread::SetNewLineTimer()

31
vnr/texthook/host/textthread.h
View File

@ -34,7 +34,7 @@ struct ThreadParameter {
class TextThread; class TextThread;
typedef void (* ConsoleCallback)(LPCSTR text); typedef void (* ConsoleCallback)(LPCSTR text);
typedef void (* ConsoleWCallback)(LPCWSTR text); typedef void (* ConsoleWCallback)(LPCWSTR text);
typedef DWORD (* ThreadOutputFilterCallback)(TextThread *, BYTE *, DWORD, DWORD, PVOID, bool space); // jichi 10/27/2013: Add space typedef DWORD (* ThreadOutputFilterCallback)(TextThread *, BYTE *, DWORD, DWORD, bool space); // jichi 10/27/2013: Add space
typedef DWORD (* ThreadEventCallback)(TextThread *); typedef DWORD (* ThreadEventCallback)(TextThread *);
//extern DWORD split_time,repeat_count,global_filter,cyclic_remove; //extern DWORD split_time,repeat_count,global_filter,cyclic_remove;
@ -42,14 +42,12 @@ typedef DWORD (* ThreadEventCallback)(TextThread *);
class TextThread : public MyVector<BYTE, 0x200> class TextThread : public MyVector<BYTE, 0x200>
{ {
public: public:
TextThread(DWORD pid, DWORD hook, DWORD retn, DWORD spl, WORD num); TextThread(ThreadParameter tp, WORD num);
~TextThread();
virtual DWORD GetEntryString(LPSTR str, DWORD max = 0x200); virtual void GetEntryString(LPSTR buffer, DWORD max);
void Reset(); void Reset();
void AddText(const BYTE *con,int len, bool new_line, bool space); // jichi 10/27/2013: add const; remove console; add space void AddText(const BYTE *con,int len, bool new_line, bool space); // jichi 10/27/2013: add const; remove console; add space
void RemoveSingleRepeatAuto(const BYTE *con, int &len); // jichi 10/27/2013: add const
void AddLineBreak(); void AddLineBreak();
void DispatchLastSentence(); void DispatchLastSentence();
@ -67,35 +65,18 @@ public:
ThreadOutputFilterCallback RegisterOutputCallBack(ThreadOutputFilterCallback cb, PVOID data) ThreadOutputFilterCallback RegisterOutputCallBack(ThreadOutputFilterCallback cb, PVOID data)
{ {
app_data = data;
return (ThreadOutputFilterCallback)_InterlockedExchange((long*)&output,(long)cb); return (ThreadOutputFilterCallback)_InterlockedExchange((long*)&output,(long)cb);
} }
private: private:
ThreadParameter tp; ThreadParameter tp;
WORD thread_number, WORD thread_number;
link_number;
WORD last,
align_space;
WORD repeat_single;
WORD repeat_single_current;
WORD repeat_single_count;
WORD repeat_detect_count;
RepeatCountNode *head;
TextThread *link;
ThreadOutputFilterCallback filter; // jichi 10/27/2013: Remove filter
ThreadOutputFilterCallback output; ThreadOutputFilterCallback output;
PVOID app_data;
LPSTR thread_string;
UINT_PTR timer; UINT_PTR timer;
DWORD status,repeat_detect_limit; DWORD status;
DWORD last_sentence, DWORD last_sentence,
prev_sentence, sentence_length;
sentence_length,
repeat_index,
last_time;
}; };
// EOF // EOF