Форум на Исходниках.RU

Скрытый текст

Файл cmdShell_b.h :

// ---------------------------------------------------------------------------------

// file cmdShell_b.h 2020.02.06

// ---------------------------------------------------------------------------------

#ifndef __cmdShell_b_H__

#define __cmdShell_b_H__

// ---------------------------------------------------------------------------------

//#include "TypeDebugString.h"

#include "memt.h"

#include "mpipe.h"

// ---------------------------------------------------------------------------------

// DbgStr::TypeDebugString(_T("%s bConnected=%d"),_T(__FUNCTION__), bConnected);

// DbgStr::TypeDebugString(_T("%s buf.GetDataSize()=%d"),_T(__FUNCTION__), buf.GetDataSize());

// ---------------------------------------------------------------------------------

class cmdShell_b

{

public:

static const size_t TOUT_DEF_ms = 3000;

static const size_t TOUT_DEF_GET_ms = 250;

static const size_t SIZE_IN = 128*1024;

static const size_t SIZE_PROXY_IN = SIZE_IN;

static const size_t MAX_COMMLINE_BUFF = 32768;

private:

protected:

bool bInstalled;

MEMT<char> proxyIn;

MPIPE In,Out;

STARTUPINFO si;

PROCESS_INFORMATION pi;

TCHAR commLineBuff [MAX_COMMLINE_BUFF];

DWORD dwSizeIn;

DWORD dwSizeOut;

size_t sizePipeInBuf;

virtual bool WINAPI WaitPipeData (size_t dwToutWait=TOUT_DEF_ms,DWORD* pdwSize=NULL);

virtual bool WINAPI GetPipeData (MEMT<char>& buf, DWORD dwGot=0, size_t dwToutGet=TOUT_DEF_GET_ms);

virtual bool WINAPI ReadPipe (bool RetBefore, MEMT<char>& buf, DWORD dwSize);

virtual bool WINAPI AddData (MEMT<char>& tar, MEMT<char>& sou);

bool WINAPI CreatePipes (void);

bool WINAPI PipesExist (void);

bool WINAPI Wait__Process (DWORD tout);

bool WINAPI Check__Pipe (DWORD *pAvail);

bool WINAPI Read__Pipe (char *pData,DWORD size,DWORD *pGot);

bool WINAPI Write__Pipe (char *pData,DWORD size,DWORD *pOut);

public:

WINAPI cmdShell_b (void);

virtual WINAPI ~cmdShell_b (void);

void WINAPI PreSetPipeInSize (size_t size);

virtual bool WINAPI Install (const TCHAR* pCommLine);

virtual bool WINAPI WriteToPipe (const void* pB, size_t size=0);

virtual bool WINAPI WriteToPipe (MEMT<char>& buf);

virtual bool WINAPI ReadFromPipe (MEMT<char>& buf, size_t dwToutWait=TOUT_DEF_ms, size_t dwToutGet=TOUT_DEF_GET_ms);

virtual bool WINAPI WriteWaitRead

(

const void* pB,

size_t size,

MEMT<char>& buf,

size_t dwToutWait = TOUT_DEF_ms,

size_t dwToutGet = TOUT_DEF_GET_ms

);

bool WINAPI UnInstall (void);

bool WINAPI Terminate (UINT uiCode);

};

// ---------------------------------------------------------------------------------

#endif

Файл cmdShell_b.cpp :

// ---------------------------------------------------------------------------------

// FILE cmdShell_b.cpp 2020.02.05

// ---------------------------------------------------------------------------------

#include "stdafx.h"

#include "cmdShell_b.h"

// ---------------------------------------------------------------------------------

WINAPI cmdShell_b::cmdShell_b () :

dwSizeIn (0),

dwSizeOut (0),

bInstalled (false),

sizePipeInBuf (SIZE_IN)

{

::ZeroMemory(&si, sizeof(si));

::ZeroMemory(&pi, sizeof(pi));

}

// ---------------------------------------------------------------------------------

WINAPI cmdShell_b::~cmdShell_b ()

{

UnInstall();

if(pi.hProcess) {::CloseHandle(pi.hProcess);}

if(pi.hThread) {::CloseHandle(pi.hThread);}

}

// ---------------------------------------------------------------------------------

void WINAPI cmdShell_b::PreSetPipeInSize (size_t size)

{

if(size < SIZE_IN) size = SIZE_IN;

sizePipeInBuf = size;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Install(const TCHAR* pCommLine)

{

if(!pCommLine) return false;

if(bInstalled) return false;

if(!proxyIn.Alloc(SIZE_PROXY_IN)) return false;

dwSizeIn = (DWORD)sizePipeInBuf;

if(!CreatePipes ()) return false;

::ZeroMemory(&si, sizeof(si)); si.cb = sizeof(si);

::ZeroMemory(&pi, sizeof(pi));

::GetStartupInfo(&si);

si.dwFlags = STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;

si.wShowWindow = SW_HIDE;

si.hStdOutput = In.GetWriteHandle();

si.hStdError = In.GetWriteHandle(); //подменяем дескрипторы для

si.hStdInput = Out.GetReadHandle(); // дочернего процесса

_sntprintf_s(commLineBuff,ARRAYSIZE(commLineBuff),_TRUNCATE,_T("%s"),pCommLine);

// DbgStr::TypeDebugString(_T("%s %s"),_T(__FUNCTION__), commLineBuff);

(

!::CreateProcess

(

NULL,

commLineBuff,

NULL,

TRUE,

CREATE_NEW_CONSOLE,

NULL,

&si,

&pi

)

) return false;

bInstalled = true;

return true;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::WriteToPipe(const void* pB, size_t size)

{

if(!bInstalled) return false;

if(!pB) return false;

const char* pBuf = (const char*) pB;

if(size==0) size=strlen(pBuf);

DWORD out=0;

bool RetC = false;

RetC = Write__Pipe ((char*)pBuf, (DWORD)size, &out);

return RetC;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::WriteToPipe(MEMT<char>& buf)

{

if(buf.GetDataSize()==0) return false;

return WriteToPipe(buf.GetPointer(), buf.GetDataSize());

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::ReadFromPipe(MEMT<char>& buf, size_t dwToutWait, size_t dwToutGet)

{

if(!bInstalled) return false;

bool RetC = false;

DWORD dwSize = 0;

buf.SetDataSize(0);

for(int ii=0;ii==0;++ii,RetC=true)

{

if(!WaitPipeData(dwToutWait, &dwSize)) break;

if(!GetPipeData(buf, dwSize, dwToutGet)) break;

}

return RetC;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::WriteWaitRead(const void* pB, size_t size, MEMT<char>& buf, size_t dwToutWait, size_t dwToutGet)

{

bool RetC = false;

for(int ii=0;ii==0;++ii,RetC=true)

{

if(pB)

{

if(!WriteToPipe(pB, size)) break;

}

if(!ReadFromPipe(buf, dwToutWait, dwToutGet)) break;

}

return RetC;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::UnInstall(void)

{

if(!bInstalled) return false;

bool RetC=false;

RetC = Terminate (0);

bInstalled = false;

return RetC;

}

// ---------------------------------------------------------------------------------

// bRetC = exb.ExecBatFile(_T("plink -ssh hostOrIp -P port -l user -pw password"));

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::WaitPipeData(size_t dwToutWait, DWORD* pdwSize)

{

bool RetC=false;

DWORD dwSize=0;

if(pdwSize){*pdwSize=0;}

for(size_t i=0;i<dwToutWait;++i)

{

::Sleep(1);

if(Wait__Process(0)) break;

if(Check__Pipe (&dwSize))

{

if(dwSize==0) continue;

else

{

RetC=true;

if(pdwSize){*pdwSize=dwSize;}

break;

}

else break;

}

return RetC;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::GetPipeData(MEMT<char>& buf, DWORD dwGot_, size_t dwToutGet)

{

bool RetC = false;

DWORD dwSize = 0;

DWORD dwGot = dwGot_;

if(dwGot) RetC = true;

for(size_t i=0;i<dwToutGet;++i)

{

::Sleep(1);

if(Wait__Process(0)) break;

if(Check__Pipe (&dwSize))

{

if(dwSize==0) {RetC=false; break;}

else

{

if(dwSize > dwGot)

{

RetC=true; dwGot=dwSize; i=0;

}

else {RetC=false;break;}

}

RetC = ReadPipe(RetC, buf, dwGot);

return RetC;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::ReadPipe(bool RetBefore, MEMT<char>& buf, DWORD dwSize)

{

if(!RetBefore) return false;

if(!buf.Alloc((size_t)dwSize*2)) return false;

buf.MemSet(0);

if(!buf.SetDataSize(0)) return false;

DWORD dwGot=0;

if(!Read__Pipe (buf.GetPointer(), (DWORD)buf.GetSize(), &dwGot)) return false;

if(!buf.SetDataSize((size_t)dwGot)) return false;

return true;

}

// ---------------------------------------------------------------------------------

bool WINAPI cmdShell_b::AddData(MEMT<char>& tar, MEMT<char>& sou)

{

size_t sizetar = tar.GetDataSize();

size_t sizesou = sou.GetDataSize();

size_t sizeres = sizetar+sizesou;

if(sizeres==0) {tar.SetDataSize(0); return true;}

MEMT<char> tmp; if(!tmp.Alloc(sizeres)) return false;

size_t ind = 0;

for(size_t i=0;i<sizetar;++i){ tmp[ind++]=tar[i]; }

for(size_t i=0;i<sizesou;++i){ tmp[ind++]=sou[i]; }

tmp.SetDataSize(sizeres);

tar = tmp;

return true;

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::CreatePipes (void)

{

if(PipesExist ()) return true;

if(!In. Create(dwSizeIn)) return false;

if(!Out.Create(dwSizeOut))return false;

return true;

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::PipesExist (void)

{

bool rIn = In.PipeExist();

bool rOut = Out.PipeExist();

return (rIn && rOut);

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Wait__Process (DWORD tout)

{

DWORD RetC = ::WaitForSingleObject(pi.hProcess, tout);

if(RetC==WAIT_OBJECT_0) return true;

return false;

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Check__Pipe (DWORD *pAvail)

{

return In.CheckPipe(pAvail);

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Read__Pipe (char *pData,DWORD size,DWORD *pGot)

{

return In.ReadPipe(pData,size,pGot);

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Write__Pipe (char *pData,DWORD size,DWORD *pOut)

{

return Out.WritePipe(pData,size,pOut);

}

//----------------------------------------------------------------------------------

bool WINAPI cmdShell_b::Terminate (UINT uiCode)

{

if(!bInstalled) return false;

if(!pi.hProcess) return false;

if(::TerminateProcess(pi.hProcess, uiCode)) return true;

return false;

}

//----------------------------------------------------------------------------------

// DbgStr::TypeDebugString(_T("%s WaitProcess bRet=%d"),_T(__FUNCTION__),bRet);

// ---------------------------------------------------------------------------------