Double Slit Application Installer

WhiteRook Privacy Guard

My Thoughts

Class Declaration

// CmdWnd.h
#pragma once
// CCmdWnd

#define UWM_CONSOLEOUTPUT (WM_APP + 1)
#define UWM_CHILDEXIT (WM_APP + 2)

class CCmdWnd : public CWnd
{
	DECLARE_DYNAMIC(CCmdWnd)

public:
	CCmdWnd();
	virtual ~CCmdWnd();

protected:
	afx_msg void OnPaint();
	afx_msg BOOL OnEraseBkgnd(CDC *pDC);
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnDestroy();
	afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
	afx_msg UINT OnGetDlgCode();
	afx_msg LRESULT OnConsoleOutput(WPARAM wParam, LPARAM lParam);
	afx_msg LRESULT OnChildExit(WPARAM wParam, LPARAM lParam);
	DECLARE_MESSAGE_MAP()

	BOOL ExecuteInternalFile(CString ExeName, CString &Response);
	BOOL ExecuteExternal(CString FileName);

	int GetNewLineCount(CString text);

	BOOL GetPrevCommand(CString &command){
		if((m_commandindex-1) >= 0){
			m_commandindex--; command = m_vcommands.at(m_commandindex);
			return TRUE;}
		return FALSE;};
	BOOL GetNextCommand(CString &command){
		if((m_commandindex+1) < m_vcommands.size()){
			m_commandindex++; command = m_vcommands.at(m_commandindex);
			return TRUE;}
		return FALSE;};
	void AddCommand(CString command){
		m_vcommands.push_back(command);
		m_commandindex = m_vcommands.size();
	};

	std::vector m_vcommands;
	int m_commandindex;
	CString m_curcommand;
	CString m_output;
	CFont m_font;

	static UINT ReadAndHandleOutput(LPVOID pParam);

	BOOL WriteToChild(CString text);
	HANDLE m_hChildProcess;
	HANDLE m_hPipeRead;
	HANDLE m_hPipeWrite;
};

Class Implementation

// CmdWnd.cpp : implementation file
//

#include "stdafx.h"
#include "CmdWnd.h"


// CCmdWnd

IMPLEMENT_DYNAMIC(CCmdWnd, CWnd)

CCmdWnd::CCmdWnd()
{
	NONCLIENTMETRICS ncm;
	ncm.cbSize = sizeof(NONCLIENTMETRICS);
	SystemParametersInfo(SPI_GETNONCLIENTMETRICS, sizeof(ncm), &ncm, 0);
	strcpy(ncm.lfCaptionFont.lfFaceName, "Calibri");
	m_font.CreateFontIndirect(&ncm.lfCaptionFont);

	m_commandindex = 0;
	m_hChildProcess = NULL;
}

CCmdWnd::~CCmdWnd()
{
}


BEGIN_MESSAGE_MAP(CCmdWnd, CWnd)
	ON_WM_CREATE()
	ON_WM_PAINT()
	ON_WM_ERASEBKGND()
	ON_WM_DESTROY()
	ON_WM_CHAR()
	ON_WM_KEYDOWN()
	ON_WM_GETDLGCODE()
	ON_MESSAGE(UWM_CONSOLEOUTPUT, OnConsoleOutput)
	ON_MESSAGE(UWM_CHILDEXIT, OnChildExit)
END_MESSAGE_MAP()



// CCmdWnd message handlers
UINT CCmdWnd::OnGetDlgCode()
{
	return DLGC_WANTTAB | DLGC_WANTARROWS | DLGC_WANTALLKEYS;
}

int CCmdWnd::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
	if(CWnd::OnCreate(lpCreateStruct) == -1)
		return -1;

	return 0;
}

void CCmdWnd::OnDestroy()
{
	CloseHandle(m_hChildProcess);
	m_hChildProcess = NULL;

	CWnd::OnDestroy();
}

BOOL CCmdWnd::OnEraseBkgnd(CDC *pDC)
{
	return TRUE;
}

void CCmdWnd::OnPaint()
{
	CPaintDC dc(this);

	CString output;
	CRect rWnd;
	CRect rOutput;
	GetClientRect(rWnd);
	CDC bufDC;
	CBitmap bufBmp;

	bufDC.CreateCompatibleDC(&dc);
	bufBmp.CreateCompatibleBitmap(&dc, rWnd.Width(), rWnd.Height());
	CBitmap *pOldBmp = bufDC.SelectObject(&bufBmp);

	bufDC.FillSolidRect(rWnd, RGB(0, 0, 0));

	bufDC.SetBkMode(TRANSPARENT);
	bufDC.SetTextColor(RGB(0, 0xFF, 0));
	CFont *pOldFont = bufDC.SelectObject(&m_font);

	// Draw all the output
	rOutput.left = rWnd.left;
	rOutput.right = rWnd.right;
	rOutput.top = 0;
	rOutput.bottom = 0;

	output = m_output;
	int lHeight = bufDC.GetTextExtent(output).cy;
	rOutput.bottom = lHeight;
	CString tmp;
	for(int i = 0; i < output.GetLength(); i++)
	{
		tmp += output.GetAt(i);
		CRect rTmp(0,0,0,0);
		bufDC.DrawText(tmp, rTmp, DT_SINGLELINE | DT_CALCRECT);
		if(rTmp.right > rWnd.right || tmp.Right(1) == "\n")
		{
			CString hold; hold = "";
			if(tmp.Right(1) == "\n")
			{
				tmp.Replace("\n", "");
				tmp.Replace("\r", "");
			}
			else
			{
				hold = tmp.Right(1);
				tmp = tmp.Left(tmp.GetLength()-1);
			}

			tmp.Replace("\n", "");
			tmp.Replace("\r", "");

			bufDC.DrawText(tmp, rOutput, DT_SINGLELINE);
			rOutput.top += lHeight; rOutput.bottom += lHeight;
			tmp = hold;
		}
	}
	tmp.Replace("\n", "");
	tmp.Replace("\r", "");
	bufDC.DrawText(tmp, rOutput, DT_SINGLELINE);
	rOutput.top += lHeight; rOutput.bottom += lHeight;

	if(m_hChildProcess == NULL)
	{
		// Draw the current command line
		rOutput.left = rWnd.left;
		rOutput.right = rWnd.right;

		CHAR szPath[MAX_PATH]; //MAX_PATH is defined as 260
		INT iLen = 0; 
		iLen = GetCurrentDirectory(MAX_PATH, szPath);
		strcat(szPath, ">");

		output = szPath;
		output += m_curcommand;
		if(rOutput.bottom == rOutput.top)
		{
			bufDC.DrawText(output, rOutput, DT_SINGLELINE | DT_CALCRECT);
			if(lHeight == 0)
				lHeight = rOutput.bottom;
		}
		tmp = "";
		for(int i = 0; i < output.GetLength(); i++)
		{
			tmp += output.GetAt(i);
			CRect rTmp(0,0,0,0);
			bufDC.DrawText(tmp, rTmp, DT_SINGLELINE | DT_CALCRECT);
			if(rTmp.right > rWnd.right)
			{
				CString hold;
				hold = tmp.Right(1);
				tmp = tmp.Left(tmp.GetLength()-1);
				bufDC.DrawText(tmp, rOutput, DT_SINGLELINE);
				rOutput.top += lHeight; rOutput.bottom += lHeight;
				tmp = hold;
			}
		}
		bufDC.DrawText(tmp, rOutput, DT_SINGLELINE);
	}

	dc.BitBlt(0, 0, rWnd.Width(), rWnd.Height(), &bufDC, 0, 0, SRCCOPY);

	bufDC.SelectObject(pOldFont);
	bufDC.SelectObject(pOldBmp);
}

void CCmdWnd::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if(m_hChildProcess != NULL)
	{
		CString tmp;
		tmp.Format("%c", nChar);
		WriteToChild(tmp);
	}
	else if(nChar >= 32)
	{
		CString tmp;
		tmp.Format("%c", nChar);
		m_curcommand += tmp;
		Invalidate();
	}
	else if(nChar == VK_BACK)
	{
		m_curcommand = m_curcommand.Left(m_curcommand.GetLength()-1);
		Invalidate();
	}
	else
		CWnd::OnChar(nChar, nRepCnt, nFlags);
}

void CCmdWnd::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
	if(m_hChildProcess == NULL)
	{
		if(nChar == VK_RETURN)
		{
			CString output;
			CHAR szPath[MAX_PATH]; //MAX_PATH is defined as 260
			INT iLen = 0;
			iLen = GetCurrentDirectory(MAX_PATH, szPath);
			strcat(szPath, ">");

			output = szPath;
			output += m_curcommand;
			if(m_output != "")
				m_output += "\r\n";
			m_output += output + "\r\n";
			
			CString tmpout;
			if(m_curcommand == "")
			{
			}
			else if(ExecuteInternalFile(m_curcommand, tmpout))
			{
				AddCommand(m_curcommand);
				if(tmpout != "")
					m_output += tmpout;
			}
			else if(ExecuteExternal(m_curcommand))
			{
				AddCommand(m_curcommand);
				if(tmpout != "")
					m_output += tmpout;
			}
			else
			{
				AddCommand(m_curcommand);
				m_output += m_curcommand + "' is not recognized as an internal or external command.";
			}

			m_curcommand = "";

			Invalidate();
		}
		else if(nChar == VK_UP)
		{
			GetPrevCommand(m_curcommand);
			Invalidate();
		}
		else if(nChar == VK_DOWN)
		{
			GetNextCommand(m_curcommand);
			Invalidate();
		}
	}
	else // The child process is running
	{
		if(nChar == VK_RETURN)
		{
			WriteToChild("\r\n");
		}
	}
}

BOOL CCmdWnd::ExecuteInternalFile(CString ExeName, CString &Response)
{
	if(ExeName == "cls")
	{
		m_output = "";
		return TRUE;
	}
	else if(ExeName == "exit")
	{
		GetParent()->PostMessage(WM_CLOSE);
		return TRUE;
	}

	return FALSE;
}

int CCmdWnd::GetNewLineCount(CString text)
{
	int icount = 0;
	for(int i = 0; i < text.GetLength(); i++)
	{
		if(text.GetAt(i) == '\n')
			icount++;
	}
	return icount;
}

BOOL CCmdWnd::ExecuteExternal(CString FileName)
{
	HANDLE hOutputReadTmp, hOutputWrite;
	HANDLE hInputWriteTmp, hInputRead;
	HANDLE hErrorWrite;
	HANDLE hThread;
	DWORD ThreadId;
	SECURITY_ATTRIBUTES sa;

	if(FileName.GetLength() > 1023)
		return FALSE;

	char command[1024];
	strcpy(command, FileName.GetBuffer(FileName.GetLength()));

	m_hChildProcess = NULL;

	// Set up the security attributes struct.
	sa.nLength= sizeof(SECURITY_ATTRIBUTES);
	sa.lpSecurityDescriptor = NULL;
	sa.bInheritHandle = TRUE;

	// Create the child output pipe.
	if(!CreatePipe(&hOutputReadTmp, &hOutputWrite, &sa, 0))
	{
		TRACE0("CreatePipe Failed!\r\n");
	}

	// Create a duplicate of the output write handle for the std error
	// write handle. This is necessary in case the child application
	// closes one of its std output handles.
	if (!DuplicateHandle(GetCurrentProcess(),hOutputWrite,
					   GetCurrentProcess(),&hErrorWrite,0,
					   TRUE,DUPLICATE_SAME_ACCESS))
	{
		TRACE0("DuplicateHandle Failed!\r\n");
	}


	// Create the child input pipe.
	if (!CreatePipe(&hInputRead,&hInputWriteTmp,&sa,0))
	{
	}

	if (!DuplicateHandle(GetCurrentProcess(),hOutputReadTmp,
					   GetCurrentProcess(),
					   &m_hPipeRead, // Address of new handle.
					   0,FALSE, // Make it uninheritable.
					   DUPLICATE_SAME_ACCESS))
	{
	}

	if (!DuplicateHandle(GetCurrentProcess(),hInputWriteTmp,
					   GetCurrentProcess(),
					   &m_hPipeWrite, // Address of new handle.
					   0,FALSE, // Make it uninheritable.
					   DUPLICATE_SAME_ACCESS))
	{
	}

	if(!CloseHandle(hOutputReadTmp))
	{
	}
	if(!CloseHandle(hInputWriteTmp))
	{
	}

	PROCESS_INFORMATION pi;
	STARTUPINFO si;

	// Set up the start up info struct.
	ZeroMemory(&si,sizeof(STARTUPINFO));
	si.cb = sizeof(STARTUPINFO);
	si.dwFlags = STARTF_USESTDHANDLES;
	si.hStdOutput = hOutputWrite;
	si.hStdInput  = hInputRead;
	si.hStdError  = hErrorWrite;

	if(!CreateProcess(NULL, command, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
	{
		CString path;
		char szSysPath[MAX_PATH];
		GetEnvironmentVariable(_T("WinDir"), szSysPath, MAX_PATH);
		path = szSysPath;
		path += "\\system32\\";
		path += command;
		strcpy(command, path);
		if(!CreateProcess(NULL, command, NULL, NULL, TRUE, NORMAL_PRIORITY_CLASS | CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
		{
			return FALSE;
		}
	}

	// Set global child process handle to cause threads to exit.
	m_hChildProcess = pi.hProcess;

	// Close any unnecessary handles.
	if(!CloseHandle(pi.hThread))
	{
	}
	if(!CloseHandle(hOutputWrite))
	{
	}
	if(!CloseHandle(hInputRead))
	{
	}
	if(!CloseHandle(hErrorWrite))
	{
	}


	// Read the child's output.
	AfxBeginThread(ReadAndHandleOutput, this);
	// Redirection is complete

	return TRUE;
}

UINT CCmdWnd::ReadAndHandleOutput(LPVOID pParam)
{
	CCmdWnd *pWnd = (CCmdWnd*)pParam;
	HANDLE hPipeRead = pWnd->m_hPipeRead;
	CHAR *lpBuffer;
	DWORD nBytesRead;
	DWORD nCharsWritten;

	while(TRUE)
	{
		lpBuffer = new CHAR[1024];
		if(!ReadFile(hPipeRead, lpBuffer, 1020, &nBytesRead, NULL) || !nBytesRead)
		{
			if(GetLastError() == ERROR_BROKEN_PIPE)
			{
				delete [] lpBuffer;
				break; // pipe done - normal exit path.
			}
			else
			{
				delete [] lpBuffer;
				break;
				// Something bad happened.
			}
		}

		lpBuffer[nBytesRead] = '\0';
		pWnd->PostMessage(UWM_CONSOLEOUTPUT, 0, (LPARAM)lpBuffer);
	}

	pWnd->SendMessage(UWM_CHILDEXIT);
	return 0;
}

LRESULT CCmdWnd::OnConsoleOutput(WPARAM wParam, LPARAM lParam)
{
	m_output += (CHAR*)lParam;

	delete [] (CHAR*)lParam;

	Invalidate();

	return 0;
}

BOOL CCmdWnd::WriteToChild(CString text)
{
	m_output += text;
	char *lpszBuf = new char[text.GetLength()+1];
	strcpy(lpszBuf, text);
	DWORD nBytesWrite = strlen(lpszBuf);
	DWORD nBytesWrote;
	if(!WriteFile(m_hPipeWrite, lpszBuf, nBytesWrite, &nBytesWrote, NULL))
	{
		delete [] lpszBuf;
		if(GetLastError() == ERROR_NO_DATA)
			return FALSE; // Pipe was closed (normal exit path).
		else
			return FALSE;
	}

	delete [] lpszBuf;
	Invalidate();
	return TRUE;
}

LRESULT CCmdWnd::OnChildExit(WPARAM wParam, LPARAM lParam)
{
	CloseHandle(m_hPipeRead);
	CloseHandle(m_hPipeWrite);
	CloseHandle(m_hChildProcess);
	m_hChildProcess = NULL;

	Invalidate();
	return 0;
}

int main()
{
	EnumDirFiles("C:\\Program Files"); // List all files within the Program Files directory.

	return 0;
}

Recursive Function Definition

void EnumDirFiles(char *lpszDir)
{
	HANDLE hDir;
	BOOL bDone = FALSE;
	WIN32_FIND_DATA FileData;
	char szFind[512];

	strcpy(szFind, lpszDir);
	strcat(szFind, "\\*");
	hDir = FindFirstFile(szFind, &FileData); 
	if(hDir == INVALID_HANDLE_VALUE) 
	{ 
		printf("Invalid Directory: \"%s\"\n", lpszDir); 
		return;
	}

	while(!bDone) 
	{
		if(FileData.cFileName[0] != '.') // Exclude "." and ".."
		{
			char szFullFile[512];
			strcpy(szFullFile, lpszDir);
			strcat(szFullFile, "\\");
			strcat(szFullFile, FileData.cFileName);

			if(FileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
			{
				printf("- Listing Directory: %s\n", szFullFile);
				EnumDirFiles(szFullFile);
			}
			else
				printf("%s\n", szFullFile);
		}

		if(!FindNextFile(hDir, &FileData)) 
		{
			if(GetLastError() == ERROR_NO_MORE_FILES) 
			{
				bDone = TRUE; 
			} 
			else 
			{
				printf("Unable to enumerate the next file.\n"); 
				bDone = TRUE;
			} 
		}
	} 

	// Close the search handle. 
	FindClose(hDir);
}

/**************************************************************

	Name:	ESMTP Class
	Ver:	1.0.1.1
	Author:	Brandon W. Yuille

	Desc:	This class assumes MFC is used and all socket
			initializations have taken place in
			CWinApp::InitInstance(). Please don't consider this code
			as production code for any sort of SMTP client. This is
			simply provided so you can acomplish some simple tasks.
			If you make modifications to this code that are useful,
			please share them with others!

			This class is free to use by anyone.

	Copyright (C) 2006 Photon Technologies
**************************************************************/
#pragma once

#include <vector>

class CESMTP
{
public:
	CESMTP(void);
	~CESMTP(void);

	void AddRecipient(CString address, CString name = "");
	void SetFrom(CString address, CString name = "");
	void SetSubject(CString subject);
	void SetESMTPServerAddress(CString address);
	void SetESMTPServerPort(int port = 25);
	void SetMsgBody(CString data);

	BOOL SendMsg();

protected:
	BOOL RecvMessage(SOCKET *psock, CString requiredcode);

	struct NAMEADDR
	{
		CString name;
		CString addr;
	};

	std::vector<NAMEADDR> m_vto;
	NAMEADDR m_from;
	CString m_serveraddr;
	int m_serverport;
	CString m_data;
	CString m_subject;
};

Class Implementation

#include "StdAfx.h"
#include ".\esmtp.h"

CESMTP::CESMTP(void)
{
	m_serverport = 25;
}

CESMTP::~CESMTP(void)
{
}

void CESMTP::AddRecipient(CString address, CString name)
{
	NAMEADDR na;
	na.addr = address;
	na.name = name;

	m_vto.push_back(na);
}

void CESMTP::SetFrom(CString address, CString name)
{
	m_from.addr = address;
	m_from.name = name;
}

void CESMTP::SetSubject(CString subject)
{
	m_subject = subject;
}

void CESMTP::SetESMTPServerAddress(CString address)
{
	m_serveraddr = address;
}

void CESMTP::SetESMTPServerPort(int port)
{
	m_serverport = port;
}

void CESMTP::SetMsgBody(CString data)
{
	data.Replace("\r\n.\r\n", "\r\n..\r\n");
	if(data.Left(3) == ".\r\n")
		data.Insert(0, ".");

	m_data = data;
}

BOOL CESMTP::SendMsg()
{
	SOCKET sock;
	SOCKADDR_IN saremote;
	CString SendBuf;

	// Create the TCP/IP CCCP socket.
	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == INVALID_SOCKET)
	{
		return FALSE;
	}

	saremote.sin_family = AF_INET;
	saremote.sin_port = htons((short)m_serverport);
	if(inet_addr(m_serveraddr.GetString()) == INADDR_NONE)
	{
		HOSTENT *hp;
		hp = gethostbyname(m_serveraddr.GetString());
		saremote.sin_addr.s_addr = *((unsigned long*)hp->h_addr);
	}
	else
	{
		saremote.sin_addr.s_addr = inet_addr(m_serveraddr.GetString());
	}

	// Connect to CCCP server.
	if(connect(sock, (SOCKADDR*)&saremote, sizeof(saremote)) == SOCKET_ERROR)
	{
		return FALSE;
	}

	// Recieve Banner
	if(!RecvMessage(&sock, "220"))
	{
		closesocket(sock);
		return FALSE;
	}

	// Send EHLO
	SendBuf = "EHLO\r\n";
	if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
	{
		closesocket(sock);
		return FALSE;
	}
	// Recieve OK
	if(!RecvMessage(&sock, "250"))
	{
		closesocket(sock);
		return FALSE;
	}

	// Send MAIL FROM:<address@domain.com>
	SendBuf = "MAIL FROM:" + m_from.addr + "\r\n";
	if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
	{
		closesocket(sock);
		return FALSE;
	}
	// Recieve OK
	if(!RecvMessage(&sock, "250"))
	{
		closesocket(sock);
		return FALSE;
	}

	for(int i = 0; i < m_vto.size(); i++)
	{
		// Send RCPT TO:<address@domain.com>
		SendBuf = "RCPT TO:" + m_vto.at(i).addr + "\r\n";
		if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
		{
			closesocket(sock);
			return FALSE;
		}
		// Recieve OK
		if(!RecvMessage(&sock, "250"))
		{
			closesocket(sock);
			return FALSE;
		}
	}

	// Send DATA
	SendBuf = "DATA\r\n";
	if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
	{
		closesocket(sock);
		return FALSE;
	}
	// Recieve Begin DATA
	if(!RecvMessage(&sock, "354"))
	{
		closesocket(sock);
		return FALSE;
	}

	CString MsgBody;
	MsgBody += "Subject:  " + m_subject + "\r\n";
	MsgBody += "To: ";
	for(int i = 0; i < m_vto.size(); i++)
	{
		MsgBody += " " + m_vto.at(i).name + " <" + m_vto.at(i).addr + ">;";
	}
	MsgBody += "\r\n\r\n";
	// Add the message data
	MsgBody += m_data;
	// End the message
	MsgBody += "\r\n.\r\n";

	SendBuf = MsgBody;
	if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
	{
		closesocket(sock);
		return FALSE;
	}
	// Recieve OK
	if(!RecvMessage(&sock, "250"))
	{
		closesocket(sock);
		return FALSE;
	}

	SendBuf = "QUIT\r\n";
	if(send(sock, SendBuf, SendBuf.GetLength(), 0) == SOCKET_ERROR)
	{
		closesocket(sock);
		return FALSE;
	}
	// Recieve Connection Closed
	if(!RecvMessage(&sock, "221"))
	{
		closesocket(sock);
		return FALSE;
	}

	closesocket(sock);
	return TRUE;
}

BOOL CESMTP::RecvMessage(SOCKET *psock, CString requiredcode)
{
	char szBuf[1025];
	CString Buffer;
	CString MsgCode;
	int BufLen = 0;
	int icount = 0;

	while((BufLen = recv(*psock, szBuf, 1024, 0)) > 0)
	{
		szBuf[BufLen] = '\0';
		Buffer += szBuf;

		if(icount == 0)
			MsgCode = Buffer.Left(3);

		if(Buffer.Find(MsgCode + " ") != -1)
			break;

		icount++;
	}

	if(MsgCode == requiredcode)
		return TRUE;

	return FALSE;
}