Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-11-05 14:19:25 +00:00
Code Issues Projects Releases Packages Wiki Activity
reactos/rosapps/applications/sysutils/regexpl/ShellCommandValue.cpp
Stefan Ginsberg a557cda82c - Fix gdb2 and regexpl warnings under gcc 4.4.0 
svn path=/trunk/; revision=42968
2009-08-30 15:35:14 +00:00

440 lines
13 KiB
C++
Raw Blame History

/* $Id$
*
* regexpl - Console Registry Explorer
*
* Copyright (C) 2000-2005 Nedko Arnaudov <nedko@users.sourceforge.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
// ShellCommandValue.cpp: implementation of the CShellCommandValue class.
//
//////////////////////////////////////////////////////////////////////
#include "ph.h"
#include "RegistryExplorer.h"
#include "ShellCommandValue.h"
#include "RegistryTree.h"
#include "RegistryKey.h"
#define VALUE_CMD _T("VV")
#define VALUE_CMD_LENGTH COMMAND_LENGTH(VALUE_CMD)
#define VALUE_CMD_SHORT_DESC VALUE_CMD _T(" command is used to view value.\n")
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CShellCommandValue::CShellCommandValue(CRegistryTree& rTree):m_rTree(rTree)
{
}
CShellCommandValue::~CShellCommandValue()
{
}
BOOL CShellCommandValue::Match(const TCHAR *pchCommand)
{
if (_tcsicmp(pchCommand,VALUE_CMD) == 0)
return TRUE;
if (_tcsnicmp(pchCommand,VALUE_CMD _T(".."),VALUE_CMD_LENGTH+2*sizeof(TCHAR)) == 0)
return TRUE;
if (_tcsnicmp(pchCommand,VALUE_CMD _T("/"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
return TRUE;
if (_tcsnicmp(pchCommand,VALUE_CMD _T("\\"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
return TRUE;
return FALSE;
}
int CShellCommandValue::Execute(CConsole &rConsole, CArgumentParser& rArguments)
{
rArguments.ResetArgumentIteration();
TCHAR *pchCommandItself = rArguments.GetNextArgument();
TCHAR *pchParameter;
TCHAR *pchValueFull = NULL;
BOOL blnUnicodeDump = FALSE;
BOOL blnBadParameter = FALSE;
BOOL blnHelp = FALSE;
LONG nError;
DWORD dwValueSize;
DWORD dwType = REG_NONE;
BYTE *pDataBuffer = NULL;
TCHAR *pchFilename = NULL;
if ((_tcsnicmp(pchCommandItself,VALUE_CMD _T(".."),VALUE_CMD_LENGTH+2*sizeof(TCHAR)) == 0)||
(_tcsnicmp(pchCommandItself,VALUE_CMD _T("\\"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0))
{
pchValueFull = pchCommandItself + VALUE_CMD_LENGTH;
}
else if (_tcsnicmp(pchCommandItself,VALUE_CMD _T("/"),VALUE_CMD_LENGTH+1*sizeof(TCHAR)) == 0)
{
pchParameter = pchCommandItself + VALUE_CMD_LENGTH;
goto CheckValueArgument;
}
while((pchParameter = rArguments.GetNextArgument()) != NULL)
{
CheckValueArgument:
blnBadParameter = FALSE;
if ((_tcsicmp(pchParameter,_T("/?")) == 0)
||(_tcsicmp(pchParameter,_T("-?")) == 0))
{
blnHelp = TRUE;
break;
}
else if (_tcsicmp(pchParameter,_T("/u")) == 0)
{
blnUnicodeDump = TRUE;
}
else if ((*pchParameter == _T('/'))&&(*(pchParameter+1) == _T('f')))
{
pchFilename = pchParameter+2;
}
else if (!pchValueFull)
{
pchValueFull = pchParameter;
}
else
{
blnBadParameter = TRUE;
}
if (blnBadParameter)
{
rConsole.Write(_T("Bad parameter: "));
rConsole.Write(pchParameter);
rConsole.Write(_T("\n"));
}
}
CRegistryKey Key;
TCHAR *pchValueName;
const TCHAR *pszEmpty = _T("");
const TCHAR *pszPath;
if (blnHelp)
{
rConsole.Write(GetHelpString());
if (pDataBuffer)
delete pDataBuffer;
return 0;
}
if (pchValueFull)
{
if (_tcscmp(pchValueFull,_T("\\")) == 0)
goto ValueCommandNAonRoot;
TCHAR *pchSep = _tcsrchr(pchValueFull,_T('\\'));
pchValueName = pchSep?(pchSep+1):(pchValueFull);
pszPath = pchSep?pchValueFull:_T(".");
//if (_tcsrchr(pchValueName,_T('.')))
//{
// pchValueName = _T("");
// pchPath = pchValueFull;
//}
//else
if (pchSep)
*pchSep = 0;
}
else
{
pchValueName = (TCHAR*)pszEmpty;
pszPath = _T(".");
}
if (!m_rTree.GetKey(pszPath,KEY_READ,Key))
{
rConsole.Write(m_rTree.GetLastErrorDescription());
goto SkipValueCommand;
}
if (Key.IsRoot())
goto ValueCommandNAonRoot;
{
rConsole.Write(_T("Value name : \""));
rConsole.Write(_T("\\"));
rConsole.Write(Key.GetKeyName());
size_t l = _tcslen(pchValueName);
if (l&&
(*pchValueName == _T('\"'))&&
(pchValueName[l-1] == _T('\"')))
{
pchValueName[l-1] = 0;
pchValueName++;
}
rConsole.Write(pchValueName);
rConsole.Write(_T("\"\n"));
nError = Key.GetValue(pchValueName,NULL,NULL,&dwValueSize);
if (nError == ERROR_SUCCESS)
{
pDataBuffer = new BYTE [dwValueSize];
Key.GetValue(pchValueName,&dwType,pDataBuffer,&dwValueSize);
rConsole.Write(_T("Value type : "));
rConsole.Write(CRegistryKey::GetValueTypeName(dwType));
rConsole.Write(_T("\nValue data : "));
switch(dwType)
{
case REG_DWORD_LITTLE_ENDIAN:
{
TCHAR Buffer[3];
rConsole.Write(_T("0x"));
for (unsigned int i = 0 ; i < dwValueSize ; i++)
{
_stprintf(Buffer,_T("%02X"),*(pDataBuffer+((dwValueSize-1)-i)));
rConsole.Write(Buffer);
}
}
rConsole.Write(_T("\n"));
break;
case REG_DWORD_BIG_ENDIAN:
{
TCHAR Buffer[3];
rConsole.Write(_T("0x"));
for (unsigned int i = 0 ; i < dwValueSize ; i++)
{
_stprintf(Buffer,_T("%02X"),*(pDataBuffer+i));
rConsole.Write(Buffer);
}
}
rConsole.Write(_T("\n"));
break;
case REG_LINK:
break;
case REG_MULTI_SZ:
{
TCHAR *pchCurrentString = (TCHAR *)pDataBuffer;
rConsole.Write(_T("\n"));
while(*pchCurrentString)
{
rConsole.Write(_T("\""));
rConsole.Write(pchCurrentString);
rConsole.Write(_T("\"\n"));
pchCurrentString += _tcslen(pchCurrentString)+1;
}
}
break;
case REG_RESOURCE_LIST:
break;
case REG_SZ:
case REG_EXPAND_SZ:
rConsole.Write(_T("\""));
rConsole.Write((TCHAR *)pDataBuffer);
rConsole.Write(_T("\"\n"));
break;
case REG_BINARY:
default:
{
TCHAR Buffer[256];
DWORD i, j;
for (i = 0 ; i < dwValueSize ; i++)
{
if (i%16 == 0)
{ // ok this is begining of line
rConsole.Write(_T("\n"));
// print offset
_stprintf(Buffer,_T("0x%08X "),(unsigned int)i);
rConsole.Write(Buffer);
}
else if (i%8 == 0)
{ // this is the additional space between 7th and 8th byte in current line
rConsole.Write(_T(" "));
}
// print current byte
unsigned int n = *(pDataBuffer+i);
_stprintf(Buffer,_T("%02X "),n);
rConsole.Write(Buffer);
if (i && (i%16 == 15))
{ // if this is the last byte in line
// Dump text representation
for (j = i-15; j <= i; j += blnUnicodeDump?2:1)\
{
if ((j%8 == 0)&&(j%16 != 0))
{ // this is the additional space between 7th and 8th byte in current line
rConsole.Write(_T(" "));
}
ASSERT(i-j < 16);
// write current char representation
if (blnUnicodeDump)
{
ASSERT(j%2 == 0);
wchar_t ch = *(TCHAR *)(pDataBuffer+j);
_stprintf(Buffer,
#ifdef _UNICODE
_T("%c"),
#else
// g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
// %C in format string is a Microsoft extension.
_T("%C"),
#endif
iswprint(ch)?ch:L'.');
}
else
{
unsigned char ch = *(pDataBuffer+j);
_stprintf(Buffer,
#ifdef _UNICODE
// g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
// %C in format string is a Microsoft extension.
_T("%C"),
#else
_T("%c"),
#endif
isprint(ch)?ch:'.');
}
rConsole.Write(Buffer);
} // for
} // if
} // for
// print text representation of last line if it is not full (it have less than 16 bytes)
// k is pseudo offset
for (DWORD k = i; k%16 != 0; k++)
{
if (k%8 == 0)
{ // this is the additional space between 7th and 8th byte in current line
rConsole.Write(_T(" "));
}
_tcscpy(Buffer,_T(" ")); // the replacement of two digit of current byte + spacing
rConsole.Write(Buffer);
if (k && (k%16 == 15))
{ // if this is the last byte in line
ASSERT((k-15)%16 == 0); // k-15 must point at begin of last line
for (j = k-15; j < i; j += blnUnicodeDump?2:1)
{
if (blnUnicodeDump&&(j+1 >= i))
{ // ok, buffer size is odd number, so we don't display last byte.
ASSERT(j+1 == i);
break;
}
if ((j%8 == 0)&&(j%16 != 0))
{ // this is the additional space between 7th and 8th byte in current line
rConsole.Write(_T(" "));
}
// write current char representation
if (blnUnicodeDump)
{
ASSERT(j%2 == 0);
wchar_t ch = *(TCHAR *)(pDataBuffer+j);
_stprintf(Buffer,
#ifdef _UNICODE
_T("%c"),
#else
// g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
// %C in format string is a Microsoft extension.
_T("%C"),
#endif
iswprint(ch)?ch:L'.');
}
else
{
unsigned char ch = *(pDataBuffer+j);
_stprintf(Buffer,
#ifdef _UNICODE
// g++ may print warnings here (warning: __wchar_t format, different type arg (arg 3))
// %C in format string is a Microsoft extension.
_T("%C"),
#else
_T("%c"),
#endif
isprint(ch)?ch:'.');
}
rConsole.Write(Buffer);
} // for
} // if
} // for
} // default:
rConsole.Write(_T("\n"));
} // switch
rConsole.Write(_T("\n"));
if (pchFilename)
{
rConsole.Write(_T("Exporting value data to "));
rConsole.Write(pchFilename);
rConsole.Write(_T(" ...\n"));
HANDLE hFile = CreateFile(pchFilename,GENERIC_WRITE,0,NULL,CREATE_NEW,FILE_ATTRIBUTE_NORMAL,NULL);
if (hFile == INVALID_HANDLE_VALUE)
{
rConsole.Write(_T("Cannot create new file "));
rConsole.Write(pchFilename);
rConsole.Write(_T("\n"));
goto SkipValueCommand;
}
DWORD dwBytesWritten;
if (!WriteFile(hFile,pDataBuffer,dwValueSize,&dwBytesWritten,NULL))
{
rConsole.Write(_T("Error writting file.\n"));
VERIFY(CloseHandle(hFile));
goto SkipValueCommand;
}
ASSERT(dwBytesWritten == dwValueSize);
VERIFY(CloseHandle(hFile));
}
}
else
{
rConsole.Write(_T("Error "));
TCHAR Buffer[256];
rConsole.Write(_itoa(nError,Buffer,10));
rConsole.Write(_T("\n"));
if (nError == ERROR_FILE_NOT_FOUND)
{
rConsole.Write(_T("(System cannot find the value specified)\n"));
}
}
}
SkipValueCommand:
if (pDataBuffer)
delete pDataBuffer;
return 0;
ValueCommandNAonRoot:
rConsole.Write(VALUE_CMD COMMAND_NA_ON_ROOT);
return 0;
}
const TCHAR * CShellCommandValue::GetHelpString()
{
return VALUE_CMD_SHORT_DESC
_T("Syntax: ") VALUE_CMD _T(" [<PATH>][<VALUE_NAME>] [/u] [/?]\n\n")
_T(" <PATH> - Optional relative path of key which value will be processed.\n")
_T(" <VALUE_NAME> - Name of key's value. Default is key's default value.\n")
_T(" /u - On binary dump view as Unicode.\n")
_T(" /fFILE - Export value data to FILE.\n")
_T(" /? - This help.\n\n")
_T("Without parameters, command displays default value of current key.\n");
}
const TCHAR * CShellCommandValue::GetHelpShortDescriptionString()
{
return VALUE_CMD_SHORT_DESC;
}
Reference in a new issue View git blame Copy permalink