helper.cpp

usblsccid-0.9.2: ED1x Smart Card Reader Driver

// Helper.cpp: implementation of the Helper class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "scrtest.h"
#include "Helper.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

char Helper::hextable[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Helper::Helper()
{

}

Helper::~Helper()
{

}

LPSTR Helper::BinToHex(LPBYTE p, int len)
{
	LPSTR str = (LPSTR)malloc(len*3+1);
	LPSTR basestr = str;
	for(int i=0; i<len; i++)
	{
		TOHEX(p[i], str);
		*str++ = ' ';
	}
	*str = '\0';
	return basestr;
}

LPBYTE Helper::HexToBin(LPSTR s, int &len)
{
	LPBYTE pByte = (LPBYTE)malloc(len>>1);
	LPBYTE basepByte = pByte;
	int i=0;
	BYTE b;
	while(*s)
	{
		if(*s <= '9' && *s >= '0')
		{
			b = *s++ - '0';
			*pByte	= (*pByte << 4) | (b & 0xf);
			i++;
		}else if(*s <= 'f' && *s >= 'a'){
			b = *s++ - 'a' + 10 ;
			*pByte	= (*pByte << 4) | (b & 0xf);
			i++;
		}else if(*s <= 'F' && *s >= 'A'){
			b = *s++ - 'A' + 10;
			*pByte	= (*pByte << 4) | (b & 0xf);
			i++;
		}else 
			*s++;
		if(i==2)
		{
			pByte++;
			i = 0;
		}
	}
	if(i)
		pByte++;
	len = pByte - basepByte;
	if(len)
		return basepByte;
	else{
		free(basepByte);
		return NULL;
	}
}

void Helper::ShowLastError( DWORD dwMessageId)
{

	LPVOID lpMsgBuf;
	FormatMessage( 
		FORMAT_MESSAGE_ALLOCATE_BUFFER | 
		FORMAT_MESSAGE_FROM_SYSTEM | 
		FORMAT_MESSAGE_IGNORE_INSERTS,
		NULL,
		dwMessageId ? dwMessageId : GetLastError(),
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
		(LPTSTR) &lpMsgBuf,
		0,
		NULL 
		);
		// Process any inserts in lpMsgBuf.
		// ...
		// Display the string.
		CString str((LPCTSTR)lpMsgBuf);

	MessageBox( NULL, (LPCTSTR)lpMsgBuf, "Error", MB_OK | MB_ICONINFORMATION );
		// Free the buffer.
	LocalFree( lpMsgBuf );
}


IXMLDOMDocumentPtr Helper::loadXML(CString str)
{
	USES_CONVERSION;
	try
	{
		IXMLDOMDocumentPtr pDOMDoc(__uuidof(DOMDocument));
		pDOMDoc->put_async(VARIANT_FALSE);
		_bstr_t bstrURL = str;
		VARIANT_BOOL varResult = pDOMDoc->load(_variant_t(bstrURL));
		if (VARIANT_FALSE == varResult)
		{
					// Load failed
			IXMLDOMParseErrorPtr pParseError = pDOMDoc->GetparseError();
			long dwError = pParseError->GeterrorCode();
			_bstr_t bstrReason = pParseError->Getreason();
			CString strError;
			strError.Format(_T("XML Parse Error 0x%x : %s"), dwError, W2T(bstrReason));
			AfxMessageBox(strError);
			return NULL;
		}
#ifdef _DEBUG
		DumpXMLNode(pDOMDoc);
#endif
		return pDOMDoc;
	}
	catch(_com_error e)
	{
		TRACE(_T("Caught Exception: OnOpenFile"));
		AfxMessageBox(_T("Load Failure"));
	}
	catch(...)
	{
		TRACE(_T("Caught Exception: OnOpenFile"));
		AfxMessageBox(_T("Load Failure"));
	}
	return NULL;
}

#ifdef _DEBUG
HRESULT Helper::DumpXMLNode(IXMLDOMNodePtr pNode)
{
	if (NULL == pNode)
		return S_FALSE;

	try
	{
		DOMNodeType nodeType;
		pNode->get_nodeType(&nodeType);

		TRACE(_T("%s\n"),GetXMLNodeString(pNode));
		// Add item's attributes
		IXMLDOMNamedNodeMapPtr pAttrMap = pNode->Getattributes();
		if (pAttrMap != NULL)
		{
			IXMLDOMAttributePtr pAttribute;
			while(pAttribute = pAttrMap->nextNode())
				TRACE(_T("%s\n"),GetXMLNodeString(pAttribute));

		}

		// Recurse Children
		if (1)
		{
			IXMLDOMNodeListPtr pNodeList = pNode->GetchildNodes();
			if (pNodeList != NULL)
			{
				IXMLDOMNodePtr pChild;
				while(pChild = pNodeList->nextNode())
				{
					DumpXMLNode(pChild);
				}
			}
		}
	}
	catch(_com_error e)
	{
		TRACE(_T("Caught Exception: DumpXMLNode"));
	}
	catch(...)
	{
		TRACE(_T("Caught Exception: DumpXMLNode"));
		AfxMessageBox(_T("Error DumpXMLNode!"));
	}

	return S_OK;


}

CString Helper::GetXMLNodeString(IXMLDOMNodePtr pNode)
{
	USES_CONVERSION;

	DOMNodeType nodeType;
	pNode->get_nodeType(&nodeType);

	CString strTextToAdd;

	try
	{
		switch(nodeType)
		{
		case NODE_INVALID:
			strTextToAdd = _T("---");
			break;

		case NODE_ELEMENT:
			strTextToAdd = _T("NODE_ELEMENT\n");
			strTextToAdd += W2T(pNode->GetnodeName());
			break;

		case NODE_ATTRIBUTE:
			strTextToAdd.Format(_T("NODE_ATTRIBUTE\n%s = %s"), W2T(pNode->GetnodeName()), W2T(_bstr_t(pNode->GetnodeValue())));
			break;

		case NODE_TEXT:
			strTextToAdd = _T("NODE_TEXT\n");
			strTextToAdd += W2T(_bstr_t(pNode->GetnodeValue()));
			break;

		case NODE_CDATA_SECTION:
			strTextToAdd = _T("NODE_CDATA_SECTION\n");
			strTextToAdd += W2T(_bstr_t(pNode->GetnodeValue()));
			break;

		case NODE_ENTITY_REFERENCE:
			strTextToAdd = _T("NODE_ENTITY_REFERENCE\n");
			strTextToAdd += W2T(pNode->GetnodeName());
			break;

		case NODE_ENTITY:
			strTextToAdd = _T("NODE_ENTITY\n");
			strTextToAdd += W2T(pNode->GetnodeName());
			break;

		case NODE_PROCESSING_INSTRUCTION:
			strTextToAdd.Format(_T("NODE_PROCESSING_INSTRUCTION\n%s %s"), W2T(pNode->GetnodeName()), W2T(_bstr_t(pNode->GetnodeValue())));
			break;

		case NODE_COMMENT:
			strTextToAdd = _T("NODE_COMMENT\n");
			strTextToAdd += W2T(_bstr_t(pNode->GetnodeValue()));
			break;

		case NODE_DOCUMENT:
			strTextToAdd = _T("NODE_DOCUMENT\n");
			strTextToAdd += _T("Root Document Node");
			break;
		
		case NODE_DOCUMENT_TYPE:
			strTextToAdd = _T("NODE_DOCUMENT_TYPE\n");
			strTextToAdd += W2T(_bstr_t(pNode->GetnodeName()));
			break;

		case NODE_DOCUMENT_FRAGMENT:
			strTextToAdd = _T("NODE_DOCUMENT_FRAGMENT\n");
			strTextToAdd += _T("Root Node of Document Fragment");
			break;

		case NODE_NOTATION:
			strTextToAdd = _T("NODE_NOTATION\n");
			strTextToAdd += W2T(_bstr_t(pNode->GetnodeName()));
			break;
		
		default:
			ASSERT(_T("Invalid NODE TYPE!\n"));
		}
	}
	catch(...)
	{
		strTextToAdd = _T("<ERROR!!>");
	}

	return strTextToAdd;
}
#endif