|
|
#ifdef USE_STDAFX
#include "stdafx.h"
#else
#include <windows.h>
//#include <stdio.h>
#endif
#include <stdio.h>
#include <NtSecApi.h>
#include <comdef.h>
#include <io.h>
#include <winioctl.h>
#include <lm.h>
#include <Dsgetdc.h>
#include "mcsdmmsg.h"
#include "pwdfuncs.h"
#include "PWGen.hpp"
#include "UString.hpp"
using namespace _com_util;
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 9 DEC 2000 * * * * This function is responsible for enumerating all floppy drives* * on this server. * * * *********************************************************************/
//BEGIN EnumLocalDrives
_bstr_t EnumLocalDrives(){/* local constants */ const int ENTRY_SIZE = 4; // Drive letter, colon, backslash, NULL
/* local variables */ _bstr_t strDrives = L""; WCHAR sDriveList[MAX_PATH]; DWORD dwRes;
/* function body */ try { dwRes = GetLogicalDriveStrings(MAX_PATH, sDriveList); if (dwRes != 0) { LPWSTR pTmpBuf = sDriveList;
//check each one to see if it is a floppy drive
while (*pTmpBuf != NULL) { //check the type of this drive
UINT uiType = GetDriveType(pTmpBuf); if ((uiType == DRIVE_REMOVABLE) || (uiType == DRIVE_FIXED) || (uiType == DRIVE_CDROM) || (uiType == DRIVE_RAMDISK)) { strDrives += pTmpBuf; strDrives += L","; } pTmpBuf += ENTRY_SIZE; } //remove the trailing ','
WCHAR* pEnd = (WCHAR*)strDrives; pEnd[strDrives.length() - 1] = L'\0'; } else { _com_issue_error(HRESULT_FROM_WIN32(GetLastError())); } } catch (...) { throw; }
return strDrives;}//END EnumLocalDrives
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 9 DEC 2000 * * * * This function is responsible for saving binary data to a given* * file path on a floppy drive. * * * *********************************************************************/
//BEGIN StoreDataToFloppy
void StoreDataToFloppy(LPCWSTR sPath, _variant_t & varData){/* local variables */ FILE * floppyfile = NULL; LPBYTE pByte = NULL; HRESULT hr;
/* function body */ try { //check incoming parameters
if ((!sPath) || (varData.vt != (VT_ARRAY | VT_UI1)) || (!varData.parray)) { _com_issue_error(HRESULT_FROM_WIN32(E_INVALIDARG)); }
//open the file
floppyfile = _wfopen(sPath, L"wb"); if (!floppyfile) _com_issue_error(HRESULT_FROM_WIN32(CO_E_FAILEDTOCREATEFILE));
//get the array size
long uLBound, uUBound; size_t uSLength; hr = SafeArrayGetLBound(varData.parray, 1, &uLBound); if (FAILED(hr)) _com_issue_error(hr); hr = SafeArrayGetUBound(varData.parray, 1, &uUBound); if (FAILED(hr)) _com_issue_error(hr); uSLength = size_t(uUBound - uLBound + 1); //write the data to the file
hr = SafeArrayAccessData(varData.parray,(void**)&pByte); if (FAILED(hr)) _com_issue_error(hr); if (fwrite((void *)pByte, 1, uSLength, floppyfile) != uSLength) _com_issue_error(HRESULT_FROM_WIN32(ERROR_WRITE_FAULT)); hr = SafeArrayUnaccessData(varData.parray); if (FAILED(hr)) _com_issue_error(hr);
//close the file
if (floppyfile) fclose(floppyfile); } catch (...) { if (floppyfile) fclose(floppyfile); throw; }}//END StoreDataToFloppy
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 9 DEC 2000 * * * * This function is responsible for retrieving binary data from a* * given file path on a floppy drive. The _variant_t variable * * returned is of the type VT_UI1 | VT_ARRAY upoin success or * * VT_EMPTY upon a failure. * * * *********************************************************************/
//BEGIN GetDataFromFloppy
_variant_t GetDataFromFloppy(LPCWSTR sPath){/* local variables */ FILE * floppyfile = NULL; LPBYTE pByte = NULL; HRESULT hr; _variant_t varData; SAFEARRAY * pSa = NULL; SAFEARRAYBOUND bd;
/* function body */ try { //check incoming parameters
if (!sPath) _com_issue_error(HRESULT_FROM_WIN32(E_INVALIDARG));
//path must have the '\' escaped
// _bstr_t sFile = EscapeThePath(sPath);
//open the file
floppyfile = _wfopen(sPath, L"rb"); if (!floppyfile) _com_issue_error(HRESULT_FROM_WIN32(ERROR_TOO_MANY_OPEN_FILES));
//get the number of bytes in the file
long fileLen = _filelength(_fileno(floppyfile)); if (fileLen == -1) _com_issue_error(HRESULT_FROM_WIN32(ERROR_READ_FAULT)); bd.cElements = fileLen; bd.lLbound = 0;
//read the data from the file one byte at a time
pSa = SafeArrayCreate(VT_UI1, 1, &bd); if (!pSa) _com_issue_error(E_FAIL); hr = SafeArrayAccessData(pSa,(void**)&pByte); if (FAILED(hr)) _com_issue_error(hr); long nTotalRead = 0; while(!feof(floppyfile) && !ferror(floppyfile)) { if (fread((void *)(pByte+nTotalRead), 1, 1, floppyfile) == 1) nTotalRead++; }
if (ferror(floppyfile)) { _com_issue_error(HRESULT_FROM_WIN32(ERROR_READ_FAULT)); }
hr = SafeArrayUnaccessData(pSa); if (FAILED(hr)) _com_issue_error(hr);
//close the file
if (floppyfile) { fclose(floppyfile); floppyfile = NULL; }
if (nTotalRead != fileLen) _com_issue_error(HRESULT_FROM_WIN32(ERROR_READ_FAULT));
varData.vt = VT_UI1 | VT_ARRAY; if (FAILED(SafeArrayCopy(pSa, &varData.parray))) _com_issue_error(hr); if (FAILED(SafeArrayDestroy(pSa))) _com_issue_error(hr); } catch (...) { if (floppyfile) fclose(floppyfile); throw; }
return varData;}//END GetDataFromFloppy
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 15 DEC 2000 * * * * This function is convert a _variant_t parameter of the type * * VT_ARRAY | VT_UI1 and returns it in a char array. The caller must* * free the array with the delete [] call. This function return NULL* * if the data was not placed in the array. * * * *********************************************************************/
//BEGIN GetBinaryArrayFromVariant
char* GetBinaryArrayFromVariant(_variant_t varData){/* local variables */ LPBYTE pByte = NULL; HRESULT hr; char * cArray; int i;
/* function body */ //check incoming parameters
if ((varData.vt != (VT_ARRAY | VT_UI1)) || (!varData.parray)) return NULL;
//get the array size
long uLBound, uUBound, uSLength; hr = SafeArrayGetLBound(varData.parray, 1, &uLBound); if (FAILED(hr)) return NULL; hr = SafeArrayGetUBound(varData.parray, 1, &uUBound); if (FAILED(hr)) return NULL; uSLength = uUBound - uLBound + 1;
//create an array to hold all this data
cArray = new char[uSLength+1]; if (!cArray) return NULL; //write the data to the file
hr = SafeArrayAccessData(varData.parray,(void**)&pByte); if (FAILED(hr)) { delete [] cArray; return NULL; } for (i=0; i<uSLength; i++) { cArray[i] = pByte[i]; } cArray[i] = L'\0'; hr = SafeArrayUnaccessData(varData.parray); if (FAILED(hr)) { delete [] cArray; return NULL; }
return cArray;}//END GetBinaryArrayFromVariant
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 15 DEC 2000 * * * * This function is convert a char array of binary data to a * * _variant_t of the type VT_ARRAY | VT_UI1 and returns it. * * * *********************************************************************/
//BEGIN SetVariantWithBinaryArray
_variant_t SetVariantWithBinaryArray(char * aData, DWORD dwArray){/* local variables */ LPBYTE pByte = NULL; HRESULT hr; _variant_t varData; SAFEARRAY * pSa = NULL; SAFEARRAYBOUND bd; DWORD i;
/* function body */ //check incoming parameters
if (!aData) return varData;
bd.cElements = dwArray; bd.lLbound = 0;
//read the data from the file one byte at a time
pSa = SafeArrayCreate(VT_UI1, 1, &bd); if (!pSa) return varData; hr = SafeArrayAccessData(pSa,(void**)&pByte); if (FAILED(hr)) return varData; for (i=0; i<dwArray; i++) { pByte[i] = aData[i]; } hr = SafeArrayUnaccessData(pSa); if (FAILED(hr)) return varData;
varData.vt = VT_UI1 | VT_ARRAY; if (FAILED(SafeArrayCopy(pSa, &varData.parray))) { varData.Clear(); return varData; } SafeArrayDestroy(pSa);
return varData;}//END SetVariantWithBinaryArray
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 15 DEC 2000 * * * * This function is returns the size, in bytes, of the given * * variant array. * * * *********************************************************************/
//BEGIN GetVariantArraySize
DWORD GetVariantArraySize(_variant_t & varData){/* local variables */ HRESULT hr; DWORD uSLength = 0; long uLBound, uUBound;
/* function body */ //check incoming parameters
if ((varData.vt != (VT_ARRAY | VT_UI1)) || (!varData.parray)) return uSLength;
//get the array size
hr = SafeArrayGetLBound(varData.parray, 1, &uLBound); if (FAILED(hr)) return uSLength; hr = SafeArrayGetUBound(varData.parray, 1, &uUBound); if (FAILED(hr)) return uSLength; uSLength = DWORD(uUBound - uLBound + 1);
return uSLength;}//END GetVariantArraySize
/*********************************************************************
* * * Written by: Paul Thompson * * Date: 15 DEC 2000 * * * * This function is returns the size, in bytes, of the given * * variant array. * * * *********************************************************************/
//BEGIN PrintVariant
void PrintVariant(const _variant_t & varData){/* local variables */ HRESULT hr; LPBYTE pByte = NULL; long i; WCHAR sData[MAX_PATH] = L"";
/* function body */ //check incoming parameters
if ((varData.vt != (VT_ARRAY | VT_UI1)) || (!varData.parray)) return;
//get the array size
long uLBound, uUBound, uSLength; hr = SafeArrayGetLBound(varData.parray, 1, &uLBound); if (FAILED(hr)) return; hr = SafeArrayGetUBound(varData.parray, 1, &uUBound); if (FAILED(hr)) return; uSLength = uUBound - uLBound + 1;
//write the data to the file
hr = SafeArrayAccessData(varData.parray,(void**)&pByte); if (FAILED(hr)) return; FILE * myfile; myfile = _wfopen(L"c:\\CryptCheck.txt", L"a+"); if (myfile == NULL) { SafeArrayUnaccessData(varData.parray); return; } for (i=0; i<uSLength; i++) { fwprintf(myfile, L"%x ", pByte[i]); } hr = SafeArrayUnaccessData(varData.parray); if (FAILED(hr)) return;
fwprintf(myfile, L"\n"); fclose(myfile);
return;}//END PrintVariant
|
