precomp.h File Reference

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <winreg.h>
#include <wincon.h>
#include <winuser.h>
#include <errno.h>
#include <conutils.h>
#include <netsh.h>
#include "resource.h"

Include dependency graph for precomp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DLL_LIST_ENTRY
struct	_HELPER_ENTRY
struct	_COMMAND_ENTRY
struct	_COMMAND_GROUP
struct	_CONTEXT_ENTRY

Macros
#define	WIN32_NO_STATUS
#define	MAX_STRING_SIZE   1024
#define	MAX_ARGS_COUNT   256
#define	REG_NETSH_PATH   L"Software\\Microsoft\\NetSh"

Typedefs
typedef struct _DLL_LIST_ENTRY	DLL_LIST_ENTRY
typedef struct _DLL_LIST_ENTRY *	PDLL_LIST_ENTRY
typedef struct _HELPER_ENTRY	HELPER_ENTRY
typedef struct _HELPER_ENTRY *	PHELPER_ENTRY
typedef struct _COMMAND_ENTRY	COMMAND_ENTRY
typedef struct _COMMAND_ENTRY *	PCOMMAND_ENTRY
typedef struct _COMMAND_GROUP	COMMAND_GROUP
typedef struct _COMMAND_GROUP *	PCOMMAND_GROUP
typedef struct _CONTEXT_ENTRY	CONTEXT_ENTRY
typedef struct _CONTEXT_ENTRY *	PCONTEXT_ENTRY

Functions
BOOL	CreateRootContext (VOID)
DWORD WINAPI	HelpCommand (LPCWSTR pwszMachine, LPWSTR *ppwcArguments, DWORD dwCurrentIndex, DWORD dwArgCount, DWORD dwFlags, LPCVOID pvData, BOOL *pbDone)
VOID	HelpGroup (PCOMMAND_GROUP pGroup)
VOID	LoadHelpers (VOID)
VOID	UnloadHelpers (VOID)
DWORD WINAPI	AddHelperCommand (LPCWSTR pwszMachine, LPWSTR *ppwcArguments, DWORD dwCurrentIndex, DWORD dwArgCount, DWORD dwFlags, LPCVOID pvData, BOOL *pbDone)
DWORD WINAPI	DeleteHelperCommand (LPCWSTR pwszMachine, LPWSTR *ppwcArguments, DWORD dwCurrentIndex, DWORD dwArgCount, DWORD dwFlags, LPCVOID pvData, BOOL *pbDone)
DWORD WINAPI	ShowHelperCommand (LPCWSTR pwszMachine, PWSTR *ppwcArguments, DWORD dwCurrentIndex, DWORD dwArgCount, DWORD dwFlags, LPCVOID pvData, BOOL *pbDone)
BOOL	InterpretScript (LPWSTR pszFileName)
BOOL	InterpretCommand (LPWSTR *argv, DWORD dwArgCount)
VOID	InterpretInteractive (VOID)

Variables
PCONTEXT_ENTRY	pRootContext
PCONTEXT_ENTRY	pCurrentContext

Macro Definition Documentation

MAX_ARGS_COUNT

#define MAX_ARGS_COUNT   256

Definition at line 35 of file precomp.h.

MAX_STRING_SIZE

#define MAX_STRING_SIZE   1024

Definition at line 34 of file precomp.h.

REG_NETSH_PATH

#define REG_NETSH_PATH   L"Software\\Microsoft\\NetSh"

Definition at line 37 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 17 of file precomp.h.

Typedef Documentation

COMMAND_ENTRY

typedef struct _COMMAND_ENTRY COMMAND_ENTRY

COMMAND_GROUP

typedef struct _COMMAND_GROUP COMMAND_GROUP

CONTEXT_ENTRY

typedef struct _CONTEXT_ENTRY CONTEXT_ENTRY

DLL_LIST_ENTRY

typedef struct _DLL_LIST_ENTRY DLL_LIST_ENTRY

HELPER_ENTRY

typedef struct _HELPER_ENTRY HELPER_ENTRY

PCOMMAND_ENTRY

typedef struct _COMMAND_ENTRY * PCOMMAND_ENTRY

PCOMMAND_GROUP

typedef struct _COMMAND_GROUP * PCOMMAND_GROUP

PCONTEXT_ENTRY

typedef struct _CONTEXT_ENTRY * PCONTEXT_ENTRY

PDLL_LIST_ENTRY

typedef struct _DLL_LIST_ENTRY * PDLL_LIST_ENTRY

PHELPER_ENTRY

typedef struct _HELPER_ENTRY * PHELPER_ENTRY

Function Documentation

AddHelperCommand()

DWORD WINAPI AddHelperCommand	(	LPCWSTR	pwszMachine,
		LPWSTR *	ppwcArguments,
		DWORD	dwCurrentIndex,
		DWORD	dwArgCount,
		DWORD	dwFlags,
		LPCVOID	pvData,
		BOOL *	pbDone
	)

Definition at line 425 of file helper.c.

{
    DWORD dwError = ERROR_SUCCESS;
 
    DPRINT("AddHelperCommand()\n");
 
    if (dwArgCount == 2)
    {
//        ConResPrintf(StdErr, IDS_INVALID_SYNTAX);
//        ConResPrintf(StdErr, IDS_HLP_ADD_HELPER_EX);
        return 1;
    }
 
    dwError = LoadHelperDll(ppwcArguments[2], TRUE);
    if (dwError != ERROR_SUCCESS)
        return dwError;
 
    StartHelpers();
 
    return ERROR_SUCCESS;
}

Referenced by CreateRootContext().

CreateRootContext()

BOOL CreateRootContext

(

VOID

)

Definition at line 282 of file context.c.

{
    PCOMMAND_GROUP pGroup;
 
    pRootContext = AddContext(NULL, NULL, NULL);
    DPRINT1("pRootContext: %p\n", pRootContext);
    if (pRootContext == NULL)
        return FALSE;
 
    pRootContext->hModule = GetModuleHandle(NULL);
 
    AddContextCommand(pRootContext, L"..",   UpCommand, IDS_HLP_UP, IDS_HLP_UP_EX, 0);
    AddContextCommand(pRootContext, L"?",    HelpCommand, IDS_HLP_HELP, IDS_HLP_HELP_EX, 0);
    AddContextCommand(pRootContext, L"bye",  ExitCommand, IDS_HLP_EXIT, IDS_HLP_EXIT_EX, 0);
    AddContextCommand(pRootContext, L"exit", ExitCommand, IDS_HLP_EXIT, IDS_HLP_EXIT_EX, 0);
    AddContextCommand(pRootContext, L"help", HelpCommand, IDS_HLP_HELP, IDS_HLP_HELP_EX, 0);
    AddContextCommand(pRootContext, L"quit", ExitCommand, IDS_HLP_EXIT, IDS_HLP_EXIT_EX, 0);
 
    pGroup = AddCommandGroup(pRootContext, L"add", IDS_HLP_GROUP_ADD, 0);
    if (pGroup)
    {
        AddGroupCommand(pGroup, L"helper", AddHelperCommand, IDS_HLP_ADD_HELPER, IDS_HLP_ADD_HELPER_EX, 0);
    }
 
    pGroup = AddCommandGroup(pRootContext, L"delete", IDS_HLP_GROUP_DELETE, 0);
    if (pGroup)
    {
        AddGroupCommand(pGroup, L"helper", DeleteHelperCommand, IDS_HLP_DEL_HELPER, IDS_HLP_DEL_HELPER_EX, 0);
    }
 
    pGroup = AddCommandGroup(pRootContext, L"show", IDS_HLP_GROUP_SHOW, 0);
    if (pGroup)
    {
        AddGroupCommand(pGroup, L"helper", ShowHelperCommand, IDS_HLP_SHOW_HELPER, IDS_HLP_SHOW_HELPER_EX, 0);
    }
 
    pCurrentContext = pRootContext;
 
    return TRUE;
}

Referenced by wmain().

DeleteHelperCommand()

DWORD WINAPI DeleteHelperCommand	(	LPCWSTR	pwszMachine,
		LPWSTR *	ppwcArguments,
		DWORD	dwCurrentIndex,
		DWORD	dwArgCount,
		DWORD	dwFlags,
		LPCVOID	pvData,
		BOOL *	pbDone
	)

Definition at line 457 of file helper.c.

{
    PDLL_LIST_ENTRY pEntry;
    HKEY hKey;
    DWORD dwError;
 
    DPRINT("DeleteHelper()\n");
 
    if (dwArgCount == 2)
    {
//        ConResPrintf(StdErr, IDS_INVALID_SYNTAX);
//        ConResPrintf(StdErr, IDS_HLP_DEL_HELPER_EX);
        return 1;
    }
 
    pEntry = pDllListHead;
    while (pEntry != NULL)
    {
        if (wcscmp(pEntry->pszShortName, ppwcArguments[2]) == 0)
        {
            DPRINT1("remove %S\n", pEntry->pszShortName);
 
            if (pEntry->pPrev != NULL)
                pEntry->pPrev->pNext = pEntry->pNext;
            if (pEntry->pNext != NULL)
                pEntry->pNext->pPrev = pEntry->pPrev;
            if (pDllListTail == pEntry)
                pDllListTail = pEntry->pPrev;
            if (pDllListHead == pEntry)
                pDllListHead = pEntry->pNext;
            pEntry->pPrev = NULL;
            pEntry->pNext = NULL;
 
            dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                                    REG_NETSH_PATH,
                                    0,
                                    KEY_WRITE,
                                    &hKey);
            if (dwError == ERROR_SUCCESS)
            {
                RegDeleteValue(hKey, pEntry->pszValueName);
                RegCloseKey(hKey);
            }
 
            FreeHelperDll(pEntry);
 
            return 1;
        }
 
        pEntry = pEntry->pNext;
    }
 
    return ERROR_SUCCESS;
}

Referenced by CreateRootContext().

HelpCommand()

DWORD WINAPI HelpCommand	(	LPCWSTR	pwszMachine,
		LPWSTR *	ppwcArguments,
		DWORD	dwCurrentIndex,
		DWORD	dwArgCount,
		DWORD	dwFlags,
		LPCVOID	pvData,
		BOOL *	pbDone
	)

Definition at line 116 of file help.c.

{
    PCONTEXT_ENTRY pContext;
 
    ConResPrintf(StdOut, IDS_HELP_HEADER);
 
    pContext = pCurrentContext;
    if (pContext == NULL)
    {
        DPRINT1("HelpCommand: invalid context %p\n", pContext);
        return 1;
    }
 
    HelpContext(pContext);
 
    if (pCurrentContext->pSubContextHead != NULL)
    {
        ConResPrintf(StdOut, IDS_SUBCONTEXT_HEADER);
        pContext = pCurrentContext->pSubContextHead;
        while (pContext != NULL)
        {
            ConPrintf(StdOut, L" %s", pContext->pszContextName);
            pContext = pContext->pNext;
        }
        ConPuts(StdOut, L"\n");
    }
    ConPuts(StdOut, L"\n");
 
    return ERROR_SUCCESS;
}

Referenced by CreateRootContext(), help_main(), InterpretCmd(), and main().

HelpGroup()

VOID HelpGroup

(

PCOMMAND_GROUP

pGroup

)

Definition at line 93 of file help.c.

{
    PCOMMAND_ENTRY pCommand;
    WCHAR szBuffer[64];
 
    ConResPrintf(StdOut, IDS_HELP_HEADER);
 
    ConPrintf(StdOut, L"\nCommands in this context:\n");
 
    pCommand = pGroup->pCommandListHead;
    while (pCommand != NULL)
    {
        swprintf(szBuffer, L"%s %s", pGroup->pwszCmdGroupToken, pCommand->pwszCmdToken);
        ConPrintf(StdOut, L"%-15s - ", szBuffer);
        ConResPuts(StdOut, pCommand->dwShortCmdHelpToken);
        pCommand = pCommand->pNext;
    }
}

Referenced by InterpretCommand().

InterpretCommand()

BOOL InterpretCommand	(	LPWSTR *	argv,
		DWORD	dwArgCount
	)

InterpretInteractive()

VOID InterpretInteractive

(

VOID

)

Definition at line 188 of file interpreter.c.

{
    WCHAR input_line[MAX_STRING_SIZE];
    LPWSTR args_vector[MAX_ARGS_COUNT];
    DWORD dwArgCount = 0;
    BOOL bWhiteSpace = TRUE;
    BOOL bRun = TRUE;
    LPWSTR ptr;
 
    while (bRun != FALSE)
    {
        dwArgCount = 0;
        memset(args_vector, 0, sizeof(args_vector));
 
        /* Shown just before the input where the user places commands */
//        ConResPuts(StdOut, IDS_APP_PROMPT);
        ConPuts(StdOut, L"netsh");
        if (pCurrentContext != pRootContext)
        {
            ConPuts(StdOut, L" ");
            ConPuts(StdOut, pCurrentContext->pszContextName);
        }
        ConPuts(StdOut, L">");
 
        /* Get input from the user. */
        fgetws(input_line, MAX_STRING_SIZE, stdin);
 
        ptr = input_line;
        while (*ptr != 0)
        {
            if (iswspace(*ptr) || *ptr == L'\n')
            {
                *ptr = 0;
                bWhiteSpace = TRUE;
            }
            else
            {
                if ((bWhiteSpace != FALSE) && (dwArgCount < MAX_ARGS_COUNT))
                {
                    args_vector[dwArgCount] = ptr;
                    dwArgCount++;
                }
                bWhiteSpace = FALSE;
            }
            ptr++;
        }
 
        /* Send the string to find the command */
        bRun = InterpretCommand(args_vector, dwArgCount);
    }
}

Referenced by wmain().

InterpretScript()

BOOL InterpretScript

(

LPWSTR

pszFileName

)

Definition at line 183 of file interpreter.c.

{
    LPWSTR args_vector[MAX_ARGS_COUNT];
    INT args_count = 0;
    BOOL bWhiteSpace = TRUE;
    BOOL bQuote = FALSE;
    LPWSTR ptr;
 
    memset(args_vector, 0, sizeof(args_vector));
 
    bQuote = FALSE;
    ptr = input_line;
    while (*ptr != 0)
    {
        if (*ptr == L'"')
            bQuote = !bQuote;
 
        if ((iswspace(*ptr) && (bQuote == FALSE))|| *ptr == L'\n')
        {
            *ptr = 0;
            bWhiteSpace = TRUE;
        }
        else
        {
            if ((bWhiteSpace != FALSE) && (bQuote == FALSE) && (args_count < MAX_ARGS_COUNT))
            {
                args_vector[args_count] = ptr;
                args_count++;
            }
 
            bWhiteSpace = FALSE;
        }
 
        ptr++;
    }
 
    /* sends the string to find the command */
    return InterpretCmd(args_count, args_vector);
}

LoadHelpers()

VOID LoadHelpers

(

VOID

)

Definition at line 241 of file helper.c.

{
    PWSTR pszNameBuffer = NULL;
    PWSTR pszValueBuffer = NULL;
    HKEY hKey;
    DWORD dwValueCount, dwMaxNameLength, dwMaxValueLength;
    DWORD dwNameLength, dwValueLength, dwType;
    DWORD dwIndex, dwError;
 
    DPRINT1("LoadHelpers()\n");
 
    dwError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                            REG_NETSH_PATH,
                            0,
                            KEY_READ,
                            &hKey);
    if (dwError != ERROR_SUCCESS)
        return;
 
    dwError = RegQueryInfoKeyW(hKey,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               NULL,
                               &dwValueCount,
                               &dwMaxNameLength,
                               &dwMaxValueLength,
                               NULL,
                               NULL);
    if (dwError != ERROR_SUCCESS)
        goto done;
 
    pszNameBuffer = HeapAlloc(GetProcessHeap(), 0,
                              (dwMaxNameLength + 1) * sizeof(WCHAR));
    if (pszNameBuffer == NULL)
        goto done;
 
    pszValueBuffer = HeapAlloc(GetProcessHeap(), 0,
                               dwMaxValueLength + sizeof(WCHAR));
    if (pszValueBuffer == NULL)
        goto done;
 
    for (dwIndex = 0; dwIndex < dwValueCount; dwIndex++)
    {
        dwNameLength = dwMaxNameLength + 1;
        dwValueLength = dwMaxValueLength + sizeof(WCHAR);
        dwError = RegEnumValueW(hKey,
                                dwIndex,
                                pszNameBuffer,
                                &dwNameLength,
                                NULL,
                                &dwType,
                                (PBYTE)pszValueBuffer,
                                &dwValueLength);
        if (dwError != ERROR_SUCCESS)
            break;
 
        DPRINT1("Dll: %S --> %S  %lu\n", pszNameBuffer, pszValueBuffer, dwError);
        LoadHelperDll(pszValueBuffer, FALSE);
    }
 
done:
    if (pszValueBuffer)
        HeapFree(GetProcessHeap(), 0, pszValueBuffer);
 
    if (pszNameBuffer)
        HeapFree(GetProcessHeap(), 0, pszNameBuffer);
 
    RegCloseKey(hKey);
 
    StartHelpers();
}

Referenced by wmain().

ShowHelperCommand()

DWORD WINAPI ShowHelperCommand	(	LPCWSTR	pwszMachine,
		PWSTR *	ppwcArguments,
		DWORD	dwCurrentIndex,
		DWORD	dwArgCount,
		DWORD	dwFlags,
		LPCVOID	pvData,
		BOOL *	pbDone
	)

UnloadHelpers()

VOID UnloadHelpers

(

VOID

)

Definition at line 318 of file helper.c.

{
    PDLL_LIST_ENTRY pEntry;
 
    while (pDllListHead != NULL)
    {
        pEntry = pDllListHead;
        pDllListHead = pEntry->pNext;
 
//        if (pEntry->Attributes.pfnStop)
//            pEntry->Attributes.pfnStop(0);
 
        FreeHelperDll(pEntry);
    }
 
    pDllListTail = NULL;
}

Referenced by wmain().

Variable Documentation

pCurrentContext

PCONTEXT_ENTRY pCurrentContext

extern

Definition at line 18 of file context.c.

Referenced by CreateRootContext(), HelpCommand(), HelpContext(), InterpretCommand(), InterpretInteractive(), and UpCommand().

pRootContext

PCONTEXT_ENTRY pRootContext

extern

Definition at line 17 of file context.c.

Referenced by CreateRootContext(), HelpContext(), InterpretCommand(), InterpretInteractive(), RegisterContext(), ShowHelperCommand(), and UpCommand().