///////////////////////////////////////////////////////////
// Betriebssysteme I - Windows 2000
// Assignment 3.3: An extended command shell
//
// author:			Stephan Brumme
// last changes:	November 27, 2001

#include <windows.h>
#include <stdio.h>


////////////////////////////////////////////////////////////////////
// read a single command
BOOL ReadLine(const HANDLE hFile, char* buffer)
{
	// FALSE, if error
	BOOL bRead;
	// determines end of line
	BOOL bCRLF = FALSE;
	// number of read bytes per read access (only 0 or 1 !)
	unsigned long nRead  = 0;
	// total amount of read bytes
	unsigned long nIndex = 0;

	// read in command byte by byte
	do
	{
		// read a single byte
		bRead = ReadFile(hFile, &buffer[nIndex], 1, &nRead, NULL);
		// strip EOL
		if (buffer[nIndex] == 0x0D)
			nIndex--;
		if (buffer[nIndex] == 0x0A)
			bCRLF = TRUE;

		// next byte
		nIndex++;
	}
	while (nRead == 1 && bCRLF == FALSE);

	// terminate string, we moved one too far
	buffer[nIndex-1] = 0;

	// return last status
	return bRead;
}


////////////////////////////////////////////////////////////////////
// parse a string and looks for a given command
// return a pointer to the parameter list 
// or NULL if command not found
char* SearchCommand(const char* command, const char* text)
{
	// look for command
	char* pReturn = strstr(text, command);
	// must be at the beginning of the line
	if (pReturn != text)
		return NULL;

	// jump to parameter list
	pReturn += strlen(command);

	// remove whitespaces
	while (*pReturn == ' ')
		pReturn++;

	return pReturn;
}


////////////////////////////////////////////////////////////////////
const MAX_HANDLES = 255;
HANDLE arHandles[MAX_HANDLES];

////////////////////////////////////////////////////////////////////
// add handle to internal list
// no checking !
void AddHandle(HANDLE handle)
{
	for (int i=0; i<MAX_HANDLES; i++)
		if (arHandles[i] == 0)
		{
			arHandles[i] = handle;
			break;
		}
}


////////////////////////////////////////////////////////////////////
// remove handle from internal list
// no checking !
void RemoveHandle(HANDLE handle)
{
	for (int i=0; i<MAX_HANDLES; i++)
		if (arHandles[i] == handle)
		{
			arHandles[i] = 0;
			break;
		}
}


////////////////////////////////////////////////////////////////////
// change directory
// return TRUE if successful
BOOL ChangeDirectory(const char* dir)
{
	return SetCurrentDirectory(dir);
}


////////////////////////////////////////////////////////////////////
// wait for a single process
// return TRUE if successful
BOOL Wait(HANDLE hProcess)
{
	printf("... waiting for %d ...\n", hProcess);

	// wait for Godot
	DWORD dwResult = WaitForSingleObject(hProcess, INFINITE);
	CloseHandle(hProcess);

	// remove handle from list
	RemoveHandle(hProcess);

	return (dwResult != WAIT_FAILED);
}


////////////////////////////////////////////////////////////////////
// create a new process
BOOL NewProcess(char* name, BOOL bWait = TRUE)
{
	// fill in start-up info values
	STARTUPINFO StartupInfo;
	ZeroMemory(&StartupInfo, sizeof StartupInfo);
	StartupInfo.cb = sizeof StartupInfo;

	// CreateProcess returns some process information
	PROCESS_INFORMATION ProcessInfo;
	ZeroMemory(&ProcessInfo, sizeof ProcessInfo);

	if (CreateProcess(NULL,     // application name is first token of the command line
				      name,     // contains application name, too
					  NULL,     // default process security settings
					  NULL,     // default thread security settings
					  FALSE,    // process DOES NOT inherit from minshell.exe
					  0,        // child has no access to minshell.exe
					  NULL,     // no special environment
					  NULL,     // same directory
					  &StartupInfo, 
					  &ProcessInfo) == 0) 
	{
		// error handling
		const int MAX_ERROR_LEN = 255;
		char strError[MAX_ERROR_LEN+1];

		DWORD nError = GetLastError();
		FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 
			          NULL,
					  nError,
					  0,
					  strError,
					  MAX_ERROR_LEN,
					  NULL);

		printf("Failed to create \"%s\": (%d) %s\n", name, nError, strError);

		return FALSE;
	}

	printf("\"%s\" (PID: %d, handle: %d) started ", name, ProcessInfo.dwProcessId, 
														  ProcessInfo.hProcess);

	// wait until process terminates and clean up
	if (bWait == TRUE)
	{
		printf("synchronously\n");

		// wait
		WaitForSingleObject(ProcessInfo.hProcess, INFINITE);

		CloseHandle(ProcessInfo.hProcess);
		CloseHandle(ProcessInfo.hThread);
	}
	else
	{
		printf("asynchronously\n");
		CloseHandle(ProcessInfo.hThread);

		// store handle
		AddHandle(ProcessInfo.hProcess);
	}

	return TRUE;
}



////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// here we go !

int main(int argc, char* argv[])
{
	// a shell command file must be supplied
	if (argc > 2)
	{
		printf("usage: \"MinShell ShellCommands.txt\"\n");
		printf("or just \"MinShell\" if you want to type in the commands.\n");

		// wrong parameter count
		return 1;
	}
	printf("Please remember that this extremely cool shell is case sensitive.\n"	\
	       "Available internal commands:\n\n"										\
		   "\"cd\"    Directory      change current directory\n"					\
		   "\"wait\"  Handle|\"all\"   wait for a single process / all processes\n"	\
		   "\"exit\"                 quit shell\n\n"								\
		   "or just enter a program (+parameters) that is available through %%PATH%% !\n\n");
  
	// file handle to access the shell commands
	HANDLE hFile;

	if (argc == 2)
	{
		// open file (read shared !)
		hFile = CreateFile(argv[1], GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if (hFile == INVALID_HANDLE_VALUE)
		{
			printf("Cannot find %s.\n", argv[1]);
			// failed
			return 2;
		}
	}
	else
		// read from console
		hFile = GetStdHandle(STD_INPUT_HANDLE);

	// clear HANDLE list
	ZeroMemory(&arHandles, sizeof arHandles);


	//
	// DA MAIN LOOP
	//

	// read and execute shell commands
	for (;;)
	{
		// at most 512 characters per line
		const int MAX_LINE_LENGTH = 512;
		char  cmdLine[MAX_LINE_LENGTH+1];

		// prompt
		printf("MinShell:");
		// show current directoy
		static char strDirectory[MAX_LINE_LENGTH]; 
		if (GetCurrentDirectory(sizeof strDirectory, strDirectory))
			printf(strDirectory);
		printf("$ ");


		// read the command
		BOOL bDone = ReadLine(hFile, cmdLine);

		// error or exit ?
		if (cmdLine[0] == 0 || SearchCommand("exit", cmdLine))
		{
			printf("\n... winke, winke, Lala !\n");
			return 0;
		}

		// show shell command (if not typed in from console)
		if (hFile != GetStdHandle(STD_INPUT_HANDLE))
			printf("%s\n", cmdLine);

		//
		// now the internal commands
		// "exit" was already handled 
		//

		// "cd [directory]"
		if (char* directory = SearchCommand("cd", cmdLine))
		{
			if (!ChangeDirectory(directory))
				printf("Unable to change directory to \"%s\".\n", directory);
			// read next command
			continue;
		}

		// "wait"
		if (char* strHandle = SearchCommand("wait", cmdLine))
		{
			// wait for all ?
			if (strstr(strHandle, "all"))
			{
				// take a look at each handle
				for (int i=0; i<MAX_HANDLES; i++)
					if (arHandles[i] != 0)
						// wait and remove from list
						Wait(arHandles[i]);
			}
			else
			{
				// get numerical value
				HANDLE dwHandle = (HANDLE) atoi(strHandle);
				// wait and wait and wait ...
				if (!Wait(dwHandle))
					printf("Unable to use handle %d (converted from %s).\n", dwHandle, strHandle);
			}
			
			// read next command
			continue;
		}

			
		//
		// no internal command found ? let's try to launch new process !
		//
		if (cmdLine[strlen(cmdLine)-1] == '&')
		{
			// remove ampersand
			cmdLine[strlen(cmdLine)-1] = 0;
			// launch synchronously
			NewProcess(cmdLine, FALSE);
		}
		else
			// launch asynchronously
			NewProcess(cmdLine, TRUE);
	}

	CloseHandle(hFile);

	// successful
	return 0;
}