ShellCommandValue.cpp

Go to the documentation of this file.

/*
 * 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;
}