1575 lines
41 KiB
C++
1575 lines
41 KiB
C++
//
|
|
// rdpfstore.cpp
|
|
//
|
|
// Implementation of CRdpFileStore, implements ISettingsStore
|
|
//
|
|
// CRdpFileStore implements a persistent settings store for
|
|
// ts client settings.
|
|
//
|
|
//
|
|
// Copyright(C) Microsoft Corporation 2000
|
|
// Author: Nadim Abdo (nadima)
|
|
//
|
|
|
|
//
|
|
// Notes for improvement:
|
|
// Can add a hash lookup table to speedup FindRecord.
|
|
// (FindRecord is called at least once for each property that
|
|
// is read/written during OpenStore/SaveStore operations)
|
|
// Most files contain maybe 5-10 records so speeding up
|
|
// the find is probably not that important.
|
|
//
|
|
// Copyright(C) Microsoft Corporation 2000
|
|
// Author: Nadim Abdo (nadima)
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#define TRC_GROUP TRC_GROUP_UI
|
|
#define TRC_FILE "rdpfstore.cpp"
|
|
#include <atrcapi.h>
|
|
|
|
#include "rdpfstore.h"
|
|
#include "autil.h" //for StringToBinary/BinaryToString
|
|
|
|
//
|
|
// Index values must match RDPF_RECTYPE_*
|
|
//
|
|
LPCTSTR g_szTypeCodeMap[] =
|
|
{
|
|
TEXT(":i:"), //RDPF_RECTYPE_UINT
|
|
TEXT(":s:"), //RDPF_RECTYPE_SZ
|
|
TEXT(":b:") //RDPF_RECTYPE_BINARY
|
|
};
|
|
|
|
CRdpFileStore::CRdpFileStore()
|
|
{
|
|
_cRef = 1;
|
|
_fReadOnly = FALSE;
|
|
_fOpenForRead = FALSE;
|
|
_fOpenForWrite = FALSE;
|
|
_fIsDirty = FALSE;
|
|
_pRecordListHead= NULL;
|
|
_pRecordListTail= NULL;
|
|
_szFileName[0] = 0;
|
|
}
|
|
|
|
CRdpFileStore::~CRdpFileStore()
|
|
{
|
|
DeleteRecords();
|
|
}
|
|
|
|
ULONG __stdcall CRdpFileStore::AddRef()
|
|
{
|
|
DC_BEGIN_FN("AddRef");
|
|
ULONG cref = InterlockedIncrement(&_cRef);
|
|
TRC_ASSERT(cref > 0, (TB,_T("AddRef: cref is not > 0!")));
|
|
DC_END_FN();
|
|
return cref;
|
|
}
|
|
|
|
ULONG __stdcall CRdpFileStore::Release()
|
|
{
|
|
DC_BEGIN_FN("Release");
|
|
TRC_ASSERT(_cRef > 0, (TB,_T("AddRef: cref is not > 0!")));
|
|
ULONG cref = InterlockedDecrement(&_cRef);
|
|
if(0 == cref)
|
|
{
|
|
TRC_DBG((TB,_T("CRdpFileStore::Release deleting object")));
|
|
delete this;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return cref;
|
|
}
|
|
|
|
STDMETHODIMP CRdpFileStore::QueryInterface(REFIID iid, void** p)
|
|
{
|
|
UNREFERENCED_PARAMETER(iid);
|
|
UNREFERENCED_PARAMETER(p);
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
//
|
|
// OpenStore
|
|
// opens the RDP file, creating one if one doesn't exist
|
|
// The file existed it is parsed and readied for fast queries
|
|
//
|
|
// parameters:
|
|
// szStoreMoniker - path to file
|
|
// bReadyOnly - specifies if file is to be opened readonly
|
|
//
|
|
BOOL CRdpFileStore::OpenStore(LPCTSTR szStoreMoniker, BOOL bReadOnly)
|
|
{
|
|
DC_BEGIN_FN("OpenStore");
|
|
|
|
TRC_ASSERT(szStoreMoniker, (TB, _T("szStoreMoniker parameter is NULL")));
|
|
if(szStoreMoniker)
|
|
{
|
|
_fReadOnly = bReadOnly;
|
|
|
|
HRESULT hr = StringCchCopy(_szFileName, SIZECHAR(_szFileName), szStoreMoniker);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
memset(_szFileName, 0, sizeof(_szFileName));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Open the file, creating it if it doesn't exist
|
|
//
|
|
|
|
//
|
|
// First try to open existing for rw
|
|
//
|
|
if (ERR_SUCCESS == _fs.OpenForRead( (LPTSTR)szStoreMoniker))
|
|
{
|
|
_fOpenForRead = _fs.IsOpenForRead();
|
|
_fOpenForWrite = !bReadOnly;
|
|
}
|
|
else
|
|
{
|
|
TRC_DBG((TB, _T("OpenStore could not _tfopen: %s."),
|
|
szStoreMoniker));
|
|
return FALSE;
|
|
}
|
|
ParseFile();
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// CommitStore
|
|
// commits the in memory representation of the file to the store
|
|
// this overwrites any existing contents in the file.
|
|
//
|
|
// File MUST have been opened with OpenStore
|
|
//
|
|
BOOL CRdpFileStore::CommitStore()
|
|
{
|
|
DC_BEGIN_FN("CommitStore");
|
|
PRDPF_RECORD node = NULL;
|
|
TCHAR szBuf[LINEBUF_SIZE];
|
|
int ret;
|
|
|
|
if(_fOpenForWrite)
|
|
{
|
|
if(_fs.IsOpenForRead() || _fs.IsOpenForWrite())
|
|
{
|
|
_fs.Close();
|
|
}
|
|
//Reopen for write, nuking previous contents
|
|
//Open as binary to allow UNICODE output
|
|
if(ERR_SUCCESS == _fs.OpenForWrite(_szFileName, TRUE))
|
|
{
|
|
node = _pRecordListHead;
|
|
while(node)
|
|
{
|
|
if(RecordToString(node, szBuf, LINEBUF_SIZE))
|
|
{
|
|
ret = _fs.Write(szBuf);
|
|
if(ERR_SUCCESS != ret)
|
|
{
|
|
TRC_ABORT((TB,_T("Error writing to _fs: %d"),ret));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
node = node->pNext;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRC_ERR((TB,_T("OpenForWrite failed on file:%s"),_szFileName));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRC_ERR((TB,_T("Files was not opened for write:%s"),_szFileName));
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// CloseStore
|
|
// Closes the file, does NOT do a commit.
|
|
//
|
|
BOOL CRdpFileStore::CloseStore()
|
|
{
|
|
DC_BEGIN_FN("CloseStore");
|
|
if(_fs.IsOpenForRead() || _fs.IsOpenForWrite())
|
|
{
|
|
if(ERR_SUCCESS == _fs.Close())
|
|
{
|
|
_fReadOnly = FALSE;
|
|
_fOpenForRead = FALSE;
|
|
_fOpenForWrite = FALSE;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
DC_END_FN();
|
|
}
|
|
|
|
BOOL CRdpFileStore::IsOpenForRead()
|
|
{
|
|
return _fOpenForRead;
|
|
}
|
|
|
|
BOOL CRdpFileStore::IsOpenForWrite()
|
|
{
|
|
return _fOpenForWrite;
|
|
}
|
|
|
|
BOOL CRdpFileStore::IsDirty()
|
|
{
|
|
return _fIsDirty;
|
|
}
|
|
|
|
BOOL CRdpFileStore::SetDirtyFlag(BOOL bIsDirty)
|
|
{
|
|
_fIsDirty = bIsDirty;
|
|
return _fIsDirty;
|
|
}
|
|
|
|
//
|
|
// Typed read/write functions
|
|
//
|
|
BOOL CRdpFileStore::ReadString(LPCTSTR szName, LPTSTR szDefault,
|
|
LPTSTR szOutBuf, UINT strLen)
|
|
{
|
|
PRDPF_RECORD node = NULL;
|
|
HRESULT hr;
|
|
|
|
DC_BEGIN_FN("ReadString");
|
|
|
|
TRC_ASSERT(szName && szDefault && szOutBuf && strLen,
|
|
(TB,_T("Invalid params to ReadString")));
|
|
if(szName && szDefault && szOutBuf && strLen)
|
|
{
|
|
node = FindRecord(szName);
|
|
if(node && node->recType == RDPF_RECTYPE_SZ)
|
|
{
|
|
hr = StringCchCopy(szOutBuf, strLen, node->u.szVal);
|
|
if (SUCCEEDED(hr)) {
|
|
return TRUE;
|
|
} else {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Fill with default
|
|
hr = StringCchCopy(szOutBuf, strLen, szDefault);
|
|
if (SUCCEEDED(hr)) {
|
|
return TRUE;
|
|
} else {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Writes a string to the store
|
|
// params
|
|
// szName - key name
|
|
// szDefault - default value (if writing default settings gets deleted)
|
|
// szValue - value to write out
|
|
// fIgnoreDefault - if set then always write ignoring szDefault
|
|
//
|
|
BOOL CRdpFileStore::WriteString(LPCTSTR szName, LPTSTR szDefault, LPTSTR szValue,
|
|
BOOL fIgnoreDefault)
|
|
{
|
|
DC_BEGIN_FN("WriteString");
|
|
TRC_ASSERT(szName && szValue,
|
|
(TB,_T("Invalid params to WriteString")));
|
|
if(szName && szValue)
|
|
{
|
|
if(szDefault && !fIgnoreDefault && !_tcscmp(szDefault,szValue))
|
|
{
|
|
//
|
|
// Don't write out defaults
|
|
//
|
|
PRDPF_RECORD node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
return DeleteRecord(node);
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
BOOL bRet =
|
|
InsertRecord(szName, RDPF_RECTYPE_SZ, szValue);
|
|
return bRet;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
BOOL CRdpFileStore::ReadBinary(LPCTSTR szName, PBYTE pOutBuf, UINT cbBufLen)
|
|
{
|
|
PRDPF_RECORD node = NULL;
|
|
DC_BEGIN_FN("ReadBinary");
|
|
|
|
TRC_ASSERT(szName && pOutBuf && cbBufLen,
|
|
(TB,_T("Invalid params to ReadBinary")));
|
|
if(szName && pOutBuf && cbBufLen)
|
|
{
|
|
node = FindRecord(szName);
|
|
if(node && node->recType == RDPF_RECTYPE_BINARY)
|
|
{
|
|
if(node->dwBinValLen <= cbBufLen)
|
|
{
|
|
memcpy(pOutBuf, node->u.pBinVal, node->dwBinValLen);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRC_ERR((TB,_T("Insufficient space in outbuf buf")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
BOOL CRdpFileStore::WriteBinary(LPCTSTR szName,PBYTE pBuf, UINT cbBufLen)
|
|
{
|
|
DC_BEGIN_FN("WriteInt");
|
|
|
|
TRC_ASSERT(szName && pBuf,
|
|
(TB,_T("Invalid params to WriteBinary")));
|
|
|
|
if(!cbBufLen)
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
if(szName && pBuf)
|
|
{
|
|
BOOL bRet =
|
|
InsertBinaryRecord(szName, pBuf, (DWORD)cbBufLen);
|
|
return bRet;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
BOOL CRdpFileStore::ReadInt(LPCTSTR szName, UINT defaultVal, PUINT pval)
|
|
{
|
|
PRDPF_RECORD node = NULL;
|
|
DC_BEGIN_FN("ReadInt");
|
|
|
|
TRC_ASSERT(szName && pval,
|
|
(TB,_T("Invalid params to ReadInt")));
|
|
if(szName && pval)
|
|
{
|
|
node = FindRecord(szName);
|
|
if(node && node->recType == RDPF_RECTYPE_UINT)
|
|
{
|
|
*pval = node->u.iVal;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
*pval = defaultVal;
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Writes an int to the store
|
|
// params
|
|
// szName - key name
|
|
// defaultVal - default value (if writing default settings gets deleted)
|
|
// val - value to write out
|
|
// fIgnoreDefault - if set then always write ignoring szDefault
|
|
//
|
|
BOOL CRdpFileStore::WriteInt(LPCTSTR szName, UINT defaultVal, UINT val,
|
|
BOOL fIgnoreDefault)
|
|
{
|
|
DC_BEGIN_FN("WriteInt");
|
|
|
|
TRC_ASSERT(szName,
|
|
(TB,_T("Invalid params to WriteInt")));
|
|
if(szName)
|
|
{
|
|
if(!fIgnoreDefault && defaultVal == val)
|
|
{
|
|
//
|
|
// Don't write out default
|
|
//
|
|
PRDPF_RECORD node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
return DeleteRecord(node);
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
BOOL bRet =
|
|
InsertIntRecord(szName, val);
|
|
return bRet;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
BOOL CRdpFileStore::ReadBool(LPCTSTR szName, UINT defaultVal, PBOOL pbVal)
|
|
{
|
|
DC_BEGIN_FN("ReadBool");
|
|
UINT val;
|
|
TRC_ASSERT(szName && pbVal,
|
|
(TB,_T("Invalid params to ReadBool")));
|
|
if(szName && pbVal)
|
|
{
|
|
if(ReadInt(szName, defaultVal, &val))
|
|
{
|
|
*pbVal = (BOOL)val;
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Writes a bool to the store
|
|
// params
|
|
// szName - key name
|
|
// defaultVal - default value (if writing default settings gets deleted)
|
|
// bVal - value to write out
|
|
// fIgnoreDefault - if set then always write ignoring szDefault
|
|
//
|
|
BOOL CRdpFileStore::WriteBool(LPCTSTR szName, UINT defaultVal,BOOL bVal,
|
|
BOOL fIgnoreDefault)
|
|
{
|
|
DC_BEGIN_FN("WriteBool");
|
|
UINT iVal = bVal;
|
|
BOOL bRet =
|
|
WriteInt( szName, defaultVal, iVal, fIgnoreDefault);
|
|
return bRet;
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// ParseFile
|
|
// parses the _hFile into a reclist and associated namemap hash
|
|
//
|
|
BOOL CRdpFileStore::ParseFile()
|
|
{
|
|
DC_BEGIN_FN("ParseFile");
|
|
TRC_ASSERT(_fs.IsOpenForRead(), (TB,_T("Can't ParseFile on a closed FS")));
|
|
if(!_fs.IsOpenForRead())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Nuke any current in-memory state
|
|
//
|
|
DeleteRecords();
|
|
|
|
//
|
|
// Parse the file line by line into a RDPF_RECORD list
|
|
//
|
|
|
|
TCHAR szBuf[LINEBUF_SIZE];
|
|
while(ERR_SUCCESS == _fs.ReadNextLine(szBuf, sizeof(szBuf)))
|
|
{
|
|
if(!InsertRecordFromLine(szBuf))
|
|
{
|
|
TRC_DBG((TB,_T("Parse error, aborting file parse")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
_fs.Close();
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// InsertRecordFromLine
|
|
// parses szLine into a record and adds to the record list
|
|
//
|
|
BOOL CRdpFileStore::InsertRecordFromLine(LPTSTR szLine)
|
|
{
|
|
DC_BEGIN_FN("InsertRecordFromLine");
|
|
TCHAR szNameField[LINEBUF_SIZE];
|
|
UINT typeCode;
|
|
TCHAR szValueField[LINEBUF_SIZE];
|
|
BOOL fParseOk = FALSE;
|
|
|
|
memset(szNameField,0,sizeof(szNameField));
|
|
memset(szValueField,0,sizeof(szValueField));
|
|
fParseOk = ParseLine(szLine, &typeCode, szNameField, szValueField);
|
|
|
|
TRC_DBG((TB,_T("Parsed line into fields- name:'%s', value:'%s', typecode:'%d'"),
|
|
szNameField,
|
|
szValueField,
|
|
typeCode));
|
|
|
|
TRC_ASSERT(IS_VALID_RDPF_TYPECODE(typeCode),
|
|
(TB,_T("typeCode %d is invalid"), typeCode));
|
|
if(IS_VALID_RDPF_TYPECODE(typeCode))
|
|
{
|
|
//Create a new record for this line
|
|
//and insert it into the reclist
|
|
if(typeCode == RDPF_RECTYPE_UNPARSED)
|
|
{
|
|
//Unparsed line: Value is the whole line. Name ignored
|
|
HRESULT hr = StringCchCopy(szValueField, SIZECHAR(szValueField), szLine);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
}
|
|
//names are always lower case
|
|
if(InsertRecord(_tcslwr(szNameField), typeCode, szValueField))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Invalid typecode
|
|
//
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// ParseLine
|
|
// parses the lines into tokens, returns false
|
|
// if the line does not match the expected format
|
|
//
|
|
// params
|
|
// szLine - line to parse
|
|
// pTypeCode - [OUT] typecode
|
|
// szNameField - [OUT] name field. (must be at least LINEBUF_SIZE)
|
|
// szValueField - [OUT] value field. (must be at least LINEBUF_SIZE)
|
|
//
|
|
//
|
|
BOOL CRdpFileStore::ParseLine(LPTSTR szLine,
|
|
PUINT pTypeCode,
|
|
LPTSTR szNameField,
|
|
LPTSTR szValueField)
|
|
{
|
|
PTCHAR szWrite = NULL;
|
|
TCHAR szTypeCode;
|
|
INT writeCount = 0;
|
|
DC_BEGIN_FN("ParseLine");
|
|
|
|
//
|
|
// Try to parse the line, if unable to parse it return
|
|
// false.
|
|
//
|
|
// Format is "fieldname:szTypeCode:value"
|
|
// e.g "server:s:localhost"
|
|
//
|
|
// szTypeCodes are:
|
|
// s - string
|
|
// i - UINT
|
|
// b - binary blob (encoded)
|
|
//
|
|
TRC_ASSERT(szLine, (TB,_T("szLine is null")));
|
|
TRC_ASSERT(pTypeCode, (TB,_T("pTypeCode is null")));
|
|
TRC_ASSERT(szNameField, (TB,_T("szNameField is null")));
|
|
TRC_ASSERT(szValueField, (TB,_T("szValueField is null")));
|
|
if(szLine && pTypeCode && szNameField && szValueField)
|
|
{
|
|
//
|
|
// parse the whole line in one pass
|
|
// goto used on error case to avoid horrible nesting
|
|
//
|
|
PTCHAR sz = szLine;
|
|
while(*sz && *sz == TCHAR(' '))
|
|
sz++; //eat leading whitespace
|
|
|
|
if(!*sz)
|
|
{
|
|
goto parse_error;
|
|
}
|
|
//Copy field 1
|
|
PTCHAR szWrite = szNameField;
|
|
writeCount = 0;
|
|
while(*sz && *sz != TCHAR(':'))
|
|
{
|
|
*szWrite++ = *sz++;
|
|
if(++writeCount > LINEBUF_SIZE)
|
|
{
|
|
TRC_ERR((TB,_T("Field1 exceeds max size. size: %d"),
|
|
writeCount));
|
|
goto parse_error;
|
|
}
|
|
}
|
|
*szWrite = NULL;
|
|
|
|
if(*sz != TCHAR(':'))
|
|
{
|
|
goto parse_error;
|
|
sz++;
|
|
}
|
|
sz++; //eat ':'
|
|
while(*sz && *sz == TCHAR(' '))
|
|
sz++; //eat whitespace
|
|
if( *sz )
|
|
{
|
|
szTypeCode = isupper(*sz) ?
|
|
#ifndef OS_WINCE
|
|
_tolower(*sz++)
|
|
#else
|
|
towlower(*sz++)
|
|
#endif
|
|
: *sz++;
|
|
switch(szTypeCode)
|
|
{
|
|
case TCHAR('s'):
|
|
*pTypeCode = RDPF_RECTYPE_SZ;
|
|
break;
|
|
case TCHAR('i'):
|
|
*pTypeCode = RDPF_RECTYPE_UINT;
|
|
break;
|
|
case TCHAR('b'):
|
|
*pTypeCode = RDPF_RECTYPE_BINARY;
|
|
break;
|
|
default:
|
|
TRC_ERR((TB,_T("Invalid szTypeCode in szLine '%s'"), szLine));
|
|
*pTypeCode = RDPF_RECTYPE_UNPARSED;
|
|
goto parse_error;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRC_ERR((TB,_T("Invalid szTypeCode in szLine '%s'"), szLine));
|
|
goto parse_error;
|
|
}
|
|
while(*sz && *sz == TCHAR(' '))
|
|
sz++; //eat whitespace
|
|
if(*sz != TCHAR(':'))
|
|
{
|
|
goto parse_error;
|
|
}
|
|
sz++; //eat ':'
|
|
while(*sz && *sz == TCHAR(' '))
|
|
sz++; //eat leading whitespace
|
|
//rest of line is field3
|
|
szWrite = szValueField;
|
|
writeCount = 0;
|
|
while(*sz && *sz != TCHAR('\n'))
|
|
{
|
|
*szWrite++ = *sz++;
|
|
if(++writeCount > LINEBUF_SIZE)
|
|
{
|
|
TRC_ERR((TB,_T("Field1 exceeds max size. size: %d"),
|
|
writeCount));
|
|
goto parse_error;
|
|
}
|
|
}
|
|
*szWrite = NULL;
|
|
return TRUE;
|
|
}
|
|
|
|
parse_error:
|
|
TRC_ERR((TB,_T("Parse error in line")));
|
|
//Add an unknown record..it will be persisted back out to
|
|
//the file (it could be from a newer file version)
|
|
*pTypeCode = RDPF_RECTYPE_UNPARSED;
|
|
DC_END_FN();
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// InsertRecord
|
|
// inserts new record, modifies existing record
|
|
// if one exists with the same name field
|
|
//
|
|
BOOL CRdpFileStore::InsertRecord(LPCTSTR szName, UINT TypeCode, LPCTSTR szValue)
|
|
{
|
|
DC_BEGIN_FN("InsertRecord");
|
|
|
|
TRC_ASSERT(IS_VALID_RDPF_TYPECODE(TypeCode),
|
|
(TB,_T("typeCode %d is invalid"), TypeCode));
|
|
TRC_ASSERT(szName && szValue,
|
|
(TB,_T("Invalid szName or szValue")));
|
|
if(szName && szValue)
|
|
{
|
|
PRDPF_RECORD node;
|
|
node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
if(node->recType == TypeCode)
|
|
{
|
|
//
|
|
// Existing record found, modify it's contents
|
|
// first free any allocated memory in the current
|
|
// node.
|
|
//
|
|
switch(TypeCode)
|
|
{
|
|
case RDPF_RECTYPE_SZ:
|
|
{
|
|
if(node->u.szVal)
|
|
{
|
|
LocalFree(node->u.szVal);
|
|
}
|
|
}
|
|
break;
|
|
case RDPF_RECTYPE_BINARY:
|
|
{
|
|
if(node->u.pBinVal)
|
|
{
|
|
LocalFree(node->u.pBinVal);
|
|
}
|
|
}
|
|
break;
|
|
case RDPF_RECTYPE_UNPARSED:
|
|
{
|
|
if(node->u.szUnparsed)
|
|
{
|
|
LocalFree(node->u.szUnparsed);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Set the node value from the typecode
|
|
//
|
|
if(SetNodeValue(node, TypeCode, szValue))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// dup record of differing type
|
|
//
|
|
TRC_ASSERT(FALSE,(TB,_T("found duplicate record of differing type")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PRDPF_RECORD node = NewRecord(szName, TypeCode);
|
|
if(node)
|
|
{
|
|
if(SetNodeValue(node, TypeCode, szValue))
|
|
{
|
|
//Append the node to the end of the reclist
|
|
if(AppendRecord(node))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Sets node value based on a typecode
|
|
// this coaxes the value from the string form
|
|
//
|
|
// This function is the generic version that accepts the value as a string
|
|
// parameter. Automatic conversion are done to the appropriate type.
|
|
//
|
|
inline BOOL CRdpFileStore::SetNodeValue(PRDPF_RECORD pNode,
|
|
RDPF_RECTYPE TypeCode,
|
|
LPCTSTR szValue)
|
|
{
|
|
DC_BEGIN_FN("SetNodeValue");
|
|
|
|
TRC_ASSERT(pNode && szValue && IS_VALID_RDPF_TYPECODE(TypeCode),
|
|
(TB,_T("Invalid SetNodeValue params")));
|
|
if(pNode && szValue)
|
|
{
|
|
switch(TypeCode)
|
|
{
|
|
case RDPF_RECTYPE_UINT:
|
|
{
|
|
pNode->u.iVal = _ttol(szValue);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case RDPF_RECTYPE_SZ:
|
|
{
|
|
pNode->u.szVal = (LPTSTR)LocalAlloc(LPTR,
|
|
sizeof(TCHAR)*(_tcslen(szValue)+1));
|
|
if(pNode->u.szVal)
|
|
{
|
|
_tcscpy(pNode->u.szVal,szValue);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RDPF_RECTYPE_BINARY:
|
|
{
|
|
//Convert from string form to actual binary bits
|
|
UINT strLen = _tcslen(szValue);
|
|
DWORD dwLen = 0;
|
|
|
|
//
|
|
// First get the buffer length
|
|
// (binaryToString returns the wrong length when the
|
|
// null parameter is passed in).
|
|
dwLen = (strLen >> 1) + 2;
|
|
|
|
pNode->u.pBinVal = (PBYTE) LocalAlloc(LPTR, dwLen);
|
|
if(!pNode->u.pBinVal)
|
|
{
|
|
TRC_ERR((TB,_T("Failed to alloc %d bytes"), dwLen));
|
|
return FALSE;
|
|
}
|
|
memset(pNode->u.pBinVal,0,dwLen);
|
|
//
|
|
// Do the conversion
|
|
//
|
|
if(!CUT::BinarytoString( strLen, (LPTSTR)szValue,
|
|
(PBYTE)pNode->u.pBinVal, &dwLen))
|
|
{
|
|
TRC_ERR((TB,_T("BinaryToString conversion failed")));
|
|
return FALSE;
|
|
}
|
|
pNode->dwBinValLen = dwLen;
|
|
}
|
|
break;
|
|
|
|
case RDPF_RECTYPE_UNPARSED:
|
|
{
|
|
pNode->u.szUnparsed = (LPTSTR)LocalAlloc(LPTR,
|
|
sizeof(TCHAR)*(_tcslen(szValue)+1));
|
|
if(pNode->u.szUnparsed)
|
|
{
|
|
_tcscpy(pNode->u.szUnparsed,szValue);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
return FALSE;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Inserts an int record (RDPF_RECTYPE_UINT)
|
|
// modifies existing record if one is found
|
|
//
|
|
BOOL CRdpFileStore::InsertIntRecord(LPCTSTR szName, UINT value)
|
|
{
|
|
DC_BEGIN_FN("InsertIntRecord");
|
|
|
|
TRC_ASSERT(szName,
|
|
(TB,_T("Invalid szName")));
|
|
if(szName)
|
|
{
|
|
PRDPF_RECORD node;
|
|
node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
if(node->recType == RDPF_RECTYPE_UINT)
|
|
{
|
|
//
|
|
// Existing record found, modify it's contents
|
|
//
|
|
|
|
node->u.iVal = value;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// dup record of differing type
|
|
//
|
|
TRC_ASSERT(FALSE,(TB,_T("found duplicate record of differing type")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PRDPF_RECORD node = NewRecord(szName, RDPF_RECTYPE_UINT);
|
|
if(node)
|
|
{
|
|
node->u.iVal = value;
|
|
//Append the node to the end of the reclist
|
|
if(AppendRecord(node))
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Insert a binary buffer record (RDPF_RECTYPE_BINARY)
|
|
// modifies existing record if one found
|
|
//
|
|
BOOL CRdpFileStore::InsertBinaryRecord(LPCTSTR szName, PBYTE pBuf, DWORD dwLen)
|
|
{
|
|
DC_BEGIN_FN("InsertBinaryRecord");
|
|
|
|
TRC_ASSERT(szName && pBuf && dwLen,
|
|
(TB,_T("Invalid szName or pBuf")));
|
|
if(szName)
|
|
{
|
|
PRDPF_RECORD node;
|
|
node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
if(node->recType == RDPF_RECTYPE_BINARY)
|
|
{
|
|
//
|
|
// Existing record found, modify its contents
|
|
//
|
|
if(node->u.pBinVal)
|
|
{
|
|
LocalFree(node->u.pBinVal);
|
|
}
|
|
|
|
node->u.pBinVal = (PBYTE) LocalAlloc(LPTR, dwLen);
|
|
if(node->u.pBinVal)
|
|
{
|
|
memcpy(node->u.pBinVal, pBuf, dwLen);
|
|
node->dwBinValLen = dwLen;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// dup record of differing type
|
|
//
|
|
TRC_ASSERT(FALSE,(TB,_T("found duplicate record of differing type")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PRDPF_RECORD node = NewRecord(szName, RDPF_RECTYPE_BINARY);
|
|
if(node)
|
|
{
|
|
node->u.pBinVal = (PBYTE) LocalAlloc(LPTR, dwLen);
|
|
if(node->u.pBinVal)
|
|
{
|
|
memcpy(node->u.pBinVal, pBuf, dwLen);
|
|
node->dwBinValLen = dwLen;
|
|
if(AppendRecord(node))
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// A worker function to make life easier in RecordToString. This function
|
|
// takes a source string, cats it to a destination string, and then appends
|
|
// a carriage return and line-feed.
|
|
//
|
|
|
|
HRESULT StringCchCatCRLF(LPTSTR pszDest, size_t cchDest, LPCTSTR pszSrc)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
DC_BEGIN_FN("StringCchCatCRLF");
|
|
|
|
hr = StringCchCat(pszDest, cchDest, pszSrc);
|
|
if (FAILED(hr)) {
|
|
DC_QUIT;
|
|
}
|
|
hr = StringCchCat(pszDest, cchDest, _T("\r\n"));
|
|
if (FAILED(hr)) {
|
|
DC_QUIT;
|
|
}
|
|
|
|
DC_EXIT_POINT:
|
|
|
|
DC_END_FN();
|
|
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// Flatten a record to a string (szBuf) using format:
|
|
// name:type:value\r\n
|
|
//
|
|
BOOL CRdpFileStore::RecordToString(PRDPF_RECORD pNode, LPTSTR szBuf, UINT strLen)
|
|
{
|
|
DC_BEGIN_FN("RecordToString");
|
|
TRC_ASSERT(pNode && szBuf && strLen,
|
|
(TB,_T("Invalid parameters to RecordToString")));
|
|
TCHAR szTemp[LINEBUF_SIZE];
|
|
INT lenRemain = strLen;
|
|
HRESULT hr;
|
|
|
|
if(pNode && szBuf && strLen)
|
|
{
|
|
TRC_ASSERT(IS_VALID_RDPF_TYPECODE(pNode->recType),
|
|
(TB,_T("Invalid typecode %d"),pNode->recType));
|
|
|
|
if(pNode->recType != RDPF_RECTYPE_UNPARSED)
|
|
{
|
|
// Space for name field, typecode, two delimiters and a NULL.
|
|
lenRemain -= _tcslen(pNode->szName) + 4;
|
|
if(lenRemain >= 0)
|
|
{
|
|
hr = StringCchPrintf(szBuf, strLen, _T("%s%s"),
|
|
pNode->szName,
|
|
g_szTypeCodeMap[pNode->recType]);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String printf failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
|
|
switch(pNode->recType)
|
|
{
|
|
case RDPF_RECTYPE_UINT:
|
|
{
|
|
_stprintf(szTemp,TEXT("%d"),pNode->u.iVal);
|
|
// Need space for a "\r\n" sequence.
|
|
lenRemain -= _tcslen(szTemp) + 2;
|
|
if(lenRemain >= 0)
|
|
{
|
|
hr = StringCchCatCRLF(szBuf, strLen, szTemp);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String concatenation failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RDPF_RECTYPE_SZ:
|
|
{
|
|
// Need space for a "\r\n" sequence.
|
|
lenRemain -= _tcslen(pNode->u.szVal) + 2;
|
|
if(lenRemain >= 0)
|
|
{
|
|
hr = StringCchCatCRLF(szBuf, strLen, pNode->u.szVal);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String concatenation failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case RDPF_RECTYPE_BINARY:
|
|
{
|
|
DWORD dwLen;
|
|
//
|
|
// Convert the binary buffer to string form
|
|
//
|
|
|
|
//
|
|
// First get the buffer length
|
|
//
|
|
if(!CUT::StringtoBinary( pNode->dwBinValLen,
|
|
(PBYTE)pNode->u.pBinVal,
|
|
NULL, &dwLen))
|
|
{
|
|
TRC_ERR((TB,
|
|
_T("Failed to get StringtoBinary buffer len")));
|
|
return FALSE;
|
|
}
|
|
lenRemain -= dwLen;
|
|
if(lenRemain >= 0 && dwLen < LINEBUF_SIZE)
|
|
{
|
|
//
|
|
// Do the conversion
|
|
//
|
|
if(CUT::StringtoBinary( pNode->dwBinValLen,
|
|
(PBYTE)pNode->u.pBinVal,
|
|
(LPTSTR) szTemp, &dwLen))
|
|
{
|
|
//String to binary appends two trailing
|
|
//'0' characters. get rid of them.
|
|
szTemp[dwLen-2] = NULL;
|
|
|
|
hr = StringCchCatCRLF(szBuf, strLen, szTemp);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String concatenation failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
TRC_ERR((TB,_T("StringtoBinary conversion failed")));
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Unparsed record, just splat the value
|
|
hr = StringCchCopy(szBuf, strLen, pNode->u.szUnparsed);
|
|
if (SUCCEEDED(hr)) {
|
|
return TRUE;
|
|
} else {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Search the record list
|
|
// for the first record with the given name
|
|
//
|
|
PRDPF_RECORD CRdpFileStore::FindRecord(LPCTSTR szName)
|
|
{
|
|
DC_BEGIN_FN("FindRecord");
|
|
|
|
if(szName && _pRecordListHead)
|
|
{
|
|
TCHAR szCmpName[RDPF_NAME_LEN];
|
|
|
|
HRESULT hr = StringCchCopy(szCmpName, SIZECHAR(szCmpName), szName);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return NULL;
|
|
}
|
|
_tcslwr(szCmpName);
|
|
|
|
PRDPF_RECORD node = _pRecordListHead;
|
|
while(node)
|
|
{
|
|
if(!_tcscmp(szCmpName, node->szName))
|
|
{
|
|
return node;
|
|
}
|
|
node=node->pNext;
|
|
}
|
|
return NULL;
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Append record to the end of the record list
|
|
// for a record with the given name
|
|
//
|
|
BOOL CRdpFileStore::AppendRecord(PRDPF_RECORD node)
|
|
{
|
|
DC_BEGIN_FN("AppendRecord");
|
|
if(node)
|
|
{
|
|
node->pNext = NULL;
|
|
if(_pRecordListHead && _pRecordListTail)
|
|
{
|
|
node->pPrev = _pRecordListTail;
|
|
_pRecordListTail->pNext= node;
|
|
_pRecordListTail = node;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
_pRecordListHead = _pRecordListTail = node;
|
|
node->pPrev = NULL;
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Create a new record with name szName
|
|
//
|
|
PRDPF_RECORD CRdpFileStore::NewRecord(LPCTSTR szName, UINT TypeCode)
|
|
{
|
|
DC_BEGIN_FN("NewRecord");
|
|
PRDPF_RECORD node = NULL;
|
|
|
|
if(szName)
|
|
{
|
|
//Need to insert new node
|
|
node = (PRDPF_RECORD)LocalAlloc(LPTR,
|
|
sizeof(RDPF_RECORD));
|
|
if(node)
|
|
{
|
|
node->recType = TypeCode;
|
|
|
|
HRESULT hr = StringCchCopy(node->szName, SIZECHAR(node->szName), szName);
|
|
if (FAILED(hr)) {
|
|
TRC_ERR((TB, _T("String copy failed: hr = 0x%x"), hr));
|
|
return NULL;
|
|
}
|
|
_tcslwr(node->szName);
|
|
|
|
node->pPrev= node->pNext= NULL;
|
|
}
|
|
}
|
|
|
|
DC_END_FN();
|
|
return node;
|
|
}
|
|
|
|
//
|
|
// DeleteRecords
|
|
// deletes and resets all inmemory record structures
|
|
//
|
|
BOOL CRdpFileStore::DeleteRecords()
|
|
{
|
|
DC_BEGIN_FN("DeleteRecords");
|
|
PRDPF_RECORD node = _pRecordListHead;
|
|
PRDPF_RECORD prev;
|
|
while(node)
|
|
{
|
|
prev = node;
|
|
node = node->pNext;
|
|
|
|
switch(prev->recType)
|
|
{
|
|
case RDPF_RECTYPE_SZ:
|
|
LocalFree(prev->u.szVal);
|
|
break;
|
|
case RDPF_RECTYPE_BINARY:
|
|
LocalFree(prev->u.pBinVal);
|
|
break;
|
|
case RDPF_RECTYPE_UNPARSED:
|
|
LocalFree(prev->u.szUnparsed);
|
|
break;
|
|
}
|
|
LocalFree(prev);
|
|
}
|
|
_pRecordListHead = NULL;
|
|
_pRecordListTail = NULL;
|
|
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
inline BOOL CRdpFileStore::DeleteRecord(PRDPF_RECORD node)
|
|
{
|
|
DC_BEGIN_FN("DeleteRecord");
|
|
|
|
TRC_ASSERT(node,(TB,_T("node is null")));
|
|
|
|
if(node)
|
|
{
|
|
if(_pRecordListTail == node)
|
|
{
|
|
_pRecordListTail = node->pPrev;
|
|
}
|
|
if(_pRecordListHead == node)
|
|
{
|
|
_pRecordListHead = node->pNext;
|
|
}
|
|
|
|
if(node->pPrev)
|
|
{
|
|
node->pPrev->pNext = node->pNext;
|
|
}
|
|
if(node->pNext)
|
|
{
|
|
node->pNext->pPrev = node->pPrev;
|
|
}
|
|
|
|
switch(node->recType)
|
|
{
|
|
case RDPF_RECTYPE_SZ:
|
|
LocalFree(node->u.szVal);
|
|
break;
|
|
case RDPF_RECTYPE_BINARY:
|
|
LocalFree(node->u.pBinVal);
|
|
break;
|
|
case RDPF_RECTYPE_UNPARSED:
|
|
LocalFree(node->u.szUnparsed);
|
|
break;
|
|
}
|
|
LocalFree(node);
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL CRdpFileStore::DeleteValueIfPresent(LPCTSTR szName)
|
|
{
|
|
DC_BEGIN_FN("DeleteValueIfPresent");
|
|
TRC_ASSERT(szName,(TB,_T("szName is null")));
|
|
|
|
if(szName)
|
|
{
|
|
PRDPF_RECORD node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
return DeleteRecord(node);
|
|
}
|
|
else
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
//
|
|
// Initialize to a NULL store that is readable
|
|
//
|
|
BOOL CRdpFileStore::SetToNullStore()
|
|
{
|
|
DC_BEGIN_FN("SetToNullStore");
|
|
DeleteRecords();
|
|
_fOpenForRead = TRUE;
|
|
_fOpenForWrite = TRUE;
|
|
DC_END_FN();
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Return TRUE if the record is present
|
|
//
|
|
BOOL CRdpFileStore::IsValuePresent(LPTSTR szName)
|
|
{
|
|
DC_BEGIN_FN("IsValuePresent");
|
|
|
|
if(szName)
|
|
{
|
|
PRDPF_RECORD node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
DC_END_FN();
|
|
}
|
|
|
|
DWORD CRdpFileStore::GetDataLength(LPCTSTR szName)
|
|
{
|
|
if(szName)
|
|
{
|
|
PRDPF_RECORD node = FindRecord(szName);
|
|
if(node)
|
|
{
|
|
switch (node->recType)
|
|
{
|
|
case RDPF_RECTYPE_UINT:
|
|
return sizeof(UINT);
|
|
break;
|
|
case RDPF_RECTYPE_SZ:
|
|
return _tcslen(node->u.szVal) * sizeof(TCHAR);
|
|
break;
|
|
case RDPF_RECTYPE_BINARY:
|
|
return node->dwBinValLen;
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|