able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/fs/hsm/wsb/wsbport.cpp

1410 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
<EFBFBD> 1998 Seagate Software, Inc. All rights reserved
Module Name:
WsbPort.cpp
Abstract:
Macros, functions, and classes to support portability.
Author:
Ron White [ronw] 19-Dec-1996
Revision History:
--*/
#include "stdafx.h"
#include "wsbport.h"
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
BOOL* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a BOOL value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array.
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(BOOL)"), OLESTR(""));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(1 == WSB_BYTE_SIZE_BOOL, E_UNEXPECTED);
if (*pBytes) {
*pValue = TRUE;
} else {
*pValue = FALSE;
}
if (pSize) {
*pSize = WSB_BYTE_SIZE_BOOL;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(BOOL)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
GUID* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a GUID value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 16 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(GUID)"), OLESTR(""));
try {
ULONG lsize;
ULONG tsize;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &pValue->Data1, &lsize));
tsize = lsize;
WsbAffirmHr(WsbConvertFromBytes(pBytes + tsize, &pValue->Data2, &lsize));
tsize += lsize;
WsbAffirmHr(WsbConvertFromBytes(pBytes + tsize, &pValue->Data3, &lsize));
tsize += lsize;
memcpy(pValue->Data4, pBytes + tsize, 8);
tsize += 8;
if (pSize) {
*pSize = tsize;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(GUID)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
LONG* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a LONG value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 4 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(LONG)"), OLESTR(""));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(4 == WSB_BYTE_SIZE_LONG, E_UNEXPECTED);
*pValue = (pBytes[0] << 24) | (pBytes[1] << 16) |
(pBytes[2] << 8) | pBytes[3];
if (pSize) {
*pSize = WSB_BYTE_SIZE_LONG;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(LONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
LONGLONG* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a LONGLONG value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 8 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(LONGLONG)"), OLESTR(""));
try {
ULONG size;
ULONG total = 0;
ULONG ul;
LONGLONG ll;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pBytes += size;
ll = (LONGLONG) ul;
*pValue = ll << 32;
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
ll = (LONGLONG) ul;
*pValue |= ll;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(LONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
ULONGLONG* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULONGLONG value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 8 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(ULONGLONG)"), OLESTR(""));
try {
ULONG size;
ULONG total = 0;
ULONG ul;
LONGLONG ll;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pBytes += size;
ll = (ULONGLONG) ul;
*pValue = ll << 32;
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
ll = (ULONGLONG) ul;
*pValue |= ll;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(ULONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
DATE* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a DATE value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 8 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(DATE)"), OLESTR(""));
try {
LONGLONG ll;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(WSB_BYTE_SIZE_DATE == WSB_BYTE_SIZE_LONGLONG, E_UNEXPECTED);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ll, NULL));
*pValue = (DATE) ll;
if (pSize) {
*pSize = WSB_BYTE_SIZE_DATE;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(DATE)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
FILETIME* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a FILETIME value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 8 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(FILETIME)"), OLESTR(""));
try {
ULONG size;
ULONG total = 0;
ULONG ul;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pBytes += size;
pValue->dwHighDateTime = ul;
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pValue->dwLowDateTime = ul;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(FILETIME)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
SHORT* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a SHORT value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 2 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(SHORT)"), OLESTR(""));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(2 == WSB_BYTE_SIZE_SHORT, E_UNEXPECTED);
*pValue = (SHORT)( (pBytes[0] << 8) | pBytes[1] );
if (pSize) {
*pSize = WSB_BYTE_SIZE_SHORT;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(SHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
ULARGE_INTEGER* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULARGE_INTEGER value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 8 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(ULARGE_INTEGER)"), OLESTR(""));
try {
ULONG size;
ULONG total = 0;
ULONG ul;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pBytes += size;
pValue->HighPart = ul;
WsbAffirmHr(WsbConvertFromBytes(pBytes, &ul, &size));
total += size;
pValue->LowPart = ul;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(ULARGE_INTEGER)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
ULONG* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULONG value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 4 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(ULONG)"), OLESTR(""));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(4 == WSB_BYTE_SIZE_ULONG, E_UNEXPECTED);
*pValue = (pBytes[0] << 24) | (pBytes[1] << 16) |
(pBytes[2] << 8) | pBytes[3];
if (pSize) {
*pSize = WSB_BYTE_SIZE_ULONG;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(ULONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertFromBytes(
UCHAR* pBytes,
USHORT* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a USHORT value from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array (must at least 2 bytes long).
pValue - Pointer to the returned value.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertFromBytes(USHORT)"), OLESTR(""));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(2 == WSB_BYTE_SIZE_USHORT, E_UNEXPECTED);
*pValue = (USHORT)( ( pBytes[0] << 8 ) | pBytes[1] );
if (pSize) {
*pSize = WSB_BYTE_SIZE_USHORT;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertFromBytes(USHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
BOOL value,
ULONG* pSize
)
/*++
Routine Description:
Convert a BOOL value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array.
value - The BOOL value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(BOOL)"), OLESTR("value = <%s>"),
WsbBoolAsString(value));
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(1 == WSB_BYTE_SIZE_BOOL, E_UNEXPECTED);
if (value) {
*pBytes = 1;
} else {
*pBytes = 0;
}
if (pSize) {
*pSize = WSB_BYTE_SIZE_BOOL;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(BOOL)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
GUID value,
ULONG* pSize
)
/*++
Routine Description:
Convert a GUID value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 16 bytes long).
value - The GUID value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(GUID)"), OLESTR("value = <%s>"),
WsbGuidAsString(value));
try {
ULONG lsize;
ULONG tsize;
WsbAssert(0 != pBytes, E_POINTER);
WsbAffirmHr(WsbConvertToBytes(pBytes, value.Data1, &lsize));
tsize = lsize;
WsbAffirmHr(WsbConvertToBytes(pBytes + tsize, value.Data2, &lsize));
tsize += lsize;
WsbAffirmHr(WsbConvertToBytes(pBytes + tsize, value.Data3, &lsize));
tsize += lsize;
memcpy(pBytes + tsize, value.Data4, 8);
tsize += 8;
if (pSize) {
*pSize = tsize;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(GUID)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
LONG value,
ULONG* pSize
)
/*++
Routine Description:
Convert a LONG value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 4 bytes long).
value - The LONG value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(LONG)"), OLESTR("value = <%d>"), value);
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(4 == WSB_BYTE_SIZE_LONG, E_UNEXPECTED);
pBytes[0] = ((UCHAR)(value >> 24));
pBytes[1] = ((UCHAR)((value >> 16) & 0xFF));
pBytes[2] = ((UCHAR)((value >> 8) & 0xFF));
pBytes[3] = ((UCHAR)(value & 0xFF));
if (pSize) {
*pSize = WSB_BYTE_SIZE_LONG;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(LONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
LONGLONG value,
ULONG* pSize
)
/*++
Routine Description:
Convert a LONGLONG value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 8 bytes long).
value - The LONGLONG value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(LONGLONG)"), OLESTR("value = <%d>"), value);
try {
ULONG size;
ULONG total = 0;
ULONG ul;
WsbAssert(0 != pBytes, E_POINTER);
ul = (ULONG)(value >> 32);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
pBytes += size;
ul = (ULONG)(value & 0xFFFFFFFF);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(LONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
ULONGLONG value,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULONGLONG value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 8 bytes long).
value - The LONGLONG value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(ULONGLONG)"), OLESTR("value = <%d>"), value);
try {
ULONG size;
ULONG total = 0;
ULONG ul;
WsbAssert(0 != pBytes, E_POINTER);
ul = (ULONG)(value >> 32);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
pBytes += size;
ul = (ULONG)(value & 0xFFFFFFFF);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(ULONGLONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
DATE value,
ULONG* pSize
)
/*++
Routine Description:
Convert a DATE value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 8 bytes long).
value - The DATE value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(DATE)"), OLESTR("value = <%d>"), value);
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(WSB_BYTE_SIZE_DATE == WSB_BYTE_SIZE_LONGLONG, E_UNEXPECTED);
// Needs to modified after WsbDate functions.
WsbAffirmHr(WsbConvertToBytes(pBytes, (LONGLONG) value, NULL));
if (pSize) {
*pSize = WSB_BYTE_SIZE_DATE;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(DATE)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
FILETIME value,
ULONG* pSize
)
/*++
Routine Description:
Convert a FILETIME value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 8 bytes long).
value - The FILETIME value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(FILETIME)"), OLESTR("value = <%d>"), value);
try {
ULONG size;
ULONG total = 0;
WsbAssert(0 != pBytes, E_POINTER);
WsbAffirmHr(WsbConvertToBytes(pBytes, value.dwHighDateTime, &size));
total += size;
pBytes += size;
WsbAffirmHr(WsbConvertToBytes(pBytes, value.dwLowDateTime, &size));
total += size;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(FILETIME)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
SHORT value,
ULONG* pSize
)
/*++
Routine Description:
Convert a SHORT value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 2 bytes long).
value - The SHORT value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(SHORT)"), OLESTR("value = <%d>"), value);
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(2 == WSB_BYTE_SIZE_SHORT, E_UNEXPECTED);
pBytes[0] = (UCHAR)( (value >> 8) & 0xFF);
pBytes[1] = (UCHAR)( value & 0xFF );
if (pSize) {
*pSize = WSB_BYTE_SIZE_SHORT;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(SHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
ULARGE_INTEGER value,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULARGE_INTEGER value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 8 bytes long).
value - The ULARGE_INTEGER value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(ULARGE_INTEGER)"), OLESTR("value = <%d>"), value);
try {
ULONG size;
ULONG total = 0;
ULONG ul;
WsbAssert(0 != pBytes, E_POINTER);
ul = (ULONG)(value.QuadPart >> 32);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
pBytes += size;
ul = (ULONG)(value.QuadPart & 0xFFFFFFFF);
WsbAffirmHr(WsbConvertToBytes(pBytes, ul, &size));
total += size;
if (pSize) {
*pSize = total;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(ULARGE_INTEGER)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
ULONG value,
ULONG* pSize
)
/*++
Routine Description:
Convert a ULONG value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 4 bytes long).
value - The ULONG value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(ULONG)"), OLESTR("value = <%d>"), value);
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(4 == WSB_BYTE_SIZE_ULONG, E_UNEXPECTED);
pBytes[0] = ((UCHAR)(value >> 24));
pBytes[1] = ((UCHAR)((value >> 16) & 0xFF));
pBytes[2] = ((UCHAR)((value >> 8) & 0xFF));
pBytes[3] = ((UCHAR)(value & 0xFF));
if (pSize) {
*pSize = WSB_BYTE_SIZE_ULONG;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(ULONG)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbConvertToBytes(
UCHAR* pBytes,
USHORT value,
ULONG* pSize
)
/*++
Routine Description:
Convert a USHORT value to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must at least 2 bytes long).
value - The USHORT value to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbConvertToBytes(USHORT)"), OLESTR("value = <%d>"), value);
try {
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(2 == WSB_BYTE_SIZE_USHORT, E_UNEXPECTED);
pBytes[0] = (UCHAR)( ( value >> 8 ) & 0xFF );
pBytes[1] = (UCHAR)( value & 0xFF );
if (pSize) {
*pSize = WSB_BYTE_SIZE_USHORT;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbConvertToBytes(USHORT)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbOlestrFromBytes(
UCHAR* pBytes,
OLECHAR* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a OLECHAR string from a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The source byte array.
pValue - Pointer to the returned string.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes or pValue was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbOlestrFromBytes(OLECHAR)"), OLESTR(""));
try {
ULONG size = 0;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(sizeof(OLECHAR) == 2, E_FAIL);
while (TRUE) {
OLECHAR wc;
wc = (OLECHAR)( (*pBytes++) << 8 );
wc |= *pBytes++;
size += 2;
*pValue++ = wc;
if (wc == 0) break;
}
if (pSize) {
*pSize = size;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbOlestrFromBytes(OLECHAR)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
HRESULT
WsbOlestrToBytes(
UCHAR* pBytes,
OLECHAR* pValue,
ULONG* pSize
)
/*++
Routine Description:
Convert a OLECHAR sring to a string of bytes. Useful
for stream portability and creating WsbDbKey values.
Arguments:
pBytes - The target byte array (must long enough).
pValue - The OLECHAR string to convert.
pSize - Returns the number of bytes used. Can be NULL.
Return Value:
S_OK - Success
E_POINTER - pBytes was NULL.
--*/
{
HRESULT hr = S_OK;
WsbTraceIn(OLESTR("WsbOlestrToBytes(OLECHAR)"), OLESTR("value = <%S>"), pValue);
try {
ULONG size = 0;
WsbAssert(0 != pBytes, E_POINTER);
WsbAssert(0 != pValue, E_POINTER);
WsbAssert(sizeof(OLECHAR) == 2, E_FAIL);
while (TRUE) {
OLECHAR wc;
wc = *pValue++;
*pBytes++ = (UCHAR)( ( wc >> 8 ) & 0xFF );
*pBytes++ = (UCHAR)( wc & 0xFF );
size += 2;
if (wc == 0) break;
}
if (pSize) {
*pSize = size;
}
} WsbCatch(hr);
WsbTraceOut(OLESTR("WsbOlestrToBytes(OLECHAR)"), OLESTR("hr = <%ls>"), WsbHrAsString(hr));
return(hr);
}
Reference in a new issue Copy permalink