Об открытом коде, линуксе, windows и программировании

/* PROCESS.C
// Process manager for Windows 9x
*/
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>

#define BY_PATH   0
#define BY_NAME   1
#define BY_PID   2

int showhelp(void);
HANDLE openlist(void);
int showlist(void);
int killproc(PROCESSENTRY32 *pe);
int kill(char *name,int by);

int showhelp(void) {
printf("USAGE:\nshow list: process -l\nkill process: process -k {-f <pathname> | -n <name> | -p <pid> }\n");
return(-1);
}//=============================================

HANDLE openlist(void) {
PROCESSENTRY32 pe;
HANDLE h;

h=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
if((h==NULL)||(h==INVALID_HANDLE_VALUE)) {
   printf("Cannot load snapshot\n");
   ExitProcess(-3);
}
while(!Process32First(h,&pe)) {
   CloseHandle(h);
   h=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
}
return(h);
}//=============================================

int showlist(void) {
HANDLE h;
PROCESSENTRY32 pe;

h=openlist();
Process32First(h,&pe);
printf("%u: %s\n",pe.th32ProcessID,pe.szExeFile);
while(Process32Next(h,&pe)) printf("%u: %s\n",pe.th32ProcessID,pe.szExeFile);
CloseHandle(h);
return(0);
}//=============================================

int killproc(PROCESSENTRY32 *pe) {
HMODULE hm;

hm=OpenProcess(PROCESS_TERMINATE,FALSE,pe->th32ProcessID);
if(hm==NULL) {
   printf("Cannot open process");
   return(0);
}
if(TerminateProcess(hm,0)) {
   CloseHandle(hm);
   return(1);
}
else printf("Cannot kill process\n");
CloseHandle(hm);
return(0);
}//=============================================

int kill(char* name,int by) {
HANDLE h;
PROCESSENTRY32 pe;
int i,found;
long pid;

h=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
Process32First(h,&pe);
switch(by) {
case BY_PATH: found=strcmpi(name,pe.szExeFile); break;
case BY_NAME:
   for(i=strlen(pe.szExeFile);pe.szExeFile[i]!='\\';i--);
   found=strcmpi(name,&(pe.szExeFile[i+1]));
   break;
case BY_PID:
   pid=atol(name);
   if(pid==(long)pe.th32ProcessID) found=0;
   else found=1;
}
i=0;
if(found==0) {
   i=killproc(&pe);
   if(by!=BY_NAME) {
      CloseHandle(h);
      return(i);
   }
}
while(Process32Next(h,&pe)) {
   switch(by) {
   case BY_PATH: found=strcmpi(name,pe.szExeFile); break;
   case BY_NAME:
      for(i=strlen(pe.szExeFile);pe.szExeFile[i]!='\\';i--);
      found=strcmpi(name,&(pe.szExeFile[i+1]));
      break;
   case BY_PID:
      if(pid==(long)pe.th32ProcessID) found=0;
      else found=1;
   }
   if(found==0) {
      i+=killproc(&pe);
      if(by!=BY_NAME) {
         CloseHandle(h);
         return(i);
      }
   }
}
CloseHandle(h);
if(by==BY_NAME) return(i);
printf("Cannot find process\n");
return(-2);
}//=============================================

int main(int argc,char *argv[]) {
if(argc<2) return(showhelp());
if((argv[1][0]=='-')||(argv[1][0]=='/')) {
   SetPriorityClass(GetCurrentProcess(),REALTIME_PRIORITY_CLASS);
   switch(argv[1][1]) {
   case 'l': return(showlist());
   case 'k':
      if(argc<4) return(showhelp());
      if((argv[2][0]!='-')&&(argv[2][0]!='/')) return(showhelp());
      switch(argv[2][1]) {
      case 'f': return(kill(argv[3],BY_PATH));
      case 'n': return(kill(argv[3],BY_NAME));
      case 'p': return(kill(argv[3],BY_PID));
      default: return(showhelp());
      }
   default: return(showhelp());
   }
}
return(showhelp());
}//=============================================

/* TLNTSRV.C
// Telnet server for Windows 9x
*/
#include <windows.h>
#include <winsock2.h>
#pragma comment(lib, "ws2_32.lib")

#define CSRV_SERVER_PORT   23
#define CSRV_MAX_BUFSIZE   65535
#define CSRV_PBUF_SIZE      256
#define WM_SERVER_ACCEPT   WM_USER+101
#define WM_CLIENT_SEND      WM_USER+102
#define WM_PROCESS_STOP      WM_USER+103

typedef struct {
SOCKET cs; // сокет, через который идет общение с удаленным клиентом
unsigned char *sbuf; // буфер для данных, поступающих через сокет
DWORD sbuflen; // размер сокетного буфера
DWORD sdatalen; // размер данных в сокетном буфере
unsigned char *pbuf; // буфер для данных, поступающих через пайп
DWORD pbuflen; // размер пайпового буфера
DWORD pdatalen; // размер данных в пайповом буфере
HANDLE process; // консольный процесс
HANDLE srvout; // другой конец входного потока процесса
HANDLE srvin; // другой конец выходнго потока процесса
HANDLE thread; // поток, ждущий данных от процесса
HANDLE start; // стартовый поток процесса
HWND wnd; // окно, принимающее сообщение от сокета
} csrvSession;

LRESULT CALLBACK ChldProc(HWND wnd,unsigned int mes,WPARAM wp,LPARAM lp);
LRESULT CALLBACK WndProc(HWND wnd,unsigned int mes,WPARAM wp,LPARAM lp);
DWORD WINAPI onServerAccept(void *param);
DWORD WINAPI CommandOutput(void *param);
int StartSession(csrvSession *css);

LPSTR CSRV_CLASS="TLNTSRV_LISTENER_CLASS";
LPSTR CHILD_CLASS="TLNTSRV_SESSION_CLASS";
SOCKET ss;
unsigned short port;
HINSTANCE hi;
HANDLE heap;
HWND mwnd;

LRESULT CALLBACK WndProc(HWND wnd,unsigned int mes,WPARAM wp,LPARAM lp) {
switch(mes) {
case WM_CLOSE:
case WM_QUERYENDSESSION:
   WSAAsyncSelect(ss,wnd,0,0);
   DestroyWindow(wnd);
   return(TRUE);
case WM_DESTROY:
   closesocket(ss);
   PostQuitMessage(0);
case WM_QUIT: return(0);
case WM_CREATE: {
   WSADATA wsaData;
   SOCKADDR_IN sa;
   if(WSAStartup(MAKEWORD(2,0),&wsaData)!=0) return(-1);
   ss=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
   sa.sin_family=AF_INET;
   sa.sin_addr.s_addr=INADDR_ANY;
   sa.sin_port=htons(port);
   if(bind(ss,(SOCKADDR *)&sa,sizeof(SOCKADDR_IN))!=0) return(-1);
   if(WSAAsyncSelect(ss,wnd,WM_SERVER_ACCEPT,FD_ACCEPT)!=0) return(-1);
   if(listen(ss,2)!=0) return(-1);
   }
   return(0);
case WM_SERVER_ACCEPT: {
   DWORD tid;
   CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)onServerAccept,NULL,0,&tid);
   }
   return(0);
}
return(DefWindowProc(wnd,mes,wp,lp));
}//=============================================

LRESULT CALLBACK ChldProc(HWND wnd,unsigned int mes,WPARAM wp,LPARAM lp) {
switch(mes) {
case WM_DESTROY: {
   csrvSession *css;
   css=(csrvSession *)GetWindowLong(wnd,GWL_USERDATA);
   if(css!=NULL) {
      WSAAsyncSelect(css->cs,wnd,0,0);
      closesocket(css->cs);
      TerminateThread(css->thread,0);
      TerminateProcess(css->process,0);
      CloseHandle(css->srvin);
      CloseHandle(css->srvout);
      if(css->sbuf!=NULL) HeapFree(heap,0,css->sbuf);
      if(css->pbuf!=NULL) HeapFree(heap,0,css->pbuf);
      HeapFree(heap,0,css);
   }}
   PostQuitMessage(0);
case WM_QUIT:
   return(0);
case WM_CLIENT_SEND: {
   csrvSession *css;
   css=(csrvSession *)GetWindowLong(wnd,GWL_USERDATA);
   if(css==NULL) return(0);
   switch(LOWORD(lp)) {
   case FD_READ: {
      DWORD len;
      GetExitCodeProcess(css->process,&len);
      if(len!=STILL_ACTIVE) break;
      if(ioctlsocket(css->cs,FIONREAD,&len)==SOCKET_ERROR) break;
      if(len==0) return(0);
      len+=css->sdatalen;
      if(len>CSRV_MAX_BUFSIZE) break;
      if(len>css->sbuflen) {
         if(css->sbuf==NULL) css->sbuf=HeapAlloc(heap,0,len);
         else css->sbuf=HeapReAlloc(heap,0,css->sbuf,len);
         if(css->sbuf==NULL) break;
         css->sbuflen=HeapSize(heap,0,css->sbuf);
      }
      if(recv(css->cs,&css->sbuf[css->sdatalen],len-css->sdatalen,0)==SOCKET_ERROR) break;
      css->sdatalen=len;
      if(len<2) return(0);
      if((css->sbuf[len-2]!='\r')||(css->sbuf[len-1]!='\n')) return(0);
      if(!WriteFile(css->srvout,css->sbuf,len,&(css->sdatalen),NULL)) break;
      css->sdatalen=0;
      }
      return(0);
   }}
case WM_PROCESS_STOP:
   DestroyWindow(wnd);
   return(0);
}
return(DefWindowProc(wnd,mes,wp,lp));
}//=============================================

DWORD WINAPI onServerAccept(void *param) {
SOCKADDR_IN sa;
MSG msg;
csrvSession *css;

css=(csrvSession *)HeapAlloc(heap,HEAP_ZERO_MEMORY,sizeof(csrvSession));
if(css==NULL) return(0);
css->cs=accept(ss,(SOCKADDR *)&sa,NULL);
if(css->cs==INVALID_SOCKET) {
   HeapFree(heap,0,css);
   return(0);
}
css->wnd=CreateWindowEx(WS_EX_TOOLWINDOW,CHILD_CLASS,NULL,WS_POPUP,0,0,0,0,mwnd,NULL,hi,NULL);
if(!IsWindow(css->wnd)) {
   closesocket(css->cs);
   HeapFree(heap,0,css);
   return(0);
}
SetWindowLong(css->wnd,GWL_USERDATA,(long)css);
if(WSAAsyncSelect(css->cs,css->wnd,WM_CLIENT_SEND,FD_READ|FD_CLOSE)!=0) {
   closesocket(css->cs);
   HeapFree(heap,0,css);
   return(0);
}
if(!StartSession(css)) {
   closesocket(css->cs);
   if(css->pbuf!=NULL) HeapFree(heap,0,css->pbuf);
   HeapFree(heap,0,css);
   return(0);
}
ResumeThread(css->start);
ResumeThread(css->thread);
css->sdatalen=0;
while(GetMessage(&msg,NULL,0,0xFFFF)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
}
return(0);
}//=============================================

DWORD WINAPI CommandOutput(void *param) {
csrvSession *css;

css=(csrvSession *)param;
while(ReadFile(css->srvin,css->pbuf,css->pbuflen,&(css->pdatalen),NULL)) 
   if(css->pdatalen>0) send(css->cs,css->pbuf,css->pdatalen,0);
PostMessage(css->wnd,WM_PROCESS_STOP,0,0);
return(0);
}//=============================================

int StartSession(csrvSession *css) {
PROCESS_INFORMATION pi;
STARTUPINFO si;
SECURITY_ATTRIBUTES sa;
DWORD i;
HANDLE htmp,farin,farout,farerr;

css->pbuf=HeapAlloc(heap,0,CSRV_PBUF_SIZE);
if(css->pbuf==NULL) return(0);
css->pbuflen=HeapSize(heap,0,css->pbuf);
sa.nLength=sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor=NULL;
sa.bInheritHandle=TRUE;
if(!CreatePipe(&htmp,&farout,&sa,0)) return(0);
if(!DuplicateHandle(GetCurrentProcess(),farout,GetCurrentProcess(),&farerr,0,TRUE,DUPLICATE_SAME_ACCESS)) return(0);
if(!DuplicateHandle(GetCurrentProcess(),htmp,GetCurrentProcess(),&(css->srvin),0,FALSE,DUPLICATE_SAME_ACCESS)) return(0);
CloseHandle(htmp);
if(!CreatePipe(&farin,&htmp,&sa,0)) return(0);
if(!DuplicateHandle(GetCurrentProcess(),htmp,GetCurrentProcess(),&(css->srvout),0,FALSE,DUPLICATE_SAME_ACCESS)) return(0);
CloseHandle(htmp);
css->thread=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)CommandOutput,css,CREATE_SUSPENDED,&i);
if(css->thread==NULL) return(0);
memset(&si,0,sizeof(STARTUPINFO));
si.cb=sizeof(STARTUPINFO);
si.dwFlags=STARTF_USESTDHANDLES|STARTF_USESHOWWINDOW;
si.wShowWindow=SW_HIDE;
si.hStdInput=farin;
si.hStdOutput=farout;
si.hStdError=farerr;
if(!CreateProcess(NULL,"command.com",NULL,NULL,TRUE,CREATE_SUSPENDED|CREATE_NEW_CONSOLE,NULL,"C:\\",&si,&pi)) return(0);
CloseHandle(farin);
CloseHandle(farout);
CloseHandle(farerr);
css->process=pi.hProcess;
css->start=pi.hThread;
return(-1);
}//=============================================

int APIENTRY WinMain(HINSTANCE hinst,HINSTANCE prhi,LPSTR cmd,int ncmd) {
MSG msg;
WNDCLASS wc;

mwnd=FindWindow(CSRV_CLASS,NULL);
if(IsWindow(mwnd)) {
   if(stricmp(cmd,"STOP")==0) PostMessage(mwnd,WM_CLOSE,0,0);
   return(0);
}
if(cmd!=NULL) port=(unsigned short)atoi(cmd);
if((port==0)||(port>16383)) port=CSRV_SERVER_PORT;
hi=hinst;
heap=GetProcessHeap();
memset(&wc,0,sizeof(WNDCLASS));
wc.lpfnWndProc=WndProc;
wc.hInstance=hi;
wc.lpszClassName=CSRV_CLASS;
RegisterClass(&wc);
wc.lpfnWndProc=ChldProc;
wc.lpszClassName=CHILD_CLASS;
RegisterClass(&wc);
mwnd=CreateWindowEx(WS_EX_TOOLWINDOW,CSRV_CLASS,NULL,WS_POPUP,0,0,0,0,NULL,NULL,hi,NULL);
if(!IsWindow(mwnd)) return(0);
while(GetMessage(&msg,NULL,0,0)) {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
}
WSACleanup();
return(0);
}//=============================================