You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
381 lines
9.3 KiB
381 lines
9.3 KiB
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows NT Security
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: cua.cpp
|
|
//
|
|
// Contents: CCryptUrlArray implementation
|
|
//
|
|
// History: 16-Sep-97 kirtd Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
#include <global.hxx>
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::CCryptUrlArray, public
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CCryptUrlArray::CCryptUrlArray (ULONG cMinUrls, ULONG cGrowUrls, BOOL& rfResult)
|
|
{
|
|
rfResult = TRUE;
|
|
m_cGrowUrls = cGrowUrls;
|
|
m_cua.cUrl = 0;
|
|
m_cua.rgwszUrl = new LPWSTR [cMinUrls];
|
|
if ( m_cua.rgwszUrl != NULL )
|
|
{
|
|
memset( m_cua.rgwszUrl, 0, sizeof(LPWSTR)*cMinUrls );
|
|
m_cArray = cMinUrls;
|
|
}
|
|
else
|
|
{
|
|
SetLastError( (DWORD) E_OUTOFMEMORY );
|
|
rfResult = FALSE;
|
|
}
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::CCryptUrlArray, public
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
CCryptUrlArray::CCryptUrlArray (PCRYPT_URL_ARRAY pcua, ULONG cGrowUrls)
|
|
{
|
|
m_cGrowUrls = cGrowUrls;
|
|
m_cua.cUrl = pcua->cUrl;
|
|
m_cua.rgwszUrl = pcua->rgwszUrl;
|
|
m_cArray = pcua->cUrl;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::AllocUrl, public, static
|
|
//
|
|
// Synopsis: allocate an URL using the same allocator used for ::AddUrl
|
|
// copies. This means that the resulting URL can be added
|
|
// without copying.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LPWSTR
|
|
CCryptUrlArray::AllocUrl (ULONG cw)
|
|
{
|
|
return( (LPWSTR)CryptMemAlloc( cw * sizeof( WCHAR ) ) );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::ReallocUrl, public, static
|
|
//
|
|
// Synopsis: see ::AllocUrl
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LPWSTR
|
|
CCryptUrlArray::ReallocUrl (LPWSTR pwszUrl, ULONG cw)
|
|
{
|
|
return( (LPWSTR)CryptMemRealloc( pwszUrl, cw * sizeof( WCHAR ) ) );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::FreeUrl, public, static
|
|
//
|
|
// Synopsis: free URL allocated using ::AllocBlob or ::ReallocBlob
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
CCryptUrlArray::FreeUrl (LPWSTR pwszUrl)
|
|
{
|
|
CryptMemFree( pwszUrl );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::AddUrl, public
|
|
//
|
|
// Synopsis: add an URL to the array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
CCryptUrlArray::AddUrl (LPWSTR pwszUrl, BOOL fCopyUrl)
|
|
{
|
|
BOOL fResult = TRUE;
|
|
LPWSTR pwszToUse;
|
|
|
|
//
|
|
// If we need to copy the URL, do so
|
|
//
|
|
|
|
if ( fCopyUrl == TRUE )
|
|
{
|
|
ULONG cw = wcslen( pwszUrl ) + 1;
|
|
|
|
pwszToUse = AllocUrl( cw );
|
|
if ( pwszToUse != NULL )
|
|
{
|
|
memcpy( pwszToUse, pwszUrl, cw * sizeof( WCHAR ) );
|
|
}
|
|
else
|
|
{
|
|
SetLastError( (DWORD) E_OUTOFMEMORY );
|
|
return( FALSE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pwszToUse = pwszUrl;
|
|
}
|
|
|
|
//
|
|
// If we need to grow the array, do so
|
|
//
|
|
|
|
if ( m_cArray == m_cua.cUrl )
|
|
{
|
|
fResult = GrowArray();
|
|
}
|
|
|
|
//
|
|
// Add the URL to the array
|
|
//
|
|
|
|
if ( fResult == TRUE )
|
|
{
|
|
m_cua.rgwszUrl[m_cua.cUrl] = pwszToUse;
|
|
m_cua.cUrl += 1;
|
|
}
|
|
else if ( fCopyUrl == TRUE )
|
|
{
|
|
FreeUrl( pwszToUse );
|
|
}
|
|
|
|
return( fResult );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::GetUrl, public
|
|
//
|
|
// Synopsis: get an URL from the array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
LPWSTR
|
|
CCryptUrlArray::GetUrl (ULONG Index)
|
|
{
|
|
assert( m_cua.cUrl > Index );
|
|
|
|
return( m_cua.rgwszUrl[Index] );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::GetUrlCount, public
|
|
//
|
|
// Synopsis: get the count of URLs in the array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
ULONG
|
|
CCryptUrlArray::GetUrlCount ()
|
|
{
|
|
return( m_cua.cUrl );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::GetArrayInNativeForm, public
|
|
//
|
|
// Synopsis: get the array in native form
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
CCryptUrlArray::GetArrayInNativeForm (PCRYPT_URL_ARRAY pcua)
|
|
{
|
|
pcua->cUrl = m_cua.cUrl;
|
|
pcua->rgwszUrl = m_cua.rgwszUrl;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::GetArrayInSingleBufferEncodedForm, public
|
|
//
|
|
// Synopsis: get the array encoded in a single buffer
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
CCryptUrlArray::GetArrayInSingleBufferEncodedForm (
|
|
PCRYPT_URL_ARRAY* ppcua,
|
|
ULONG* pcb
|
|
)
|
|
{
|
|
ULONG cbStruct;
|
|
ULONG cbPointers;
|
|
ULONG cbData;
|
|
ULONG cb;
|
|
ULONG cbSize;
|
|
ULONG cCount;
|
|
PCRYPT_URL_ARRAY pcua = NULL;
|
|
ULONG cbUrl;
|
|
|
|
//
|
|
// Calculate the buffer size we will need and allocate it
|
|
//
|
|
|
|
cbStruct = sizeof( CRYPT_URL_ARRAY );
|
|
cbPointers = m_cua.cUrl * sizeof( LPWSTR );
|
|
|
|
for ( cCount = 0, cbData = 0; cCount < m_cua.cUrl; cCount++ )
|
|
{
|
|
cbData += ( wcslen( m_cua.rgwszUrl[cCount] ) + 1 ) * sizeof( WCHAR );
|
|
}
|
|
|
|
cbSize = cbStruct + cbPointers + cbData;
|
|
|
|
if ( ppcua == NULL )
|
|
{
|
|
if ( pcb != NULL )
|
|
{
|
|
*pcb = cbSize;
|
|
return( TRUE );
|
|
}
|
|
|
|
SetLastError( (DWORD) E_INVALIDARG );
|
|
return( FALSE );
|
|
}
|
|
|
|
if ( *ppcua == NULL )
|
|
{
|
|
pcua = (PCRYPT_URL_ARRAY)CryptMemAlloc( cbSize );
|
|
if ( pcua == NULL )
|
|
{
|
|
SetLastError( (DWORD) E_OUTOFMEMORY );
|
|
return( FALSE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( pcb == NULL )
|
|
{
|
|
SetLastError( (DWORD) E_INVALIDARG );
|
|
return( FALSE );
|
|
}
|
|
else if ( *pcb < cbSize )
|
|
{
|
|
SetLastError( (DWORD) E_INVALIDARG );
|
|
return( FALSE );
|
|
}
|
|
|
|
pcua = *ppcua;
|
|
}
|
|
|
|
//
|
|
// Fill in the data
|
|
//
|
|
|
|
pcua->cUrl = m_cua.cUrl;
|
|
pcua->rgwszUrl = (LPWSTR *)((LPBYTE)pcua+cbStruct);
|
|
|
|
for ( cCount = 0, cb = 0; cCount < m_cua.cUrl; cCount++ )
|
|
{
|
|
pcua->rgwszUrl[cCount] = (LPWSTR)((LPBYTE)pcua+cbStruct+cbPointers+cb);
|
|
|
|
cbUrl = ( wcslen( m_cua.rgwszUrl[cCount] ) + 1 ) * sizeof( WCHAR );
|
|
|
|
memcpy( pcua->rgwszUrl[cCount], m_cua.rgwszUrl[cCount], cbUrl );
|
|
|
|
cb += cbUrl;
|
|
}
|
|
|
|
if ( *ppcua != pcua )
|
|
{
|
|
*ppcua = pcua;
|
|
|
|
if ( pcb != NULL )
|
|
{
|
|
*pcb = cbSize;
|
|
}
|
|
}
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::FreeArray, public
|
|
//
|
|
// Synopsis: free the URL array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
VOID
|
|
CCryptUrlArray::FreeArray (BOOL fFreeUrls)
|
|
{
|
|
if ( fFreeUrls == TRUE )
|
|
{
|
|
ULONG cCount;
|
|
|
|
for ( cCount = 0; cCount < m_cua.cUrl; cCount++ )
|
|
{
|
|
FreeUrl( m_cua.rgwszUrl[cCount] );
|
|
}
|
|
}
|
|
|
|
delete m_cua.rgwszUrl;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCryptUrlArray::GrowArray, private
|
|
//
|
|
// Synopsis: grow the URL array
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
BOOL
|
|
CCryptUrlArray::GrowArray ()
|
|
{
|
|
ULONG cNewArray;
|
|
LPWSTR* rgwsz;
|
|
|
|
//
|
|
// Check if we are allowed to grow
|
|
//
|
|
//
|
|
|
|
if ( m_cGrowUrls == 0 )
|
|
{
|
|
SetLastError( (DWORD) E_INVALIDARG );
|
|
return( FALSE );
|
|
}
|
|
|
|
//
|
|
// Allocate and initialize the new array
|
|
//
|
|
|
|
cNewArray = m_cArray + m_cGrowUrls;
|
|
rgwsz = new LPWSTR [cNewArray];
|
|
if ( rgwsz == NULL )
|
|
{
|
|
SetLastError( (DWORD) E_OUTOFMEMORY );
|
|
return( FALSE );
|
|
}
|
|
|
|
memset( rgwsz, 0, cNewArray * sizeof( LPWSTR ) );
|
|
|
|
//
|
|
// Copy the old to the new
|
|
//
|
|
|
|
memcpy( rgwsz, m_cua.rgwszUrl, m_cua.cUrl*sizeof( LPWSTR ) );
|
|
|
|
//
|
|
// Free the old and use the new
|
|
//
|
|
|
|
delete m_cua.rgwszUrl;
|
|
m_cua.rgwszUrl = rgwsz;
|
|
m_cArray = cNewArray;
|
|
|
|
return( TRUE );
|
|
}
|
|
|