// FILTJECT.CPP -- Inject or remove filter driver for a specified device
// Copyright (C) 1999 by Walter Oney
// All rights reserved


#include "stdafx.h"

LPTSTR* CommandLineToArgv(LPTSTR cmdline, int* pargc);

BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
	{							// DllMain
    return TRUE;
	}							// DllMain

///////////////////////////////////////////////////////////////////////////////

extern "C" void WINAPI InjectFilter(HWND hwnd, HINSTANCE hInst, LPCTSTR rawline, int nshow)
	{							// InjectFilter
	HDEVINFO hinfoset = INVALID_HANDLE_VALUE;

	// Determine which platform we're running on. You'll see why a bit later...

	OSVERSIONINFO vi = {sizeof(OSVERSIONINFO)};
	GetVersionEx(&vi);
	BOOL win98 = vi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS;

	// Parse arguments. We expect to be called this way:
	// rundll32 filtject,InjectFilter devname filtname [-Add | -Remove] [-Upper | -Lower] [-First | -LAst | -Before name | -AFter name]
	// Default is to inject 1st upper filter

	int argc;
	LPTSTR cmdline = _tcsdup(rawline);
	LPTSTR* argv = CommandLineToArgv(cmdline, &argc);
	if (!argv)
		{
		free(cmdline);
		return;
		}

	LPTSTR devname = NULL;
	LPTSTR filtname = NULL;
	LPTSTR existing = NULL;
	BOOL upper = TRUE;
	BOOL add = TRUE;
	
	enum POSITION {FIRST, LAST, BEFORE, AFTER, REMOVE} pos = FIRST;

	for (int iarg = 0; iarg < argc; ++iarg)
		{						// inspect arguments
		LPTSTR arg = argv[iarg];
		if (arg[0] == _T('-') || arg[0] == _T('/'))
			{					// parse option
			++arg;
			_tcslwr(arg);
			int len = _tcslen(arg);
			if (memcmp(arg, _T("upper"), min(len, 5) * sizeof(TCHAR)) == 0)
				upper = TRUE;
			else if (memcmp(arg, _T("lower"), min(len, 5) * sizeof(TCHAR)) == 0)
				upper = FALSE;
			else if (memcmp(arg, _T("first"), min(len, 5) * sizeof(TCHAR)) == 0)
				pos = FIRST;
			else if (memcmp(arg, _T("last"), min(len, 4) * sizeof(TCHAR)) == 0)
				pos = LAST;
			else if (memcmp(arg, _T("add"), min(len, 3 * sizeof(TCHAR))) == 0)
				pos = FIRST;
			else if (memcmp(arg, _T("remove"), min(len, 6) * sizeof(TCHAR)) == 0)
				pos = REMOVE;
			else
				{				// before or after something
				if (iarg == argc - 1)
					goto badargs;
				existing = argv[++iarg];
				if (memcmp(arg, _T("before"), min(len, 6) * sizeof(TCHAR)) == 0)
					pos = BEFORE;
				else if (memcmp(arg, _T("after"), min(len, 5) * sizeof(TCHAR)) == 0)
					pos = AFTER;
				else
					goto badargs;
				}				// before or after something
			}					// parse option

		else if (!devname)
			devname = arg;
		else if (!filtname)
			filtname = arg;
		else
			goto badargs;
		}						// inspect arguments

	if (!devname || !filtname)
		goto badargs;			// didn't get both required parameters

	if (pos == REMOVE)
		existing = filtname;	// so we'll search for it later on

	// Use SetupDi functions to locate each instance of the specified device

	hinfoset = SetupDiGetClassDevs(NULL, NULL, hwnd, DIGCF_PRESENT | DIGCF_ALLCLASSES);
	if (hinfoset == INVALID_HANDLE_VALUE)
		goto error;

	{							// local scope
	DWORD propcode = upper ? SPDRP_UPPERFILTERS : SPDRP_LOWERFILTERS;
	LPTSTR valname = upper ? _T("UpperFilters") : _T("LowerFilters");
	SP_DEVINFO_DATA devinfo = {sizeof(SP_DEVINFO_DATA)};

	for (DWORD devindex = 0; SetupDiEnumDeviceInfo(hinfoset, devindex, &devinfo); ++devindex)
		{						// for each device
		DWORD junk;
		TCHAR value[512];
		BOOL found = FALSE;
		if (SetupDiGetDeviceRegistryProperty(hinfoset, &devinfo, SPDRP_FRIENDLYNAME, &junk, (PBYTE) value, sizeof(value), NULL)
			&& _tcsicmp((LPCTSTR) value, devname) == 0)
			found = TRUE;
		if (!found
			&& SetupDiGetDeviceRegistryProperty(hinfoset, &devinfo, SPDRP_DEVICEDESC, &junk, (PBYTE) value, sizeof(value), NULL)
			&& _tcsicmp((LPCTSTR) value, devname) == 0)
			found = TRUE;
		if (!found)
			continue;			// not this device

		DWORD len;				// length of existing value
		HKEY hkey;				// (Win98) registry key handle
		DWORD regtype;			// (Win98) registry data type

		// If running in Win98, open the hardware key and use regular registry functions to get and store
		// the Upper/Lower Filters value. This is necessary because SetupDiSetDeviceRegistryProperty doesn't
		// store a correctly terminated MULTI_SZ value.

		if (win98)
			{					// open registry key
			hkey = SetupDiOpenDevRegKey(hinfoset, &devinfo, DICS_FLAG_GLOBAL, 0, DIREG_DEV, KEY_ALL_ACCESS);
			if (hkey == INVALID_HANDLE_VALUE)
				continue;		// can't open hardware key
			len = sizeof(value);
			if (RegQueryValueEx(hkey, valname, NULL, &regtype, (PBYTE) value, &len) != 0 || len == 0)
				{				// no existing list
				len = sizeof(TCHAR);
				value[0] = 0;
				regtype = REG_BINARY;
				}				// no existing list
			}					// open registry key

		// If running in Win2K, SetupDiSetDeviceRegistryProperty works correctly

		else
			{					// use setup function
			if (!SetupDiGetDeviceRegistryProperty(hinfoset, &devinfo, propcode, &junk, (PBYTE) value, sizeof(value), &len) || len == 0)
				len = sizeof(TCHAR), value[0] = 0;		// empty filter list
			}					// use setup function

		// Locate the spot in the existing list of filters where we should insert the new one (or remove the old one)

		LPTSTR insert = value;
		if (pos == LAST)
			{					// put this filter last
			while (*insert)
				insert += _tcslen(insert) + 1;
			}					// put this filter last
		else if (pos != FIRST)
			{					// before or after something
			while (*insert && _tcsicmp(existing, insert) != 0)
				insert += _tcslen(insert) + 1;
			if (*insert && pos == AFTER)
				insert += _tcslen(insert) + 1;
			if (!*insert && pos == BEFORE)
				insert = value;	// default if "before" filter not found
			}					// before or after something

		// Calculate the number of existing bytes preceding the insertion/deletion spot

		int ncopy = (insert - value) * sizeof(TCHAR);

		// If removing a filter, construct a smaller filter string

		if (pos == REMOVE)
			{					// remove filter
			if (*insert)
				{				// filter was actually in the list
				LPTSTR remove = insert + _tcslen(insert) + 1;
				len -= (_tcslen(existing) + 1) * sizeof(TCHAR);
				ncopy = len - ncopy;
				memcpy(insert, remove, ncopy);
				if (len == sizeof(TCHAR))
					len = 0;	// nothing left

				// Rewrite the filter list

				if (win98)
					{			// remove via registry call
					if (len)
						RegSetValueEx(hkey, valname, 0, regtype, (PBYTE) value, len);
					else
						RegDeleteValue(hkey, valname);
					}			// remove via registry call
				else
					SetupDiSetDeviceRegistryProperty(hinfoset, &devinfo, propcode, (PBYTE) value, len);
				}				// filter was actually in the list
			}					// remove filter

		// Construct a new list of filter drivers

		else
			{					// add filter
			DWORD newlen;
			newlen = len + (_tcslen(filtname) + 1) * sizeof(TCHAR);

			LPTSTR newvalue = (LPTSTR) malloc(newlen);
			if (!newvalue)
				{					// can't get memory
				if (win98)
					RegCloseKey(hkey);
				continue;			// can't get this tiny bit of memory??
				}					// can't get memory

			PBYTE pcopy = (PBYTE) newvalue;
			if (ncopy)
				memcpy(pcopy, value, ncopy);
			pcopy += ncopy;

			if (add)
				{					// insert new name
				_tcscpy((LPTSTR) pcopy, filtname);
				pcopy += (_tcslen(filtname) + 1) * sizeof(TCHAR);

				ncopy = len - ncopy;
				memcpy(pcopy, insert, ncopy);
				}					// insert new name
			else
				{					// remove name
				}					// remove name

			// Install the new filter list

			if (win98)
				RegSetValueEx(hkey, valname, 0, regtype, (PBYTE) newvalue, newlen);
			else
				SetupDiSetDeviceRegistryProperty(hinfoset, &devinfo, propcode, (PBYTE) newvalue, newlen);

			free(newvalue);
			}						// add filter

		if (win98)
			RegCloseKey(hkey);
		}						// for each device
	}							// local scope

cleanup:
	if (hinfoset != INVALID_HANDLE_VALUE)
		SetupDiDestroyDeviceInfoList(hinfoset);
	free(argv);
	free(cmdline);
	return;

badargs:
	OutputDebugString(_T("InjectFilter - invalid arguments\n"));
	goto cleanup;

error:
	OutputDebugString(_T("InjectFilter - error trying to inject filter\n"));
	goto cleanup;
	}							// InjectFilter

///////////////////////////////////////////////////////////////////////////////
// Note -- CommandLineToArgvW exists already, but not the ANSI equivalent @&*%!

LPTSTR* CommandLineToArgv(LPTSTR cmdline, int* pargc)
	{							// CommandLineToArgv
	int argc = 0;
	while (*cmdline == _T(' ') || *cmdline == _T('\t'))
		++cmdline;				// skip leading blanks

	LPTSTR arg = cmdline;
	while (*arg)
		{						// count arguments
		TCHAR ch;
		while ((ch = *arg) == _T(' ') || ch == _T('\t'))
			*arg++ = _T(' ');	// skip leading blanks, replace tabs with blanks
		if (!ch)
			break;				// end of command line
		
		++argc;
		
		if (ch == _T('\"'))
			{					// quoted arg
			*arg++ = _T(' ');	// replace leading quote with space
			while ((ch = *arg) && ch != _T('\"'))
				++arg;			// find trailing quote
			}					// quoted arg
		else
			{					// unquoted arg
			while ((ch = *arg) && ch != _T(' ') && ch != _T('\t'))
				++arg;			// find space after arg
			}					// unquoted arg

		if (ch)
			*arg++ = 0;			// change ending delimiter to nul
		}						// count arguments

	if (!argc)
		return NULL;			// no arguments

	LPTSTR* argv = (LPTSTR*) malloc(argc * sizeof(LPTSTR));
	if (!argv)
		return NULL;			// can't allocate memory

	arg = cmdline;
	for (int iarg = 0; iarg < argc; ++iarg)
		{						// fill in argv array
		TCHAR ch;
		while ((ch = *arg) == _T(' '))
			++arg;				// skip to start of arg
		argv[iarg] = arg;
		arg += _tcslen(arg) + 1;	// skip to end of arg
		}						// fill in argv array

	*pargc = argc;
	return argv;
	}							// CommandLineToArgv