pril 1 (663671), страница 5

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 5)

else if (vt == VT_I4)

WriteVariable(file, buffer.lVal, VT_I4);

else if (vt == VT_R4)

WriteVariable(file, buffer.fltVal, VT_R4);

else if (vt == VT_R8)

WriteVariable(file, buffer.dblVal, VT_R8);

else if (vt == VT_BOOL)

WriteVariable(file, buffer.boolVal, VT_BOOL);

else if (vt == VT_ERROR)

WriteVariable(file, buffer.scode, VT_ERROR);

else if (vt == VT_CY)

WriteVariable(file, buffer.cyVal, VT_CY);

else if (vt == VT_DATE)

WriteVariable(file, buffer.date, VT_DATE);

else if (vt == VT_I1)

WriteVariable(file, buffer.cVal, VT_I1);

else if (vt == VT_UI2)

WriteVariable(file, buffer.uiVal, VT_UI2);

else if (vt == VT_UI4)

WriteVariable(file, buffer.ulVal, VT_UI4);

else if (vt == VT_INT)

WriteVariable(file, buffer.intVal, VT_INT);

else if (vt == VT_UINT)

WriteVariable(file, buffer.uintVal, VT_UINT);

else if (vt == VT_BSTR)

{

file.Write(&vt, sizeof(VARTYPE));

CComBSTR str(buffer.bstrVal);

unsigned len = str.Length();

file.Write(&len, sizeof(unsigned));

file.Write(static_cast(str), len * sizeof(OLECHAR));

}

else

CkgExcept(_T("Ошибка записи в файл. (VARIANT данного типа не поддерживается)"));

}

else if (vt & VT_ARRAY)

{

if (vt & VT_BSTR)

CkgExcept(ERROR_INVALID_ARGUMENT);

SAFEARRAY &safeArray = *buffer.parray;

if (safeArray.fFeatures == FADF_RECORD ||

safeArray.fFeatures == FADF_HAVEIID ||

safeArray.fFeatures == FADF_BSTR ||

safeArray.fFeatures == FADF_UNKNOWN ||

safeArray.fFeatures == FADF_DISPATCH ||

safeArray.fFeatures == FADF_VARIANT ||

safeArray.cDims > maxDimDimensions)

CkgExcept(_T("Ошибка записи в файл. (VARIANT с массивом данного типа не поддерживается)"));

file.Write(&vt, sizeof(VARTYPE));

file.Write(&safeArray.cDims, sizeof(safeArray.cDims));

file.Write(&safeArray.cbElements, sizeof(safeArray.cbElements));

file.Write(&safeArray.fFeatures, sizeof(safeArray.fFeatures));

const SAFEARRAYBOUND *bound = safeArray.rgsabound;

unsigned size = 0;

for (unsigned i = 0; i < safeArray.cDims; i++)

{

const long &Lbound = bound[i].lLbound;

const unsigned &cElements = bound[i].cElements;

file.Write(&Lbound, sizeof(Lbound));

file.Write(&cElements, sizeof(cElements));

if (!cElements)

CkgExcept(ERROR_INVALID_ARGUMENT);

size += cElements;

}

if (size == 0)

CkgExcept(ERROR_INVALID_ARGUMENT);

size *= safeArray.cbElements;

file.Write(safeArray.pvData, size);

}

else

CkgExcept(_T("Ошибка записи в файл. (VARIANT данного типа не поддерживается)"));

_ASSERT(file.GetPosition() - oldSize);

*written = file.GetPosition() - oldSize;

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::WriteString(short handle, BSTR buffer, long *written)

{

WriteToLog(_T("CProtect::WriteString()"));

try

{

int index = handles.IndexOf(handle);

if (index == -1)

CkgExcept(_T("Ошибка записи в файл. (Неверный дескриптор.)"));

ObjectFile &file = files[index];

unsigned oldSize = file.GetPosition();

CComBSTR str(buffer);

unsigned len = str.Length();

file.Write(&len, sizeof(unsigned));

file.Write(buffer, len * sizeof(OLECHAR));

_ASSERT(file.GetPosition() - oldSize);

*written = file.GetPosition() - oldSize;

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

template

T ReadVariable(ObjectFile &file)

{

T tmp;

file.Read(&tmp, sizeof(T));

return tmp;

}

STDMETHODIMP CProtect::Read(short handle, VARIANT *buffer, long *read)

{

WriteToLog(_T("CProtect::Read()"));

try

{

int index = handles.IndexOf(handle);

if (index == -1)

CkgExcept(_T("Ошибка чтения из файла. (Неверный дескриптор.)"));

ObjectFile &file = files[index];

unsigned oldSize = file.GetPosition();

CComVariant var;

VARTYPE vt = 0;

file.Read(&vt, sizeof(vt));

if (!(vt & VT_BYREF) && !(vt & VT_ARRAY))

{

if (vt == VT_UI1)

var = ReadVariable(file);

else if (vt == VT_I2)

var = ReadVariable(file);

else if (vt == VT_I4)

var = ReadVariable(file);

else if (vt == VT_R4)

var = ReadVariable(file);

else if (vt == VT_R8)

var = ReadVariable(file);

else if (vt == VT_BOOL)

var = ReadVariable(file);

else if (vt == VT_ERROR)

var = ReadVariable(file);

else if (vt == VT_CY)

var = ReadVariable(file);

else if (vt == VT_DATE)

var = ReadVariable(file);

else if (vt == VT_I1)

var = ReadVariable(file);

else if (vt == VT_UI2)

var = ReadVariable(file);

else if (vt == VT_UI4)

var = ReadVariable(file);

else if (vt == VT_INT)

var = ReadVariable(file);

else if (vt == VT_UINT)

var = ReadVariable(file);

else if (vt == VT_BSTR)

{

unsigned len = 0;

file.Read(&len, sizeof(len));

CComBSTR str(len);

file.Read(static_cast(str), len * sizeof(OLECHAR));

var = str;

}

else

CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));

*buffer = var;

}

else if (vt & VT_ARRAY)

{

CComVariant tmp;

memset(&tmp, 0, sizeof(tmp));

VariantInit(&tmp);

tmp.vt = vt;

struct {

SAFEARRAY safeArray;

SAFEARRAYBOUND buf[maxDimDimensions];

} trueSafeArr;

SAFEARRAY &safeArray = trueSafeArr.safeArray;

memset(&safeArray, 0, sizeof(safeArray));

tmp.parray = &safeArray;

file.Read(&safeArray.cDims, sizeof(safeArray.cDims));

file.Read(&safeArray.cbElements, sizeof(safeArray.cbElements));

file.Read(&safeArray.fFeatures, sizeof(safeArray.fFeatures));

_ASSERT(safeArray.cDims && safeArray.cbElements);

unsigned size = 0;

_ASSERT(safeArray.cDims <= maxDimDimensions);

for (unsigned i = 0; i < safeArray.cDims; i ++)

{

long &Lbound = safeArray.rgsabound[i].lLbound;

ULONG &cElements = safeArray.rgsabound[i].cElements;

file.Read(&Lbound, sizeof(Lbound));

file.Read(&cElements, sizeof(cElements));

size += cElements;

}

size *= safeArray.cbElements;

if (!size)

CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));

cpp_arr_ptr data(new BYTE[size]);

TestPtr(data);

file.Read(data, size);

safeArray.pvData = data;

HRESULT hr = var.Copy(&tmp);

if (FAILED(hr))

CkgExceptHresult(hr);

if (FAILED(var.Detach(buffer)))

CkgExcept();

}

else

CkgExcept(_T("Ошибка чтения из файла. (Возможно файл поврежден или имеет несовместимый формат)"));

_ASSERT(file.GetPosition() - oldSize);

*read = file.GetPosition() - oldSize;

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::ReadString(short handle, BSTR *buffer, long *read)

{

WriteToLog(_T("CProtect::ReadString()"));

try

{

int index = handles.IndexOf(handle);

if (index == -1)

CkgExcept(_T("Ошибка чтения из файла. (Неверный дескриптор.)"));

ObjectFile &file = files[index];

unsigned oldSize = file.GetPosition();

unsigned len = 0;

file.Read(&len, sizeof(len));

CComBSTR str(len);

file.Read(static_cast(str), len * sizeof(OLECHAR));

*buffer = str.Copy();

_ASSERT(file.GetPosition() - oldSize);

*read = file.GetPosition() - oldSize;

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::CreateConformityFile(BSTR name, BSTR uptFileNameForRead,

BSTR uptFileNameForWrite,

BSTR ArrayOfStrings)

{

WriteToLog(_T("CProtect::Create()"));

try

{

HRESULT Result;

Result = GenerateUPTfiles(uptFileNameForWrite, uptFileNameForRead);

if (FAILED(Result))

return Result;

short handle;

Result = Create(name, DEFAULT, uptFileNameForWrite, &handle);

if (FAILED(Result))

return Result;

long tmp;

Result = WriteString(handle, ArrayOfStrings, &tmp);

Close(handle);

return Result;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::EasyCreateConformityFile(BSTR name, BSTR uptFileNameForCreate,

BSTR ArrayOfStrings)

{

WriteToLog(_T("CProtect::EasyCreate()"));

try

{

HRESULT Result;

short handle;

Result = Create(name, DEFAULT, uptFileNameForCreate, &handle);

if (FAILED(Result))

return Result;

long tmp;

Result = WriteString(handle, ArrayOfStrings, &tmp);

Close(handle);

return Result;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::ReadConformityFile(BSTR name, BSTR uptFileNameForRead,

BSTR *ArrayOfStrings)

{

WriteToLog(_T("CProtect::Read()"));

try

{

HRESULT Result;

short handle;

Result = Open(name, uptFileNameForRead, NULL, &handle);

if (FAILED(Result))

return Result;

long tmp;

Result = ReadString(handle, ArrayOfStrings, &tmp);

Close(handle);

return Result;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

HRESULT CProtect::InternalGetAlgName(const CkgString &Strings,

CkgString SearchName,

CkgString &Result)

{

if (Strings.IsEmpty() || SearchName.IsEmpty())

CkgExcept(ERROR_INVALID_ARGUMENT);

if (SearchName[0u] != CkgText('"'))

{

SearchName.Insert(CkgText('"'), 0);

SearchName = SearchName + CkgText('"');

}

Result = CkgText("");

const CkgChar *p = CkgStrStr(Strings, SearchName);

if (!p)

return S_FALSE;

p += SearchName.GetLength();

const CkgChar *Start = CkgStrChr(p, CkgText('"'));

if (!Start)

return S_FALSE;

Start++;

const CkgChar *End = CkgStrChr(Start, CkgText('"'));

return S_FALSE;

CkgString tmp(Start, End - Start);

Result = tmp;

return S_OK;

}

HRESULT CProtect::InternalGetDataName(const CkgString &Strings,

CkgString SearchName,

CkgString &Result)

{

if (Strings.IsEmpty() || SearchName.IsEmpty())

CkgExcept(ERROR_INVALID_ARGUMENT);

if (SearchName[0u] != CkgText('"'))

{

SearchName.Insert(CkgText('"'), 0);

SearchName = SearchName + CkgText('"');

}

const CkgChar *p = CkgStrStr(Strings, SearchName);

if (!p)

{

Result = CkgText("");

return S_FALSE;

}

unsigned Len = p - Strings;

if (!Len)

CkgExcept(ERROR_INVALID_DATA);

p--;

const CkgChar *End = CkgStrChrBk(p, CkgText('"'), Strings);

if (!End)

CkgExcept(ERROR_INVALID_DATA);

End--;

const CkgChar *Start = CkgStrChrBk(End, CkgText('"'), Strings);

if (!Start)

CkgExcept(ERROR_INVALID_DATA);

Start++;

CkgString tmp(Start, End - Start + 1);

Result = tmp;

return S_OK;

}

STDMETHODIMP CProtect::GetAlgName(BSTR Strings, BSTR SearchName,

BSTR *ResultStr)

{

WriteToLog(_T("CProtect::GetAlgName()"));

try

{

USES_CONVERSION;

CkgString Buf(W2T(Strings));

CkgString Name(W2T(SearchName));

CkgString Result;

Buf.MakeLower();

Name.MakeLower();

HRESULT Res = InternalGetAlgName(Buf, Name, Result);

CComBSTR bstr;

bstr = T2W(Result);

*ResultStr = bstr.Copy();

return Res;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::GetDataName(BSTR Strings, BSTR SearchName, BSTR *ResultStr)

{

WriteToLog(_T("CProtect::GetDataName()"));

try

{

USES_CONVERSION;

CkgString Buf(W2T(Strings));

CkgString Name(W2T(SearchName));

CkgString Result;

Buf.MakeLower();

Name.MakeLower();

HRESULT Res = InternalGetDataName(Buf, Name, Result);

CComBSTR bstr;

bstr = T2W(Result);

*ResultStr = bstr.Copy();

return Res;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::GetAlgFromFile(BSTR FileName, BSTR uptFileNameForRead,

BSTR SearchName, BSTR *ResultStr)

{

WriteToLog(_T("CProtect::GetAlgFromFile()"));

try

{

HRESULT Result;

CComBSTR SmartPtr;

BSTR ArrayOfString;

Result = ReadConformityFile(FileName, uptFileNameForRead, &ArrayOfString);

if (FAILED(Result))

return Result;

SmartPtr.Attach(ArrayOfString);

return GetAlgName(SmartPtr, SearchName, ResultStr);

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::GetDataFromFile(BSTR FileName, BSTR uptFileNameForRead, /*[in]*/ BSTR SearchName, BSTR *ResultStr)

{

WriteToLog(_T("CProtect::GetDataFromFile()"));

try

{

HRESULT Result;

CComBSTR SmartPtr;

BSTR ArrayOfString;

Result = ReadConformityFile(FileName, uptFileNameForRead, &ArrayOfString);

if (FAILED(Result))

return Result;

SmartPtr.Attach(ArrayOfString);

return GetDataName(SmartPtr, SearchName, ResultStr);

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::FromFile(short handle, BSTR FileName, long *read)

{

WriteToLog(_T("CProtect::FromFile()"));

try

{

int index = handles.IndexOf(handle);

if (index == -1)

CkgExcept(_T("Ошибка записи в файл. (Неверный дескриптор.)"));

ObjectFile &file = files[index];

USES_CONVERSION;

CkgString Name(W2T(FileName));

DWORD Len;

FILE *f = _tfopen(Name, _T("rb"));

if (!f)

CkgExcept(ERROR_OPEN_FILE);

if (fseek(f, 0, SEEK_END))

CkgExcept(ERROR_READ_FILE);

Len = ftell(f);

if (fseek(f, 0, SEEK_SET))

CkgExcept(ERROR_READ_FILE);

pure_c_ptr Buf((char *)malloc(Len));

TestPtr(Buf);

if (fread(Buf, sizeof(char), Len, f) != Len)

CkgExcept(ERROR_READ_FILE);

fclose(f);

file.Write(&Len, sizeof(Len));

file.Write(Buf, Len);

*read = Len + sizeof(Buf);

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

STDMETHODIMP CProtect::ToFile(short handle, BSTR FileName, long *written)

{

WriteToLog(_T("CProtect::ToFile()"));

try

{

int index = handles.IndexOf(handle);

if (index == -1)

CkgExcept(_T("Ошибка записи в файл. (Неверный дескриптор.)"));

ObjectFile &file = files[index];

DWORD Len;

file.Read(&Len, sizeof(Len));

pure_c_ptr Buf((char *)malloc(Len));

TestPtr(Buf);

file.Read(Buf, Len);

USES_CONVERSION;

CkgString Name(W2T(FileName));

FILE *f = _tfopen(Name, _T("wb"));

if (!f)

CkgExcept(ERROR_CREATE_FILE);

if (fwrite(Buf, sizeof(char), Len, f) != Len)

CkgExcept(ERROR_WRITE_FILE);

fclose(f);

*written = Len + sizeof(Buf);

return S_OK;

}

CONVERT_EXCEPTION_TO_COM_EXCEPTION

}

Файл Uniprot.idl.

// Uniprot.idl : IDL source for Uniprot.dll

//

// This file will be processed by the MIDL tool to

// produce the type library (Uniprot.tlb) and marshalling code.

import "oaidl.idl";

import "ocidl.idl";

typedef

[uuid(60B14ABC-035B-43f4-B1D0-B2A29A1BC02C), v1_enum]

enum CreateMode

{

DEFAULT = 0,

DISABLE_ARC = 1

} CreateMode;

[

object,

uuid(0BF8C246-389C-42FF-845F-198C5550BCED),

dual, oleautomation,

helpstring("IProtect Interface"),

pointer_default(unique)

]

interface IProtect : IDispatch

{

[id(1), helpstring("method GetInfo")] HRESULT GetInfo([out] short *version, [out] BSTR *info);

[id(2), helpstring("method Generate UPT files")] HRESULT GenerateUPTfiles([in] BSTR algorithmCryptFileName, [in] BSTR algorithmDecryptFileName);

[id(3), helpstring("method Generate Time Limit UPT files")] HRESULT GenerateTimeLimitUPTfiles([in] BSTR algorithmCryptFileName, [in] BSTR algorithmDecryptFileName, [in] long LimitDays);

[id(4), helpstring("method Generate Time Limit UPT files")] HRESULT GenerateTimeLimitUPTfiles2([in] BSTR algorithmCryptFileName, [in] BSTR algorithmDecryptFileName, [in] long LimitDaysCrypt, [in] long LimitDaysDecrypt);

};

[

object,

uuid(1F3ADD8E-45DE-44e7-8953-CD7CC302154A),

dual, oleautomation,

helpstring("IProtectFile Interface"),

pointer_default(unique)

]

interface IProtectFile : IDispatch

{

[id(1), helpstring("method Create New File")] HRESULT Create([in] BSTR name, [in] CreateMode mode, [in] BSTR uptFileNameForWrite, [out, retval] short *handle);

[id(2), helpstring("method Open File")] HRESULT Open([in] BSTR name, [in] BSTR uptFileNameForRead, [in] BSTR uptFileNameForWrite, [out, retval] short *handle);

[id(3), helpstring("method Close File")] HRESULT Close([in] short handle);

[id(4), helpstring("method Write To File")] HRESULT Write([in] short handle, [in] VARIANT buffer, [out, retval] long *written);

[id(5), helpstring("method Read From File")] HRESULT Read([in] short handle, [out] VARIANT *buffer, [out, retval] long *read);

[id(6), helpstring("method Write String To File")] HRESULT WriteString([in] short handle, [in] BSTR buffer, [out, retval] long *written);

[id(7), helpstring("method Read String From File")] HRESULT ReadString([in] short handle, [out] BSTR *buffer, [out, retval] long *read);

[id(8), helpstring("method From File")] HRESULT FromFile([in] short handle, [in] BSTR FileName, [out, retval] long *read);

[id(9), helpstring("method To File")] HRESULT ToFile([in] short handle, [in] BSTR FileName, [out, retval] long *written);

};

[

object,

uuid(FEB052E7-05D5-4a38-A40B-D5895DE69F87),

dual, oleautomation,

helpstring("IProtectConformity Interface"),

pointer_default(unique)

]

interface IProtectConformity : IDispatch

{

[id(1), helpstring("method Create Conformity File")] HRESULT CreateConformityFile([in] BSTR name, [in] BSTR uptFileNameForRead, [in] BSTR uptFileNameForWrite, [in] BSTR ArrayOfStrings);

[id(2), helpstring("method Easy Create Conformity File")] HRESULT EasyCreateConformityFile([in] BSTR name, [in] BSTR uptFileNameForCreate, [in] BSTR ArrayOfStrings);

[id(3), helpstring("method Read Conformity File")] HRESULT ReadConformityFile([in] BSTR name, [in] BSTR uptFileNameForRead, [out, retval] BSTR *ArrayOfStrings);

[id(4), helpstring("method Get UptAlgName by FileName")] HRESULT GetAlgName([in] BSTR Strings, [in] BSTR SearchName, [out, retval] BSTR *ResultStr);

[id(5), helpstring("method Get FileName by UptAlgName")] HRESULT GetDataName([in] BSTR Strings, [in] BSTR SearchName, [out, retval] BSTR *ResultStr);

[id(6), helpstring("method Get UptAlgName by FileName From File")] HRESULT GetAlgFromFile([in] BSTR FileName, [in] BSTR uptFileNameForRead, [in] BSTR SearchName, [out, retval] BSTR *ResultStr);

[id(7), helpstring("method Get FileName by UptAlgName From File")] HRESULT GetDataFromFile([in] BSTR FileName, [in] BSTR uptFileNameForRead, [in] BSTR SearchName, [out, retval] BSTR *ResultStr);

};

/*

[

object,

uuid(15A99543-9A8F-4032-B61F-8EDF01101A93),

dual, oleautomation,

helpstring("IProtectBase Interface"),

pointer_default(unique)

]

interface IProtectBase : IDispatch

{

};

*/

[

uuid(8B9F6840-7A50-4A94-AC80-B2C85F3C469C),

version(1.0),

helpstring("Uniprot 1.0 Type Library")

]

library UNIPROTLib

{

importlib("stdole32.tlb");

importlib("stdole2.tlb");

[

uuid(75581251-6B01-4164-850D-CD6A93D860BB),

helpstring("protect Class")

]

coclass protect

{

[default] interface IProtect;

interface IProtectFile;

interface IProtectConformity;

};

};

Характеристики

Список файлов реферата