BOOL WINAPI CreateProcessACallBack(LPCSTR lpApplicationName,
LPSTR lpCommandLine,
LPSECURITY_ATTRIBUTES lpProcessAttributes,
LPSECURITY_ATTRIBUTES lpThreadAttributes,
BOOL bInheritHandles,
DWORD dwCreationFlags,
LPVOID lpEnvironment,
LPCSTR lpCurrentDirectory,
LPSTARTUPINFOA lpStartupInfo,
LPPROCESS_INFORMATION lpProcessInformation)
{
DWORD dwMyCreationFlags = (dwCreationFlags | CREATE_SUSPENDED);
PROCESS_INFORMATION pi;
int ret;
DEBUG_INFO("Current Process (%d)\n",GetCurrentProcessId());
if(!CreateProcessANext(lpApplicationName,
lpCommandLine,
lpProcessAttributes,
lpThreadAttributes,
bInheritHandles,
dwMyCreationFlags,
lpEnvironment,
lpCurrentDirectory,
lpStartupInfo,
&pi))
{
ret = LAST_ERROR_CODE();
DEBUG_INFO("lasterror %d\n",ret);
SetLastError(ret);
return FALSE;
}
DEBUG_INFO("\n");
if(!InsertDlls(pi.hProcess))
{
ret = LAST_ERROR_CODE();
SetLastError(ret);
return FALSE;
}
DEBUG_INFO("\n");
if(lpProcessInformation)
{
CopyMemory(lpProcessInformation, &pi, sizeof(pi));
}
if(!(dwCreationFlags & CREATE_SUSPENDED))
{
ResumeThread(pi.hThread);
}
DEBUG_INFO("\n");
return TRUE;
}
HANDLE CreateMapFile(const char* pMapFileName,int size,int create)
{
HANDLE hMapFile=NULL;
int ret;
#ifdef _UNICODE
wchar_t* pMapFileW=NULL;
int mapfilesize=0;
ret = AnsiToUnicode((char*)pMapFileName,&pMapFileW,&mapfilesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
goto fail;
}
if(create)
{
hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,size,pMapFileW);
}
else
{
hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,pMapFileW);
}
#else
if(create)
{
hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE,NULL,PAGE_READWRITE,0,size,pMapFileName);
}
else
{
hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS,FALSE,pMapFileName);
}
#endif
if(hMapFile == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
#ifdef _UNICODE
AnsiToUnicode(NULL,&pMapFileW,&mapfilesize);
#endif
return hMapFile;
fail:
if(hMapFile)
{
CloseHandle(hMapFile);
}
hMapFile = NULL;
#ifdef _UNICODE
AnsiToUnicode(NULL,&pMapFileW,&mapfilesize);
#endif
SetLastError(ret);
return NULL;
}
static int DetourCreateProcessFunctions()
{
PVOID OldCreatW=NULL,OldCreateA=NULL;
#if 0
CreateProcessNext =(CreateProcessFunc_t) GetProcAddress(hModule,(LPCSTR)TEXT("CreateProcess"));
if(CreateProcessNext == NULL)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not get process addr for CreateProcess error(%d)\n",ret);
goto fail;
}
#endif
OldCreatW = (PVOID)CreateProcessWNext;
DEBUG_INFO("CreateProcess Code");
DEBUG_BUFFER(OldCreatW,5);
OldCreateA = (PVOID)CreateProcessANext;
DEBUG_BUFFER(OldCreateA,5);
DetourTransactionBegin();
DetourUpdateThread(GetCurrentThread());
DetourAttach((PVOID*)&CreateProcessWNext,CreateProcessWCallBack);
DetourAttach((PVOID*)&CreateProcessANext,CreateProcessACallBack);
DetourTransactionCommit();
DEBUG_INFO("After Detour Code");
DEBUG_BUFFER(OldCreatW,5);
DEBUG_BUFFER(OldCreateA,5);
DEBUG_INFO("createprocess detour\n");
return 0;
}
int StartThreadControl(thread_control_t* pThrControl,ThreadFunc_t pStartFunc,LPVOID pParam,int startnow)
{
int ret;
if(pThrControl == NULL) {
ret = ERROR_INVALID_PARAMETER;
SetLastError(ret);
return -ret;
}
StopThreadControl(pThrControl);
/*now first to make handle of event*/
pThrControl->exitevt = GetEvent(NULL,1);
if(pThrControl->exitevt == NULL) {
ret = LAST_ERROR_CODE();
ERROR_INFO("could not create event Error(%d)\n",ret);
goto fail;
}
pThrControl->running = 1;
pThrControl->exited = 0;
/*now start thread*/
pThrControl->thread = CreateThread(NULL,0,pStartFunc,pParam,startnow ? 0 : CREATE_SUSPENDED , &(pThrControl->threadid));
if(pThrControl->thread == NULL) {
ret = LAST_ERROR_CODE();
/*we need make it exited*/
pThrControl->exited = 1;
ERROR_INFO("could not create thread (0x%p:0x%p) Error(%d)\n",
pStartFunc,pParam,ret);
goto fail;
}
SetLastError(0);
return 0;
fail:
assert(ret > 0);
StopThreadControl(pThrControl);
SetLastError(ret);
return -ret;
}
int main(int argc, char* argv[])
{
BOOL bret;
int ret;
char* pCommandLine=NULL;
STARTUPINFOA si;
PROCESS_INFORMATION pi;
memset(&si,0,sizeof(si));
memset(&pi,0,sizeof(pi));
si.cb = 0;
pCommandLine = FormatCommandLine(argc,argv,1);
if(pCommandLine == NULL)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("format arg error(%d)\n",ret);
return -ret;
}
DEBUG_INFO("createprocessA 0x%p\n",CreateProcessA);
/*now create process*/
bret = CreateProcessA(NULL,pCommandLine,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not run process (%s) error(%d)\n",pCommandLine,ret);
free(pCommandLine);
return -ret;
}
DEBUG_INFO("RunProcess %s\n",pCommandLine);
while(1)
{
Sleep(1000);
}
free(pCommandLine);
return 0;
}
int BindUdp(int port)
{
int ret;
int sock=-1;
struct sockaddr_in saddr;
sock = socket(AF_INET,SOCK_DGRAM,0);
if(sock < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("socket error (%d)\n",ret);
goto fail;
}
memset(&saddr,0,sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
saddr.sin_port = htons(port);
ret = bind(sock,(struct sockaddr*)&saddr,sizeof(saddr));
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("bind error (%d)\n",ret);
goto fail;
}
return sock;
fail:
if(sock >= 0)
{
close(sock);
}
sock = -1;
return ret;
}
int ResumeThreadControl(thread_control_t * pThrControl)
{
int ret;
DWORD dret;
if(pThrControl == NULL || pThrControl->thread == NULL) {
ret = ERROR_INVALID_PARAMETER;
SetLastError(ret);
return -ret;
}
dret = ResumeThread(pThrControl->thread);
if(dret == (DWORD)-1) {
ret = LAST_ERROR_CODE();
/*we make sure this will exited ,when it */
pThrControl->exited = 1;
ERROR_INFO("Thread[0x%p] resume Error(%d)\n",pThrControl->thread,ret);
SetLastError(ret);
return -ret;
}
SetLastError(0);
return dret;
}
int InsertModuleFileName(HMODULE hModule)
{
HANDLE hProcess=NULL;
DWORD dret;
#ifdef _UNICODE
wchar_t *pModuleFullNameW=NULL;
int modulefullnamesize=0;
#else
char *pModuleFullNameA=NULL;
#endif
char* pModuleFullName=NULL,*pModulePartName=NULL;
int lasterr=0;
int ret;
unsigned int fullnamesize=1024;
if(st_InjectModuleInited == 0)
{
return -ERROR_NOT_SUPPORTED;
}
hProcess = GetCurrentProcess();
do
{
lasterr = 0;
#ifdef _UNICODE
pModuleFullNameW = (wchar_t*)calloc(sizeof(*pModuleFullNameW),fullnamesize);
if(pModuleFullNameW == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
dret = GetModuleFileNameEx(hProcess,hModule,pModuleFullNameW,fullnamesize);
#else
pModuleFullNameA = calloc(sizeof(*pModuleFullNameA),fullnamesize);
if(pModuleFullNameA == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
dret = GetModuleFileNameEx(hProcess,hModule,pModuleFullNameA,fullnamesize);
#endif
if(dret == 0 || dret >= fullnamesize)
{
lasterr = LAST_ERROR_CODE();
#ifdef _UNICODE
free(pModuleFullNameW);
pModuleFullNameW = NULL;
#else
free(pModuleFullNameA);
pModuleFullNameA = NULL;
#endif
fullnamesize <<= 1;
}
}
while(lasterr == ERROR_INSUFFICIENT_BUFFER);
if(dret == 0 || dret >= fullnamesize)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("can not get [0x%x:0x%x] modulefilename error(%d)\n",hProcess,hModule,ret);
goto fail;
}
#ifdef _UNICODE
ret = UnicodeToAnsi(pModuleFullNameW,&pModuleFullName,&modulefullnamesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
goto fail;
}
#else
pModuleFullName = pModuleFullNameA;
#endif
/*now get the name so we should*/
pModulePartName = strrchr(pModuleFullName,'\\');
if(pModulePartName)
{
pModulePartName ++;
}
else
{
pModulePartName = pModuleFullName;
}
/*now insert the dlls*/
DEBUG_INFO("Insert into(%s:%s)\n",pModuleFullName,pModulePartName);
ret = InsertDllNames(pModuleFullName,pModulePartName);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not insert (%s:%s) error(%d)\n",pModuleFullName,pModulePartName,ret);
goto fail;
}
DEBUG_INFO("Insert (%s:%s) succ\n",pModuleFullName,pModulePartName);
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pModuleFullName,&modulefullnamesize);
if(pModuleFullNameW)
{
free(pModuleFullNameW);
}
pModuleFullNameW = NULL;
pModulePartName = NULL;
#else
if(pModuleFullNameA)
{
free(pModuleFullNameA);
}
pModuleFullNameA = NULL;
pModuleFullName = NULL;
pModulePartName = NULL;
#endif
fullnamesize = 0;
return 0;
fail:
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pModuleFullName,&modulefullnamesize);
if(pModuleFullNameW)
{
free(pModuleFullNameW);
}
pModuleFullNameW = NULL;
pModulePartName = NULL;
#else
if(pModuleFullNameA)
{
free(pModuleFullNameA);
}
pModuleFullNameA = NULL;
pModuleFullName = NULL;
pModulePartName = NULL;
#endif
fullnamesize = 0;
SetLastError(ret);
return -ret;
}
static int InsertDllNames(const char* pFullName,const char* pPartName)
{
int ret=0;
int findidx=-1;
unsigned int i;
char *pAllocFullName=NULL,*pAllocPartName=NULL;
pAllocFullName = _strdup(pFullName);
pAllocPartName = _strdup(pPartName);
if(pAllocFullName == NULL || pAllocPartName == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
EnterCriticalSection(&st_DllNameCS);
INSERT_DLL_NAME_ASSERT();
for(i=0; i<st_InsertDllPartNames.size(); i++)
{
if(strcmp(pAllocPartName,st_InsertDllPartNames[i])==0)
{
findidx = i;
break;
}
}
if(findidx < 0)
{
st_InsertDllFullNames.push_back(pAllocFullName);
st_InsertDllPartNames.push_back(pAllocPartName);
ret = 1;
}
LeaveCriticalSection(&st_DllNameCS);
if(ret == 0)
{
assert(pAllocFullName && pAllocPartName);
free(pAllocFullName);
pAllocFullName = NULL;
free(pAllocPartName);
pAllocPartName = NULL;
}
return ret;
fail:
if(pAllocFullName)
{
free(pAllocFullName);
}
pAllocFullName = NULL;
if(pAllocPartName)
{
free(pAllocPartName);
}
pAllocPartName = NULL;
SetLastError(ret);
return -ret;
}
BOOL InsertDlls(HANDLE hProcess)
{
int ret;
BOOL bret;
int i;
char* pFullName=NULL,*pPartName=NULL;
LPCSTR rlpDlls[2];
i = 0;
while(1)
{
assert(pFullName == NULL && pPartName == NULL);
ret = GetDllNames(i,&pFullName,&pPartName);
if(ret < 0)
{
assert(pFullName == NULL && pPartName == NULL);
ERROR_INFO("Get [%d] name error(%d)\n",i,ret);
ret = -ret;
goto fail;
}
else if(ret == 0)
{
break;
}
rlpDlls[0] = pFullName;
rlpDlls[1] = pPartName;
DEBUG_INFO("update (%s:%s)\n",pFullName,pPartName);
bret = UpdateImports(hProcess,rlpDlls,2);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("Import Dll(%s:%s) error(%d)\n",pFullName,pPartName,ret);
}
free(pFullName);
free(pPartName);
pFullName = NULL;
pPartName = NULL;
i ++;
}
if(pFullName)
{
free(pFullName);
}
pFullName = NULL;
if(pPartName)
{
free(pPartName);
}
pPartName = NULL;
return TRUE;
fail:
if(pFullName)
{
free(pFullName);
}
pFullName = NULL;
if(pPartName)
{
free(pPartName);
}
pPartName = NULL;
SetLastError(ret);
return FALSE;
}
int main(int argc, char* argv[])
{
int ret;
int i;
HANDLE hMapFile=NULL;
unsigned char* pMemBase=NULL;
FILE* fp=NULL;
DWORD stick,etick,ctick;
DEBUG_INFO("\n");
SDEBUG("\n");
ParseParam(argc,argv);
SDEBUG("\n");
DEBUG_INFO("\n");
hMapFile = CreateMapFile(st_pShareName,st_MemSize,st_CreateMem);
if(hMapFile== NULL)
{
ret = -(LAST_ERROR_CODE());
SDEBUG("can not %s %s memsize(%d:0x%x) error(%d)\n",
st_CreateMem ? "Create" : "Open",st_pShareName,st_MemSize,st_MemSize,ret);
ERROR_INFO("\n");
goto out;
}
DEBUG_INFO("\n");
SDEBUG("\n");
pMemBase = MapFileBuffer(hMapFile,st_MemSize);
if(pMemBase == NULL)
{
ret = -(LAST_ERROR_CODE());
SDEBUG("\n");
ERROR_INFO("\n");
goto out;
}
DEBUG_INFO("\n");
/*now to read from the file*/
if(st_pFromFile && st_WriteInit)
{
ret = fopen_s(&fp,st_pFromFile,"r");
if(fp == NULL)
{
ret = -(LAST_ERROR_CODE());
ERROR_INFO("\n");
goto out;
}
ret = fread(st_pBuffer,st_BufSize,1,fp);
if(ret != 1)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read %d from %s (%d)\n",st_BufSize,st_pFromFile,ret);
goto out;
}
ret = WriteShareMem(pMemBase,st_WriteOffset,st_pBuffer,st_BufSize);
if(ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write at offset %d (0x%x) in mem (%d:0x%x) for size(%d:0x%x) error(%d)\n",st_WriteOffset,st_WriteOffset,st_MemSize,st_MemSize,
st_BufSize,st_BufSize,ret);
goto out;
}
}
else if(st_pToFile && st_ReadInit)
{
ret = fopen_s(&fp,st_pToFile,"w");
if(fp == NULL)
{
ret = -(LAST_ERROR_CODE());
ERROR_INFO("\n");
goto out;
}
ret = ReadShareMem(pMemBase,st_ReadOffset,st_pBuffer,st_BufSize);
if(ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read at offset (%d:0x%x) in mem (%d:0x%x) for size(%d:0x%x) error(%d)\n",
st_ReadOffset,st_ReadOffset,st_MemSize,st_MemSize,
st_BufSize,st_BufSize,ret);
goto out;
}
ret = fwrite(st_pBuffer,st_BufSize,1,fp);
if(ret != 1)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write %s for size (%d:0x%x) error(%d)\n",st_pToFile,
st_BufSize,st_BufSize,ret);
goto out;
}
}
else if(st_WriteInit)
{
ret = WriteShareMem(pMemBase,st_WriteOffset,st_pBuffer,st_BufSize);
if (ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not write (%s) at offset (%d:0x%x) in mem (%d:0x%x) for size (%d:0x%x) error (%d)\n",
st_pShareName,st_WriteOffset,st_WriteOffset,st_MemSize,st_MemSize,st_BufSize,st_BufSize,ret);
goto out;
}
fprintf(stdout,"Write(%s) offset(%d:0x%x):\n",st_pShareName,st_WriteOffset,st_WriteOffset);
for(i=0;i<st_BufSize;i++)
{
if ((i%16)==0)
{
fprintf(stdout,"\n0x%08x:\t",i);
}
fprintf(stdout," 0x%02x",st_pBuffer[i]);
}
fprintf(stdout,"\nsuccess\n");
}
else if(st_ReadInit)
{
ret= ReadShareMem(pMemBase,st_ReadOffset,st_pBuffer,st_BufSize);
if (ret < 0)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"could not read (%s) at offset (%d:0x%x) in mem (%d:0x%x) for size (%d:0x%x) error (%d)\n",
st_pShareName,st_ReadOffset,st_ReadOffset,st_MemSize,st_MemSize,st_BufSize,st_BufSize,ret);
goto out;
}
fprintf(stdout,"Read(%s) offset(%d:0x%x):\n",st_pShareName,st_ReadOffset,st_ReadOffset);
for(i=0;i<st_BufSize;i++)
{
if ((i%16)==0)
{
fprintf(stdout,"\n0x%08x:\t",i);
}
fprintf(stdout," 0x%02x",st_pBuffer[i]);
}
fprintf(stdout,"\nsuccess\n");
}
stick = GetTickCount();
etick = stick + st_Timeout * 1000;
ctick = stick;
while (st_Timeout == 0 || ctick >= etick)
{
Sleep(1000);
ctick = GetTickCount();
}
ret = 0;
out:
if(fp)
{
fclose(fp);
}
fp = NULL;
if(pMemBase)
{
UnmapViewOfFile(pMemBase);
}
pMemBase = NULL;
if(hMapFile)
{
CloseHandle(hMapFile);
}
hMapFile = NULL;
if(st_pBuffer)
{
free(st_pBuffer);
}
st_pBuffer = NULL;
st_BufSize = 0;
return 0;
}
int HandleClient(int sock,int rport,char* msg)
{
int msglen = strlen(msg)+1;
int ret;
fd_set rset;
struct sockaddr_in saddr;
socklen_t socklen=0;
int times=0;
struct timeval tmval;
int buflen=2000;
unsigned char buffer[buflen];
char addrbuf[INET_ADDRSTRLEN];
while(st_RunLoop)
{
memset(&saddr,0,sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
saddr.sin_port = htons(rport);
socklen = sizeof(saddr);
ret = sendto(sock,msg,msglen,MSG_DONTWAIT,(struct sockaddr*)&saddr,socklen);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not send[%d] msg (%s) error(%d)\n",times,msg,ret);
goto out;
}
FD_ZERO(&rset);
FD_SET(sock,&rset);
tmval.tv_sec = 2;
tmval.tv_usec = 0;
errno = 0;
ret = select(sock+1,&rset,NULL,NULL,&tmval);
if(ret <=0)
{
ERROR_INFO("Get errno %d\n",errno);
ret = LAST_ERROR_CODE();
ERROR_INFO("could make rset ok (%d)\n",ret);
goto out;
}
if(!FD_ISSET(sock,&rset))
{
ret = -EFAULT;
ERROR_INFO("not set rset\n");
goto out;
}
socklen = sizeof(saddr);
memset(&saddr,0,socklen);
ret = recvfrom(sock,buffer,buflen,MSG_DONTWAIT,(struct sockaddr*)&saddr,&socklen);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not receive %d\n",ret);
goto out;
}
DEBUG_INFO("[%d]receive from %s:%d (%s)\n",times,inet_ntop(AF_INET,&(saddr.sin_addr),addrbuf, INET_ADDRSTRLEN),ntohs(saddr.sin_port),buffer);
times ++;
sleep(1);
}
ret = 0;
out:
return ret;
}
int main(int argc,char* argv[])
{
int ret;
int lport=0,rport=0;
char* msg=NULL;
int sock = -1;
if(argc == 1)
{
fprintf(stderr,"%s OPTIONS\n",argv[1]);
fprintf(stderr,"\tlport rport msg for client\n");
fprintf(stderr,"\tlport for server\n");
exit(3);
}
if(argc >= 4)
{
signal(SIGINT,SigHandler);
signal(SIGTERM,SigHandler);
signal(SIGPIPE,SIG_IGN);
while(st_RunLoop)
{
lport =atoi(argv[1]);
rport = atoi(argv[2]);
msg = argv[3];
DEBUG_INFO("\n");
sock = BindUdp(lport);
if(sock < 0)
{
ret = sock;
DEBUG_INFO("bind error %d\n",ret);
goto out;
}
ret = HandleClient(sock,rport,msg);
close(sock);
sock = -1;
sleep(1);
DEBUG_INFO("\n");
}
}
else
{
lport = atoi(argv[1]);
sock = BindUdp(lport);
if(sock < 0)
{
ret = sock;
goto out;
}
ret = daemon(0,0);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
goto out;
}
signal(SIGINT,SigHandler);
signal(SIGTERM,SigHandler);
signal(SIGPIPE,SIG_IGN);
ret = HandleServer(sock);
}
out:
if(sock >= 0)
{
close(sock);
}
sock = -1;
return ret;
}
int GetModuleInsertedProcess(const char * pPartDll,unsigned int **ppPids,int * pPidsSize)
{
char *pCmpDllName=NULL;
std::vector<unsigned int> procvecs;
#ifdef _UNICODE
int cmpdllnamesize=0;
#endif
HANDLE hProcSnap=INVALID_HANDLE_VALUE,hModSnap=INVALID_HANDLE_VALUE;
int ret;
BOOL bret;
int numget=0;
unsigned int *pRetPids = *ppPids;
unsigned int *pTmpPids=NULL;
int pidretsize=*pPidsSize;
PROCESSENTRY32 pentry;
unsigned int i;
if(pidretsize == 0 && pRetPids)
{
ret = ERROR_INVALID_PARAMETER;
goto fail;
}
hProcSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
if(hProcSnap == INVALID_HANDLE_VALUE)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not create module32 error(%d)\n",ret);
goto fail;
}
pentry.dwSize = sizeof(pentry);
bret = Process32First(hProcSnap,&pentry);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("could not get process entry error(%d)\n",ret);
goto fail;
}
DEBUG_INFO("Process ID: %d\n", pentry.th32ProcessID);
ret = __CheckProcessIdModuleInserted(pentry.th32ProcessID,pPartDll);
if(ret > 0)
{
procvecs.push_back(pentry.th32ProcessID);
numget ++;
}
while(Process32Next(hProcSnap,&pentry))
{
DEBUG_INFO("Process ID: %d\n",pentry.th32ProcessID);
ret = __CheckProcessIdModuleInserted(pentry.th32ProcessID,pPartDll);
if(ret > 0)
{
procvecs.push_back(pentry.th32ProcessID);
numget ++;
}
}
if(procvecs.size() > 0)
{
if(pidretsize <(int) procvecs.size())
{
pidretsize = procvecs.size();
pRetPids = (unsigned int*)calloc(sizeof(*pRetPids),pidretsize);
if(pRetPids == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
}
for(i=0; i<procvecs.size(); i++)
{
pRetPids[i] = procvecs[i];
}
}
if(hProcSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hProcSnap);
}
hProcSnap = INVALID_HANDLE_VALUE;
if(pRetPids != *ppPids && *ppPids)
{
free(*ppPids);
}
*ppPids = pRetPids;
*pPidsSize = pidretsize;
procvecs.clear();
return numget;
fail:
if(hProcSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hProcSnap);
}
hProcSnap = INVALID_HANDLE_VALUE;
if(pRetPids != *ppPids && pRetPids)
{
free(pRetPids);
}
pRetPids = NULL;
procvecs.clear();
SetLastError(ret);
return -ret;
}
int __CheckProcessIdModuleInserted(unsigned int procid,const char* pPartDll)
{
HANDLE hModSnap=INVALID_HANDLE_VALUE;
int ret;
BOOL bret;
char* pCmpDllName=NULL;
MODULEENTRY32 mentry;
int curnum=0;
#ifdef _UNICODE
int cmpdllnamesize=0;
#endif
try_again:
hModSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE,procid);
if(hModSnap == INVALID_HANDLE_VALUE)
{
ret = LAST_ERROR_CODE();
if(ret != ERROR_BAD_LENGTH)
{
//ERROR_INFO("[%d] snap module error(%d)\n",procid,ret);
goto fail;
}
/*we try again for next use*/
goto try_again;
}
mentry.dwSize = sizeof(mentry);
bret = Module32First(hModSnap,&mentry);
if(!bret)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d] first error(%d)\n",procid,ret);
goto fail;
}
#ifdef _UNICODE
ret = UnicodeToAnsi(mentry.szModule,&pCmpDllName,&cmpdllnamesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d]:[%d] get module name error(%d)\n",procid,curnum,ret);
goto fail;
}
#else
pCmpDllName = mentry.szModule;
#endif
//DEBUG_INFO("[%d]:[%d] modname %s partdll %s\n",procid,curnum,pCmpDllName,pPartDll);
if(_stricmp(pCmpDllName,pPartDll)==0)
{
DEBUG_INFO("[%d] find %s\n",procid,pPartDll);
goto findout;
}
curnum ++;
while(Module32Next(hModSnap,&mentry))
{
#ifdef _UNICODE
ret = UnicodeToAnsi(mentry.szModule,&pCmpDllName,&cmpdllnamesize);
if(ret < 0)
{
ret = LAST_ERROR_CODE();
ERROR_INFO("[%d]:[%d] get module name error(%d)\n",procid,curnum,ret);
goto fail;
}
#else
pCmpDllName = mentry.szModule;
#endif
//DEBUG_INFO("[%d]:[%d] modname %s partdll %s\n",procid,curnum,pCmpDllName,pPartDll);
if(_stricmp(pCmpDllName,pPartDll)==0)
{
DEBUG_INFO("[%d] find %s\n",procid,pPartDll);
goto findout;
}
curnum ++;
}
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
return 0;
findout:
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
return 1;
fail:
#ifdef _UNICODE
UnicodeToAnsi(NULL,&pCmpDllName,&cmpdllnamesize);
#endif
if(hModSnap != INVALID_HANDLE_VALUE)
{
CloseHandle(hModSnap);
}
hModSnap = INVALID_HANDLE_VALUE;
SetLastError(ret);
return -ret;
}
int main(int argc, char* argv[])
{
FILE* fp=NULL;
CViWavePlay *pPlay=NULL;
WAVEFORMATEX *pwfx=(WAVEFORMATEX*)st_FormatEx;
int ret;
BOOL bret;
char* pBuffer=NULL;
int rlen=0;
int retlen=0;
int totalread=0;
int filesize=0;
char* pCurPtr=NULL;
if(argc < 2)
{
fprintf(stderr,"wplay filetoplay\n");
ret = -3;
goto out;
}
fopen_s(&fp,argv[1],"r+b");
if(fp == NULL)
{
ret = -(LAST_ERROR_CODE());
fprintf(stderr,"can not open %s error(%d)\n",argv[1],ret);
goto out;
}
fseek(fp,0,2);
filesize = ftell(fp);
rewind(fp);
pBuffer = (char*)malloc(filesize);
if(pBuffer == NULL)
{
ret = -LAST_ERROR_CODE();
goto out;
}
retlen = fread(pBuffer,filesize,1,fp);
if(retlen != 1)
{
ret = -LAST_ERROR_CODE();
fprintf(stderr,"can not read %s filesize %d error(%d)\n",
argv[1],filesize,ret);
goto out;
}
pPlay = new CViWavePlay();
#if 0
wfx.nSamplesPerSec = 48000;
wfx.wBitsPerSample = 32;
wfx.nChannels = 2;
wfx.cbSize = 0;
wfx.wFormatTag = WAVE_FORMAT_IEEE_FLOAT;
wfx.nBlockAlign = (wfx.wBitsPerSample * wfx.nChannels) >> 3;
wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;
#endif
rlen = pwfx->nSamplesPerSec * pwfx->wBitsPerSample * pwfx->nChannels / 8 / 10;
DEBUG_INFO("pwfx->nSamplesPerSec %d\n",pwfx->nSamplesPerSec);
DEBUG_INFO("pwfx->wBitsPerSample %d\n",pwfx->wBitsPerSample);
DEBUG_INFO("pwfx->nChannels %d\n",pwfx->nChannels);
DEBUG_INFO("pwfx->cbSize %d\n",pwfx->cbSize);
DEBUG_INFO("pwfx->wFormatTag %d\n",pwfx->wFormatTag);
DEBUG_INFO("pwfx->nBlockAlign %d\n",pwfx->nBlockAlign);
DEBUG_INFO("pwfx->nAvgBytesPerSec %d\n",pwfx->nAvgBytesPerSec);
DEBUG_BUFFER_FMT(pwfx,sizeof(st_FormatEx),"wfx sizeof(%d)",sizeof(st_FormatEx));
SetLastError(0);
bret = pPlay->Start(pwfx);
if(!bret)
{
ret = -LAST_ERROR_CODE();
fprintf(stderr,"start error %d\n",ret);
goto out;
}
totalread = 0;
pCurPtr = pBuffer;
while(totalread < filesize)
{
retlen = rlen;
if((totalread + retlen)> filesize)
{
retlen = filesize - totalread;
}
//DEBUG_BUFFER_FMT(pCurPtr,(retlen > 16 ? 16 : retlen),"buffer at %d retlen %d",totalread,retlen);
bret = pPlay->PlayAudio(pCurPtr,retlen);
if(!bret)
{
ret = -LAST_ERROR_CODE();
fprintf(stderr,"play audio %d error %d\n",totalread,ret);
goto out;
}
totalread += retlen;
pCurPtr += retlen;
Sleep(100);
}
ret = 0;
out:
if(pBuffer)
{
free(pBuffer);
}
pBuffer = NULL;
if(pPlay)
{
pPlay->Stop();
delete pPlay;
}
pPlay = NULL;
if(fp)
{
fclose(fp);
}
fp = NULL;
return ret;
}
static int GetDllNames(int idx,char**ppFullName,char**ppPartName)
{
int ret = 0;
int overflow ;
int fullmallocsize=1024,fullsize;
char* pFullName=*ppFullName;
char* pPartName=*ppPartName;
if(pFullName || pPartName)
{
ret = ERROR_INVALID_PARAMETER;
SetLastError(ret);
return -ret;
}
do
{
if(pFullName)
{
free(pFullName);
}
pFullName = NULL;
if(pPartName)
{
free(pPartName);
}
pPartName = NULL;
pFullName = (char*)malloc(fullmallocsize);
pPartName = (char*)malloc(fullmallocsize);
if(pFullName == NULL || pPartName == NULL)
{
ret = LAST_ERROR_CODE();
goto fail;
}
ret = 0;
overflow = 0;
EnterCriticalSection(&st_DllNameCS);
INSERT_DLL_NAME_ASSERT();
if(st_InsertDllFullNames.size() > (unsigned int)idx)
{
fullsize = strlen(st_InsertDllFullNames[idx]);
if(fullsize < fullmallocsize)
{
ret = 1;
strncpy_s(pFullName,fullmallocsize,st_InsertDllFullNames[idx],_TRUNCATE);
strncpy_s(pPartName,fullmallocsize,st_InsertDllPartNames[idx],_TRUNCATE);
}
else
{
overflow = 1;
fullmallocsize = fullsize + 1;
}
}
LeaveCriticalSection(&st_DllNameCS);
}
while(overflow);
if(ret == 0)
{
if(pFullName)
{
free(pFullName);
}
pFullName = NULL;
if(pPartName)
{
free(pPartName);
}
pPartName = NULL;
}
else
{
*ppFullName = pFullName;
*ppPartName = pPartName;
}
return ret;
fail:
if(pFullName)
{
free(pFullName);
}
pFullName = NULL;
if(pPartName)
{
free(pPartName);
}
pPartName = NULL;
SetLastError(ret);
return -ret;
}
