windows-server-2003/ds/adsi/oledsvw/testcore.cpp

#define _LARGE_INTEGER_SUPPORT_
#include "stdafx.h"
#include "winnls.h"
#include "resource.h"
#include "errordlg.h"

typedef DWORD ( *LARGEINTTOSTRING )( LARGE_INTEGER*, ULONG, LONG, PSZ );

LARGEINTTOSTRING LargeIntegerToString;

/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
ADSTYPE  ADsTypeFromString( CString& strText )
{
   if( !strText.CompareNoCase( _T("ADSTYPE_DN_STRING") ) )
      return ADSTYPE_DN_STRING;

	if( !strText.CompareNoCase( _T("ADSTYPE_CASE_EXACT_STRING") ) )
      return ADSTYPE_CASE_EXACT_STRING;

   if( !strText.CompareNoCase( _T("ADSTYPE_CASE_IGNORE_STRING") ) )
      return ADSTYPE_CASE_IGNORE_STRING;


	if( !strText.CompareNoCase( _T("ADSTYPE_PRINTABLE_STRING") ) )
      return ADSTYPE_PRINTABLE_STRING;


	if( !strText.CompareNoCase( _T("ADSTYPE_NUMERIC_STRING") ) )
      return ADSTYPE_NUMERIC_STRING;


	if( !strText.CompareNoCase( _T("ADSTYPE_BOOLEAN") ) )
      return ADSTYPE_BOOLEAN;


	if( !strText.CompareNoCase( _T("ADSTYPE_INTEGER") ) )
      return ADSTYPE_INTEGER;


	if( !strText.CompareNoCase( _T("ADSTYPE_OCTET_STRING") ) )
      return ADSTYPE_OCTET_STRING;


	if( !strText.CompareNoCase( _T("ADSTYPE_UTC_TIME") ) )
      return ADSTYPE_UTC_TIME;


	if( !strText.CompareNoCase( _T("ADSTYPE_LARGE_INTEGER") ) )
      return ADSTYPE_LARGE_INTEGER;


	if( !strText.CompareNoCase( _T("ADSTYPE_PROV_SPECIFIC") ) )
      return ADSTYPE_PROV_SPECIFIC;

   if( !strText.CompareNoCase( _T("ADSTYPE_CASEIGNORE_LIST") ) )
      return ADSTYPE_CASEIGNORE_LIST;

   if( !strText.CompareNoCase( _T("ADSTYPE_POSTALADDRESS") ) )
      return ADSTYPE_POSTALADDRESS;

	if( !strText.CompareNoCase( _T("ADSTYPE_OCTET_LIST") ) )
      return ADSTYPE_OCTET_LIST;

	if( !strText.CompareNoCase( _T("ADSTYPE_PATH") ) )
      return ADSTYPE_PATH;

	if( !strText.CompareNoCase( _T("ADSTYPE_POSTALADDRESS") ) )
      return ADSTYPE_POSTALADDRESS;

	if( !strText.CompareNoCase( _T("ADSTYPE_TIMESTAMP") ) )
      return ADSTYPE_TIMESTAMP;

	if( !strText.CompareNoCase( _T("ADSTYPE_BACKLINK") ) )
      return ADSTYPE_BACKLINK;

	if( !strText.CompareNoCase( _T("ADSTYPE_TYPEDNAME") ) )
      return ADSTYPE_TYPEDNAME;

	if( !strText.CompareNoCase( _T("ADSTYPE_HOLD") ) )
      return ADSTYPE_HOLD;

	if( !strText.CompareNoCase( _T("ADSTYPE_NETADDRESS") ) )
      return ADSTYPE_NETADDRESS;

	if( !strText.CompareNoCase( _T("ADSTYPE_REPLICAPOINTER") ) )
      return ADSTYPE_REPLICAPOINTER;

	if( !strText.CompareNoCase( _T("ADSTYPE_FAXNUMBER") ) )
      return ADSTYPE_FAXNUMBER;

	if( !strText.CompareNoCase( _T("ADSTYPE_EMAIL") ) )
      return ADSTYPE_EMAIL;

   return ADSTYPE_INVALID;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
ADSTYPE  ADsTypeFromSyntaxString( WCHAR* pszSyntax )
{
   ADSTYPE  eType = ADSTYPE_CASE_IGNORE_STRING;

   if( !_wcsicmp( pszSyntax, L"String" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"DN" ) )
   {
      eType = ADSTYPE_DN_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"ObjectSecurityDescriptor" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"OID" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"Object Class" ) )
   {
      eType = ADSTYPE_OBJECT_CLASS;
   }
   else if( !_wcsicmp( pszSyntax, L"DirectoryString" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"ORName" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"IA5String" ) )
   {
      eType = ADSTYPE_NUMERIC_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"NumericString" ) )
   {
      eType = ADSTYPE_NUMERIC_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"CaseIgnoreString" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"PrintableString" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"Counter" ) )
   {
      eType = ADSTYPE_INTEGER;
   }
   else if( !_wcsicmp( pszSyntax, L"OleDsPath" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"Email" ) )
   {
      eType = ADSTYPE_EMAIL;
   }
   else if( !_wcsicmp( pszSyntax, L"Hold" ) )
   {
      eType = ADSTYPE_HOLD;
   }
   else if( !_wcsicmp( pszSyntax, L"Octet" ) )
   {
      eType = ADSTYPE_OCTET_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"Back Link" ) )
   {
      eType = ADSTYPE_BACKLINK;
   }
   else if( !_wcsicmp( pszSyntax, L"Typed Name" ) )
   {
      eType = ADSTYPE_TYPEDNAME;
   }
   else if( !_wcsicmp( pszSyntax, L"EmailAddress" ) )
   {
      eType = ADSTYPE_EMAIL;
   }
   else if( !_wcsicmp( pszSyntax, L"Path" ) )
   {
      eType = ADSTYPE_PATH;
   }
   else if( !_wcsicmp( pszSyntax, L"Case Ignore List" ) )
   {
      eType = ADSTYPE_CASEIGNORE_LIST;
   }
   else if( !_wcsicmp( pszSyntax, L"Octet List" ) )
   {
      eType = ADSTYPE_OCTET_LIST;
   }
   else if( !_wcsicmp( pszSyntax, L"FaxNumber" ) )
   {
      eType = ADSTYPE_FAXNUMBER;
   }
   else if( !_wcsicmp( pszSyntax, L"Integer" ) )
   {
      eType = ADSTYPE_INTEGER;
   }
   else if( !_wcsicmp( pszSyntax, L"Integer8" ) )
   {
      eType = ADSTYPE_LARGE_INTEGER;
   }
   else if( !_wcsicmp( pszSyntax, L"Postal Address" ) )
   {
      eType = ADSTYPE_POSTALADDRESS;
   }
   else if( !_wcsicmp( pszSyntax, L"Interval" ) )
   {
      eType = ADSTYPE_INTEGER;
   }
   else if( !_wcsicmp( pszSyntax, L"List" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"NetAddress" ) )
   {
      eType = ADSTYPE_NETADDRESS;
   }
   else if( !_wcsicmp( pszSyntax, L"OctetString" ) )
   {
      eType = ADSTYPE_OCTET_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"Path" ) )
   {
      eType = ADSTYPE_PATH;
   }
   else if( !_wcsicmp( pszSyntax, L"PhoneNumber" ) )
   {
      eType = ADSTYPE_CASE_IGNORE_STRING;
   }
   else if( !_wcsicmp( pszSyntax, L"PostalAddress" ) )
   {
      eType = ADSTYPE_POSTALADDRESS;
   }
   else if( !_wcsicmp( pszSyntax, L"SmallInterval" ) )
   {
      eType = ADSTYPE_INTEGER;
   }
   else if( !_wcsicmp( pszSyntax, L"Time" ) )
   {
      eType = ADSTYPE_UTC_TIME;
   }
   else if( !_wcsicmp( pszSyntax, L"TimeStamp" ) )
   {
      eType = ADSTYPE_TIMESTAMP;
   }
  else if( !_wcsicmp( pszSyntax, L"UTCTime" ) )
   {
      eType = ADSTYPE_UTC_TIME;
   }
  else if( !_wcsicmp( pszSyntax, L"GeneralizedTime" ) )
   {
      eType = ADSTYPE_UTC_TIME;
   }
   else if( !_wcsicmp( pszSyntax, L"boolean" ) )
   {
      eType = ADSTYPE_BOOLEAN;
   }
   else
   {
      TCHAR szText[ 128 ];

      Convert( szText, pszSyntax );
      TRACE( _T("ERROR: unknown %s syntax\n"), szText );
      //ASSERT( FALSE );
   }

   return eType;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
CString  StringFromADsType( ADSTYPE eType )
{

   switch( eType )
   {
      case  ADSTYPE_DN_STRING:
         return CString( _T("ADSTYPE_DN_STRING") );

      case  ADSTYPE_CASE_EXACT_STRING:
	      return CString( _T("ADSTYPE_CASE_EXACT_STRING") );

      case  ADSTYPE_CASE_IGNORE_STRING:
         return CString( _T("ADSTYPE_CASE_IGNORE_STRING") );

      case  ADSTYPE_PRINTABLE_STRING:
	      return CString( _T("ADSTYPE_PRINTABLE_STRING") );

      case  ADSTYPE_NUMERIC_STRING:
	      return CString( _T("ADSTYPE_NUMERIC_STRING") );

      case  ADSTYPE_BOOLEAN:
	      return CString( _T("ADSTYPE_BOOLEAN") );

      case  ADSTYPE_INTEGER:
	      return CString( _T("ADSTYPE_INTEGER") );

      case  ADSTYPE_OCTET_STRING:
	      return CString( _T("ADSTYPE_OCTET_STRING") );

      case  ADSTYPE_UTC_TIME:
	      return CString( _T("ADSTYPE_UTC_TIME") );


      case  ADSTYPE_LARGE_INTEGER:
	      return CString( _T("ADSTYPE_LARGE_INTEGER") );


      case  ADSTYPE_PROV_SPECIFIC:
	      return CString( _T("ADSTYPE_PROV_SPECIFIC") );

      default:
         return CString( _T("ADSTYPE_UNKNOWN") );

   }
}



/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
DWORD TypeFromString( LPWSTR lpszBuffer )
{
   if( !lpszBuffer )
      return OTHER;

   if( !_wcsicmp( lpszBuffer, L"Namespace" ) )
      return NAMESPACE;

   if( !_wcsicmp(  lpszBuffer, L"Namespaces" ) )
      return NAMESPACES;

   if( !_wcsicmp( lpszBuffer, L"User" ) )
      return USER;

   if( !_wcsicmp( lpszBuffer, L"Group" ) )
      return GROUP;

   if( !_wcsicmp( lpszBuffer, L"LocalGroup" ) )
      return GROUP;

   if( !_wcsicmp( lpszBuffer, L"GlobalGroup" ) )
      return GROUP;

   if( !_wcsicmp( lpszBuffer, L"groupofuniquenames" ) )
      return GROUP;

   if( !_wcsicmp( lpszBuffer, L"Domain" ) )
      return DOMAIN;

   if( !_wcsicmp( lpszBuffer, L"Computer" ) )
      return  COMPUTER;

   if( !_wcsicmp( lpszBuffer, L"Service" ) )
      return  SERVICE;

   if( !_wcsicmp( lpszBuffer, L"FileService" ) )
      return  FILESERVICE;

   if( !_wcsicmp( lpszBuffer, L"Printqueue" ) )
      return  PRINTQUEUE;

   if( !_wcsicmp( lpszBuffer, L"Printer" ) )
      return  PRINTER;

   if( !_wcsicmp( lpszBuffer, L"Printjob" ) )
      return  PRINTJOB;

   if( !_wcsicmp( lpszBuffer, L"PrintDevice" ) )
      return  PRINTDEVICE;

   if( !_wcsicmp( lpszBuffer, L"Session" ) )
      return   SESSION;

   if( !_wcsicmp( lpszBuffer, L"Resource" ) )
      return   RESOURCE;

   if( !_wcsicmp( lpszBuffer, L"FileShare" ) )
      return   FILESHARE;

   if( !_wcsicmp( lpszBuffer, L"Organization" ) )
      return NDSORG;

   if( !_wcsicmp( lpszBuffer, L"Root" ) )
      return NDSROOT;

   if( !_wcsicmp( lpszBuffer, L"Tree" ) )
      return NDSROOT;

   if( !_wcsicmp( lpszBuffer, L"Top" ) )
      return NDSROOT;

   if( !_wcsicmp( lpszBuffer, L"Organizational Unit" ) )
      return NDSOU;

   if( !_wcsicmp( lpszBuffer, L"OrganizationalUnit" ) )
      return NDSOU;

   if( !_wcsicmp( lpszBuffer, L"DomainOrganizationalUnit" ) )
      return NDSOU;

   if( !_wcsicmp( lpszBuffer, L"Alias" ) )
      return   NDSALIAS;

   if( !_wcsicmp( lpszBuffer, L"Directory Map" ) )
      return   NDSDIRECTORYMAP;

   if( !_wcsicmp( lpszBuffer, L"Distribution List" ) )
      return   NDSDISTRIBUTIONLIST;

   if( !_wcsicmp( lpszBuffer, L"AFP Server" ) )
      return   NDSAFPSERVER;

   if( !_wcsicmp( lpszBuffer, L"Communications Server" ) )
      return   NDSCOMMUNICATIONSSERVER;

   if( !_wcsicmp( lpszBuffer, L"Message Routing Group" ) )
      return   NDSMESSAGEROUTINGGROUP;

   if( !_wcsicmp( lpszBuffer, L"NCP Server" ) )
      return   NDSNETWARESERVER;

   if( !_wcsicmp( lpszBuffer, L"Organizational Role" ) )
      return   NDSORGANIZATIONALROLE;

   if( !_wcsicmp( lpszBuffer, L"Queue" ) )
      return   NDSPRINTQUEUE;

   if( !_wcsicmp( lpszBuffer, L"Print Server" ) )
      return   NDSPRINTSERVER;

   if( !_wcsicmp( lpszBuffer, L"Profile" ) )
      return   NDSPROFILE;

   if( !_wcsicmp( lpszBuffer, L"Volume" ) )
      return   NDSVOLUME;

   if( !_wcsicmp( lpszBuffer, L"Class" ) )
      return   CLASS;

   if( !_wcsicmp( lpszBuffer, L"Schema" ) )
      return   SCHEMA;

   if( !_wcsicmp( lpszBuffer, L"Syntax" ) )
      return   SYNTAX;

   if( !_wcsicmp( lpszBuffer, L"Property" ) )
      return   PROPERTY;

   return OTHER;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
DWORD TypeFromString( LPSTR lpszBuffer )
{
   int      nLength;
   WCHAR*   pszwType;
   DWORD    dwType;

   nLength  = strlen( lpszBuffer );

   pszwType = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );
 
   if ( pszwType ) {
       memset( pszwType, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            lpszBuffer,
                            nLength,
                            pszwType,
                            nLength + 1 );
   }
   dwType   = TypeFromString( pszwType );
   if ( pszwType ) 
	   free( pszwType );

   return dwType;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
void  StringFromType( DWORD dwType, CString& rString )
{
   TCHAR szText[ 128 ];

   StringFromType( dwType, szText );

   rString  = szText;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
void  StringFromType( DWORD dwType, TCHAR* lpszBuffer )
{
   switch( dwType )
   {
      case  NAMESPACE:
         _tcscpy( lpszBuffer, _T("Namespace") );
         break;

      case  NAMESPACES:
         _tcscpy( lpszBuffer, _T("Namespaces") );
         break;

      case  USER:
         _tcscpy( lpszBuffer, _T("User") );
         break;

      case  GROUP:
         _tcscpy( lpszBuffer, _T("Group") );
         break;

      case  DOMAIN:
         _tcscpy( lpszBuffer, _T("Domain") );
         break;

      case  COMPUTER:
         _tcscpy( lpszBuffer, _T("Computer") );
         break;

      case  SERVICE:
         _tcscpy( lpszBuffer, _T("Service") );
         break;

      case  FILESERVICE:
         _tcscpy( lpszBuffer, _T("FileService") );
         break;

      case  PRINTQUEUE:
         _tcscpy( lpszBuffer, _T("Printqueue") );
         break;

      case  PRINTER:
         _tcscpy( lpszBuffer, _T("Printer") );
         break;

      case  PRINTJOB:
         _tcscpy( lpszBuffer, _T("PrintJob") );
         break;

      case  PRINTDEVICE:
         _tcscpy( lpszBuffer, _T("PrintDevice") );
         break;

      case  SESSION:
         _tcscpy( lpszBuffer, _T("Session") );
         break;

      case  FILESHARE:
         _tcscpy( lpszBuffer, _T("FileShare") );
         break;

      case  RESOURCE:
         _tcscpy( lpszBuffer, _T("Resource") );
         break;

      case  NDSORG:
         _tcscpy( lpszBuffer, _T("Organization") );
         break;

      case  NDSROOT:
         _tcscpy( lpszBuffer, _T("Tree") );
         break;

      case  NDSOU:
         _tcscpy( lpszBuffer, _T("Organizational Unit") );
         break;

      case  NDSALIAS:
         _tcscpy( lpszBuffer, _T("Alias") );
         break;

      case  NDSDIRECTORYMAP:
         _tcscpy( lpszBuffer, _T("Directory Map") );
         break;

      case  NDSDISTRIBUTIONLIST:
         _tcscpy( lpszBuffer, _T("Distribution List") );
         break;

      case  NDSAFPSERVER:
         _tcscpy( lpszBuffer, _T("AFP Server") );
         break;

      case  NDSCOMMUNICATIONSSERVER:
         _tcscpy( lpszBuffer, _T("Communications Server") );
         break;

      case  NDSMESSAGEROUTINGGROUP:
         _tcscpy( lpszBuffer, _T("Message Routing Group") );
         break;

      case  NDSNETWARESERVER:
         _tcscpy( lpszBuffer, _T("NCP Server") );
         break;

      case  NDSORGANIZATIONALROLE:
         _tcscpy( lpszBuffer, _T("Organizational Role") );
         break;

      case  NDSPRINTQUEUE:
         _tcscpy( lpszBuffer, _T("Queue") );
         break;

      case  NDSPRINTSERVER:
         _tcscpy( lpszBuffer, _T("Print Server") );
         break;

      case  NDSPROFILE:
         _tcscpy( lpszBuffer, _T("Profile") );
         break;

      case  NDSVOLUME:
         _tcscpy( lpszBuffer, _T("Volume") );
         break;

      case  SCHEMA:
         _tcscpy( lpszBuffer, _T("Schema") );
         break;

      case  OTHER:
         _tcscpy( lpszBuffer, _T("Other") );
         break;

      case  CLASS:
         _tcscpy( lpszBuffer, _T("Class") );
         break;

      case  PROPERTY:
         _tcscpy( lpszBuffer, _T("Property") );
         break;

      case  SYNTAX:
         _tcscpy( lpszBuffer, _T("Syntax") );
         break;

      default:
         ASSERT( FALSE );
         _tcscpy( lpszBuffer, _T("") );
   }
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  MakeQualifiedName( TCHAR* strDest, TCHAR* strName, DWORD dwType )
{
   TCHAR szTemp[ 128 ];

   _tcscpy( strDest, strName );

   if( OTHER == dwType )
      return TRUE;

   StringFromType( dwType, szTemp );

   if( _tcslen( szTemp ) )
   {
      _tcscat( strDest, _T(",") );
   }
   _tcscat( strDest, szTemp );

   return TRUE;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  MakeQualifiedName ( CString& strDest, CString& strName, DWORD dwType )
{
   TCHAR szTemp[ 128 ];

   strDest  = strName;

   if( OTHER != dwType )
   {
      StringFromType( dwType, szTemp );
      strDest  = strDest + _T(',');
      strDest  = strDest + CString( szTemp );
   }

   return TRUE;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL     TryThisFilter( BSTR bstrObjectType, MEMBERS* pIGroup )
{
   VARIANT        v, varFilter, varOld;
   SAFEARRAY      *psaTry     = NULL;
   SAFEARRAYBOUND sabTryArray;
   HRESULT        hr;
   long           i;

   sabTryArray.cElements   = 1;
   sabTryArray.lLbound     = LBOUND;
   psaTry = SafeArrayCreate( VT_VARIANT, 1, &sabTryArray );

   if (!psaTry)
   {
      return FALSE;
   }

   VariantInit(&v);
   V_VT(&v)    = VT_BSTR;
   V_BSTR(&v)  = SysAllocString( bstrObjectType );
   i           = LBOUND;
   hr          = SafeArrayPutElement( psaTry, (long FAR *)&i, &v );

   while( TRUE )
   {
      if( FAILED( hr ) )
         break;

      hr = pIGroup->get_Filter( &varOld );
      if( FAILED( hr ) )
         break;

      VariantInit(&varFilter);

      V_VT(&varFilter)     = VT_VARIANT | VT_ARRAY;
      V_ARRAY( &varFilter)   = psaTry;
      hr = pIGroup->put_Filter( varFilter );
      if( FAILED( hr ) )
         break;

      hr = pIGroup->put_Filter( varOld );
      ASSERT( SUCCEEDED( hr ) );

      hr = VariantClear( &varOld );
      ASSERT( SUCCEEDED( hr ) );
      break;
   }
   SafeArrayDestroy( psaTry );

   return SUCCEEDED( hr );
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
HRESULT  BuildFilter( BOOL* pFilters, DWORD dwFilters, VARIANT* pvarFilter )
{
   VARIANT        varFilter;
   DWORD          dwIter, dwCount, dwType;
   SAFEARRAY      *psaFilter  = NULL;
   HRESULT        hResult;
   SAFEARRAYBOUND sabFilterArray;
   BSTR           bstrTexts[ LIMIT ];
   TCHAR          szType[ 128 ];

   dwCount  = 0L;

   for( dwType = 0L ; dwType < dwFilters ; dwType++ )
   {
      if( OTHER == dwType )
         continue;

      if( pFilters[ dwType ] )
      {
         StringFromType( dwType, szType );
         bstrTexts[ dwCount++ ]  = AllocBSTR( szType );
      }
   }

   sabFilterArray.cElements   = dwCount;
   sabFilterArray.lLbound     = LBOUND;
   psaFilter                  = SafeArrayCreate( VT_VARIANT, 1, &sabFilterArray );

   if ( psaFilter )
   {
      for( dwIter = LBOUND; dwIter < ( LBOUND + dwCount ); dwIter++ )
      {
         VariantInit(&varFilter);
         V_VT(&varFilter)    = VT_BSTR;

         V_BSTR(&varFilter)  = bstrTexts[ dwIter ];
         hResult     = SafeArrayPutElement( psaFilter,
                                            (long FAR *)&dwIter, &varFilter );
         ASSERT( SUCCEEDED( hResult ) );
         VariantClear( &varFilter );
      }

      V_VT(pvarFilter)     = VT_VARIANT | VT_ARRAY;
      V_ARRAY(pvarFilter)  = psaFilter;
   }
   else {
	  hResult = E_OUTOFMEMORY ;
   }

   // return SUCCEEDED( hResult );
   return hResult ;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL     SetFilter( IADsCollection* pIColl, BOOL* pFilters, DWORD dwFilters )
{
   VARIANT        v;
   HRESULT        hResult;

   hResult  = BuildFilter( pFilters, dwFilters, &v );

   if( SUCCEEDED( hResult ) )
   {
      /*hResult  = pIColl->put_Filter( v );
      if( FAILED( hResult ) )
      {
         TRACE( _T( "ERROR! put_Filter failed") );
      } */

      VariantClear( &v );
   }

   return SUCCEEDED( hResult );
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  SetFilter( MEMBERS* pIGroup, BOOL* pFilters, DWORD dwFilters )
{
   VARIANT        v;
   HRESULT        hResult;

   hResult  = BuildFilter( pFilters, dwFilters, &v );

   if( SUCCEEDED( hResult ) )
   {
      hResult  = pIGroup->put_Filter( v );
      if( FAILED( hResult ) )
      {
         TRACE( _T( "ERROR! put_Filter failed") );
      }

      VariantClear( &v );
   }

   return SUCCEEDED( hResult );
}



/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  SetFilter( IADsContainer* pIContainer, BOOL* pFilters, DWORD dwFilters )
{
   VARIANT        v;
   HRESULT        hResult;

   hResult  = BuildFilter( pFilters, dwFilters, &v );

   if( SUCCEEDED( hResult ) )
   {
      hResult  = pIContainer->put_Filter( v );
      if( FAILED( hResult ) )
      {
         TRACE( _T( "ERROR! put_Filter failed") );
      }

      VariantClear( &v );
   }

   return SUCCEEDED( hResult );
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
CString  OleDsGetErrorText ( HRESULT  hResult  )
{
   TCHAR szText[ 128 ];

   switch( hResult )
   {
      case  E_ADS_BAD_PATHNAME:
         return CString( _T("E_ADS_BAD_PATHNAME") );
         break;

      case  E_ADS_INVALID_DOMAIN_OBJECT:
         return CString( _T("E_ADS_INVALID_DOMAIN_OBJECT") );
         break;

      case  E_ADS_INVALID_USER_OBJECT:
         return CString( _T("E_ADS_INVALID_USER_OBJECT") );
         break;

      case  E_ADS_INVALID_COMPUTER_OBJECT:
         return CString( _T("E_ADS_INVALID_COMPUTER_OBJECT") );
         break;

      case  E_ADS_UNKNOWN_OBJECT:
         return CString( _T("E_ADS_UNKNOWN_OBJECT") );
         break;

      case  E_ADS_PROPERTY_NOT_SET:
         return CString( _T("E_ADS_PROPERTY_NOT_SET") );
         break;

      case  E_ADS_PROPERTY_NOT_SUPPORTED:
         return CString( _T("E_ADS_PROPERTY_NOT_SUPPORTED") );
         break;

      case  E_ADS_PROPERTY_INVALID:
         return CString( _T("E_ADS_PROPERTY_INVALID") );
         break;

      case  E_ADS_BAD_PARAMETER:
         return CString( _T("E_ADS_BAD_PARAMETER") );
         break;

      case  E_ADS_OBJECT_UNBOUND:
         return CString( _T("E_ADS_OBJECT_UNBOUND") );
         break;

      case  E_ADS_PROPERTY_NOT_MODIFIED:
         return CString( _T("E_ADS_PROPERTY_NOT_MODIFIED") );
         break;

      case  E_ADS_PROPERTY_MODIFIED:
         return CString( _T("E_ADS_PROPERTY_MODIFIED") );
         break;

      case  E_ADS_CANT_CONVERT_DATATYPE:
         return CString( _T("E_ADS_CANT_CONVERT_DATATYPE") );
         break;

      case  E_ADS_PROPERTY_NOT_FOUND:
         return CString( _T("E_ADS_PROPERTY_NOTFOUND") );
         break;

      case  E_ADS_OBJECT_EXISTS:
         return CString( _T("E_ADS_OBJECT_EXISTS") );
         break;

      case  E_ADS_SCHEMA_VIOLATION:
         return CString( _T("E_ADS_SCHEMA_VIOLATION") );
         break;

      case  E_ADS_COLUMN_NOT_SET:
         return CString( _T("E_ADS_COLUMN_NOT_SET") );
         break;

      case  E_ADS_INVALID_FILTER:
         return CString( _T("E_ADS_INVALID_FILTER") );
         break;

      //case  E_ADS_LDAP_BASE:
      //   return CString( _T("E_ADS_LDAP_BASE") );
      //   break;

      case  HRESULT_FROM_WIN32(ERROR_DS_OPERATIONS_ERROR):
         return CString( _T("ERROR_DS_OPERATIONS_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_PROTOCOL_ERROR):
         return CString( _T("ERROR_DS_PROTOCOL_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_TIMELIMIT_EXCEEDED):
         return CString( _T("ERROR_DS_TIMELIMIT_EXCEEDED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_SIZELIMIT_EXCEEDED):
         return CString( _T("ERROR_DS_SIZELIMIT_EXCEEDED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_COMPARE_FALSE):
         return CString( _T("ERROR_DS_COMPARE_FALSE") );
         break;


      case  HRESULT_FROM_WIN32(ERROR_DS_COMPARE_TRUE):
         return CString( _T("ERROR_DS_COMPARE_TRUE") );
         break;


      case  HRESULT_FROM_WIN32(ERROR_DS_AUTH_METHOD_NOT_SUPPORTED):
         return CString( _T("ERROR_DS_AUTH_METHOD_NOT_SUPPORTED") );
         break;


      case  HRESULT_FROM_WIN32(ERROR_DS_STRONG_AUTH_REQUIRED):
         return CString( _T("ERROR_DS_STRONG_AUTH_REQUIRED") );
         break;


      case  HRESULT_FROM_WIN32(ERROR_MORE_DATA):
         return CString( _T("ERROR_MORE_DATA") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_REFERRAL):
         return CString( _T("(ERROR_DS_REFERRAL") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_ADMIN_LIMIT_EXCEEDED):
         return CString( _T("ERROR_DS_ADMIN_LIMIT_EXCEEDED") );
         break;


      case  HRESULT_FROM_WIN32(ERROR_DS_UNAVAILABLE_CRIT_EXTENSION):
         return CString( _T("(ERROR_DS_UNAVAILABLE_CRIT_EXTENSION") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CONFIDENTIALITY_REQUIRED):
         return CString( _T("HRESULT_FROM_WIN32(ERROR_DS_CONFIDENTIALITY_REQUIRED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_NO_ATTRIBUTE_OR_VALUE):
         return CString( _T("ERROR_DS_NO_ATTRIBUTE_OR_VALUE") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED):
         return CString( _T("(ERROR_DS_ATTRIBUTE_TYPE_UNDEFINED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_INAPPROPRIATE_MATCHING):
         return CString( _T("(ERROR_DS_INAPPROPRIATE_MATCHING") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CONSTRAINT_VIOLATION):
         return CString( _T("ERROR_DS_CONSTRAINT_VIOLATION") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS):
         return CString( _T("ERROR_DS_ATTRIBUTE_OR_VALUE_EXISTS") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_INVALID_ATTRIBUTE_SYNTAX):
         return CString( _T("ERROR_DS_INVALID_ATTRIBUTE_SYNTAX") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_NO_SUCH_OBJECT):
         return CString( _T("ERROR_DS_NO_SUCH_OBJECT") );
         break;

      // case  HRESULT_FROM_WIN32(E_ADS_LDAP_ALIAS_PROBLEM:
         // return CString( _T("HRESULT_FROM_WIN32(E_ADS_LDAP_ALIAS_PROBLEM") );
         // break;

      case  HRESULT_FROM_WIN32(ERROR_DS_INVALID_DN_SYNTAX):
         return CString( _T("(ERROR_DS_INVALID_DN_SYNTAX") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_IS_LEAF):
         return CString( _T("(ERROR_DS_IS_LEAF") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_ALIAS_DEREF_PROBLEM):
         return CString( _T("(ERROR_DS_ALIAS_DEREF_PROBLEM") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_INAPPROPRIATE_AUTH):
         return CString( _T("(ERROR_DS_INAPPROPRIATE_AUTH") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_INVALID_PASSWORD):
         return CString( _T("(ERROR_INVALID_PASSWORD") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_ACCESS_DENIED):
         return CString( _T("ERROR_ACCESS_DENIED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_BUSY):
         return CString( _T("ERROR_DS_BUSY") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_UNAVAILABLE):
         return CString( _T("ERROR_DS_UNAVAILABLE") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_UNWILLING_TO_PERFORM):
         return CString( _T("ERROR_DS_UNWILLING_TO_PERFORM") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_LOOP_DETECT):
         return CString( _T("ERROR_DS_LOOP_DETECT") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_NAMING_VIOLATION):
         return CString( _T("ERROR_DS_NAMING_VIOLATION") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_OBJ_CLASS_VIOLATION):
         return CString( _T("ERROR_DS_OBJ_CLASS_VIOLATION") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CANT_ON_NON_LEAF):
         return CString( _T("ERROR_DS_CANT_ON_NONLEAF") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CANT_ON_RDN):
         return CString( _T("ERROR_DS_CANT_ON_RDN") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS):
         return CString( _T("ERROR_ALREADY_EXISTS") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CANT_MOD_OBJ_CLASS):
         return CString( _T("ERROR_DS_CANT_MOD_OBJ_CLASS") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_OBJECT_RESULTS_TOO_LARGE):
         return CString( _T("ERROR_DS_OBJECT_RESULTS_TOO_LARGE") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_AFFECTS_MULTIPLE_DSAS):
         return CString( _T("ERROR_DS_AFFECTS_MULTIPLE_DSAS") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_GEN_FAILURE):
         return CString( _T("(ERROR_GEN_FAILURE") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_SERVER_DOWN):
         return CString( _T("ERROR_DS_SERVER_DOWN") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_LOCAL_ERROR):
         return CString( _T("ERROR_DS_LOCAL_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_ENCODING_ERROR):
         return CString( _T("ERROR_DS_ENCODING_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_DECODING_ERROR):
         return CString( _T("(ERROR_DS_DECODING_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_TIMEOUT):
         return CString( _T("(ERROR_TIMEOUT") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_AUTH_UNKNOWN):
         return CString( _T("ERROR_DS_AUTH_UNKNOWN") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_FILTER_UNKNOWN):
         return CString( _T("(ERROR_DS_FILTER_UNKNOWN") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_CANCELLED):
         return CString( _T("(ERROR_CANCELLED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_PARAM_ERROR):
         return CString( _T("ERROR_DS_PARAM_ERROR") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY):
         return CString( _T("ERROR_NOT_ENOUGH_MEMORY") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_CONNECTION_REFUSED):
         return CString( _T("ERROR_CONNECTION_REFUSED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_NOT_SUPPORTED):
         return CString( _T("ERROR_DS_NOT_SUPPORTED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_NO_RESULTS_RETURNED):
         return CString( _T("ERROR_DS_NO_RESULTS_RETURNED") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CONTROL_NOT_FOUND):
         return CString( _T("ERROR_DS_CONTROL_NOT_FOUND") );
         break;

      // case  HRESULT_FROM_WIN32(E_ADS_LDAP_MORE_RESULTS_TO_RETURN:
         // return CString( _T("HRESULT_FROM_WIN32(E_ADS_LDAP_MORE_RESULTS_TO_RETURN") );
         // break;

      case  HRESULT_FROM_WIN32(ERROR_DS_CLIENT_LOOP):
         return CString( _T("(ERROR_DS_CLIENT_LOOP") );
         break;

      case  HRESULT_FROM_WIN32(ERROR_DS_REFERRAL_LIMIT_EXCEEDED):
         return CString( _T("ERROR_DS_REFERRAL_LIMIT_EXCEEDED") );
         break;

      // case  HRESULT_FROM_WIN32(E_ADS_LDAP_LAST:
         // return CString( _T("HRESULT_FROM_WIN32(E_ADS_LDAP_LAST") );
         // break;

      case  E_FAIL:
         return CString( _T("E_FAIL") );
         break;

      case  E_NOTIMPL:
         return CString( _T("E_NOIMPL") );
         break;

      case  S_OK:
         return CString( _T("OK") );
         break;

      case  0x800704b8:
      // we have an extended error
      {
         TCHAR szError[ 1024 ];
         WCHAR szErrorBuff[ 1024 ];
         WCHAR szNameBuff[ 1024 ];
         DWORD dwError;

         ADsGetLastError( &dwError,
                          szErrorBuff,
                          1023,
                          szNameBuff,
                          1023 );
         wcscat( szNameBuff, L" : " );
         wcscat( szNameBuff, szErrorBuff );

         _tcscpy( szError, _T("ERROR: ") );
         Convert( szError + _tcslen( szError ), szNameBuff );

         return CString( szError );
      }

      default:
      {
         LPVOID lpMsgBuf;
         UINT   nChars;

         nChars   = FormatMessage(
                            FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
                            NULL,
                            SCODE_CODE(hResult),
                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                            (LPTSTR) &lpMsgBuf,
                            0,
                            NULL
                           );

         if( nChars )
         {
            if( nChars != _tcslen( (LPTSTR)lpMsgBuf ) )
            {
               ((LPTSTR)lpMsgBuf)[nChars]  = _T('\0');
            }
            wsprintf( szText, _T("ERROR: %lx - %s"), hResult, (LPTSTR)lpMsgBuf );
            LocalFree( lpMsgBuf );

         }
         else
         {
            DWORD dwLastError;

            wsprintf( szText, _T("ERROR: %lx"), hResult );
            dwLastError = GetLastError();
         }
         return CString( szText );
         break;
      }
   }
}


/***********************************************************
  Function: BuildVariantArray
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
HRESULT  BuildVariantArray( VARTYPE vType,
                            CString& rText,
                            VARIANT& varRes,
                            TCHAR cSeparator )
{
   VARIANT        vTemp, vTyped;
   SAFEARRAY*     psa;
   SAFEARRAYBOUND sab;
   CStringArray   strArray;
   TCHAR*         strText;
   int            nItems   = 0;
   int            nIdx;
   int            nSize;
   LPTSTR         lpName;
   HRESULT        hResult;

   strText  = (TCHAR*) new TCHAR[ rText.GetLength( ) + 1 ];

   if( !strText )
   {
      return E_FAIL;
   }

   if( VT_I8 == vType )
   {
      vType = VT_R8;
   }

   _tcscpy( strText, rText.GetBuffer( rText.GetLength( ) ) );

   nSize    = rText.GetLength( );
   nItems   = nSize ? 1 : 0;
   for( nIdx = 0; nIdx < nSize ; nIdx++ )
   {
      if( strText[ nIdx ] == cSeparator )
      {
         nItems++;
         strText[ nIdx ] = _T('\0');
      }
   }

   sab.cElements   = nItems;
   sab.lLbound     = LBOUND;
   psa             = SafeArrayCreate( VT_VARIANT, 1, &sab );

   ASSERT( NULL != psa );

   if ( psa )
   {

      lpName      = strText;
      for( nIdx = LBOUND; nIdx < ( LBOUND + nItems ) ; nIdx++ )
      {
         while( *lpName == _T(' ') )
         {
            lpName++;
         }

         VariantInit( &vTemp );
         V_VT(&vTemp)  = VT_BSTR;

         V_BSTR(&vTemp) = AllocBSTR( lpName );
         lpName         = lpName + ( _tcslen( lpName ) + 1 );

         VariantInit( &vTyped );
         hResult  = VariantChangeType( &vTyped, &vTemp, VARIANT_NOVALUEPROP, vType );

         hResult  = SafeArrayPutElement( psa, (long FAR *)&nIdx, &vTyped );

         VariantClear( &vTyped );
         VariantClear( &vTemp );
         ASSERT( SUCCEEDED( hResult ) );
      }

      V_VT( &varRes )     = VT_VARIANT | VT_ARRAY;
      V_ARRAY( &varRes )  = psa;
   }
   else {
	  hResult = E_OUTOFMEMORY ;
   } ;

   delete [] strText;

   //return SUCCEEDED( hResult );
   return hResult ;

}


/***********************************************************
  Function: FromVariantArrayToString
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
CString  FromVariantArrayToString( VARIANT& v, TCHAR* pszSeparator )
{
   SAFEARRAY*  pSafeArray;
   TCHAR       szText[ 2048 ];
   VARIANT     var, varString;
   long        lBound, uBound, lItem;
   HRESULT     hResult;
   BOOL        bFirst;
   CString     strResult;


   // array of VT_UI1 (probably OctetString)
   if( (VT_ARRAY | VT_UI1) == V_VT( &v ) )
   {
      BYTE        bValue;

      pSafeArray  = V_ARRAY( &v );

      hResult     = SafeArrayGetLBound(pSafeArray, 1, &lBound);
      hResult     = SafeArrayGetUBound(pSafeArray, 1, &uBound);

      szText[ 0 ]    = _T('\0');

      for( lItem = lBound; lItem <= uBound ; lItem++ )
      {
         hResult  = SafeArrayGetElement( pSafeArray, &lItem, &bValue );
         if( FAILED( hResult ) )
         {
            break;
         }

         _stprintf( szText + _tcslen(szText), _T(" x%02x"), bValue );
         if( _tcslen( szText ) > 2044 )
            break;
      }

      return CString( szText );
   }

   if( V_VT( &v ) != (VT_VARIANT | VT_ARRAY) )
   {
      VARIANT  vString;

      TRACE( _T("Warning: Non array variant!!!\n") );
      VariantInit( &vString );

      hResult  = VariantChangeType( &vString, &v, VARIANT_NOVALUEPROP, VT_BSTR );
      if( FAILED( hResult ) )
      {
         V_VT( &vString )     = VT_BSTR;
         V_BSTR( &vString )   = AllocBSTR( _T("ERROR on conversion") );
      }
      _tcscpy( szText, _T("") );
      StringCat( szText, V_BSTR(&vString) );
      VariantClear( &vString);

      return CString( szText );
   }

   pSafeArray   = V_ARRAY( &v );

   hResult = SafeArrayGetLBound(pSafeArray, 1, &lBound);
   hResult = SafeArrayGetUBound(pSafeArray, 1, &uBound);

   VariantInit( &varString );
   szText[ 0 ]    = _T('\0');
   bFirst         = TRUE;

   for( lItem = lBound; lItem <= uBound ; lItem++ )
   {
      hResult  = SafeArrayGetElement( pSafeArray, &lItem, &var );
      if( FAILED( hResult ) )
      {
         break;
      }

      if( ConvertFromPropertyValue( var, szText ) )
      {
         V_VT( &varString )   = VT_BSTR;
         V_BSTR( &varString ) = AllocBSTR( szText );
         hResult  = S_OK;
      }
      else
      {
         hResult  = VariantChangeType( &varString, &var,
                                       VARIANT_NOVALUEPROP, VT_BSTR );
      }

      if( SUCCEEDED( hResult ) )
      {
         _tcscpy( szText, _T("") );
         if( !bFirst )
         {
            if( NULL == pszSeparator )
            {
               _tcscat( szText, SEPARATOR_S );
            }
            else
            {
               _tcscat( szText, pszSeparator );
            }
         }

         StringCat( szText, V_BSTR( &varString ) );

         bFirst   = FALSE;
         VariantClear( &varString );

         strResult  += szText;
      }

      VariantClear( &var );
   }

   return strResult;
}



/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
CString  FromVariantToString( VARIANT& v)
{
   return FromVariantArrayToString( v );
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
COleDsObject*  CreateOleDsObject( DWORD  dwType, IUnknown* pIUnk )
{
   COleDsObject*  pObject;

   switch( dwType )
   {
      case  DOMAIN:
         pObject  = new COleDsDomain( pIUnk );
         break;

      case  COMPUTER:
         pObject  = new COleDsComputer( pIUnk );
         break;

      case  USER:
         pObject  = new COleDsUser( pIUnk );
         break;

      case  GROUP:
         pObject  = new COleDsGroup( pIUnk );
         break;

      case  SERVICE:
         pObject  = new COleDsService( pIUnk );
         break;

      case  FILESERVICE:
         pObject  = new COleDsFileService( pIUnk );
         break;

      case  PRINTQUEUE:
         pObject  = new COleDsPrintQueue( pIUnk );
         break;

      case  PRINTJOB:
         pObject  = new COleDsPrintJob( pIUnk );
         break;

      case  PRINTDEVICE:
         pObject  = new COleDsPrintDevice( pIUnk );
         break;

      case  SESSION:
         pObject  = new COleDsSession( pIUnk );
         break;

      case  FILESHARE:
         pObject  = new COleDsFileShare( pIUnk );
         break;

      case  RESOURCE:
         pObject  = new COleDsResource( pIUnk );
         break;

      case  NAMESPACE:
         pObject  = new COleDsNamespace( pIUnk );
         break;

      case  NAMESPACES:
         pObject  = new COleDsNamespaces( pIUnk );
         break;
      case  NDSROOT:
      case  NDSORG:
      case  NDSOU:
      case  PRINTER:
      case  NDSALIAS:
      case  NDSDIRECTORYMAP:
      case  NDSDISTRIBUTIONLIST:
      case  NDSAFPSERVER:
      case  NDSCOMMUNICATIONSSERVER:
      case  NDSMESSAGEROUTINGGROUP:
      case  NDSNETWARESERVER:
      case  NDSORGANIZATIONALROLE:
      case  NDSPRINTQUEUE:
      case  NDSPRINTSERVER:
      case  NDSPROFILE:
      case  NDSVOLUME:
      case  OTHER:
      case  CLASS:
      case  SCHEMA:
      case  PROPERTY:
      case  SYNTAX:
         pObject  = new COleDsGeneric( pIUnk );
         break;

      default:
         ASSERT( FALSE );
         pObject  = new COleDsObject( pIUnk );
         break;

   }

   return pObject;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
void  ErrorOnPutProperty( CString& strFuncSet,
						        CString& strProperty,
                          CString& strPropValue,
                          HRESULT  hResult,
                          BOOL     bGeneric,
                          BOOL     bUseEx )
{
   CErrorDialog   aErrorDialog;
   CString        strOperation;

   if( !bGeneric )
   {
      strOperation   = _T("put_");
      strOperation  += strProperty;
   }
   else
   {
      strOperation   = _T("Put");
      if( bUseEx )
      {
         strOperation  += _T("Ex");
      }
      strOperation  += _T("( ");
      strOperation  += strProperty;
      strOperation  += _T(", ...)");
   }


   //aErrorDialog.m_FuncSet  = strFuncSet;
   aErrorDialog.m_Operation   = strOperation;
   aErrorDialog.m_Value       = strPropValue;
   aErrorDialog.m_Result      = OleDsGetErrorText( hResult );

   aErrorDialog.DoModal( );
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  CheckIfValidClassName( WCHAR* lpszClassName )
{
   TCHAR szClassName[ 512 ];
   BSTR bszClassName = NULL ;

   if( !lpszClassName )
   {
      TRACE( _T("Oops! Found NULL class name: %s\n"), lpszClassName );
      return TRUE;
   }

   if( !_wcsicmp( lpszClassName, L"Namespace") )
      return TRUE;

   if( !_wcsicmp( lpszClassName, L"Namespaces") )
      return TRUE;

   if( !_wcsicmp( lpszClassName, L"User") )
      return TRUE;

   if( !_wcsicmp( lpszClassName, L"Group") )
      return TRUE;

   if( !_wcsicmp( lpszClassName, L"Domain") )
      return TRUE;

   if( !_wcsicmp( lpszClassName, L"Computer") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"Service") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"FileService") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"Printqueue") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"Printjob") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"PrintDevice") )
      return  TRUE;

   if( !_wcsicmp( lpszClassName, L"Session") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Resource") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"FileShare") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Tree") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Organization") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Organizational Unit") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"OrganizationalUnit") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Printer") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Class") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Property") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Syntax") )
      return   TRUE;

   if( !_wcsicmp( lpszClassName, L"Schema") )
      return   TRUE;

   _tcscpy( szClassName, _T("") );
   bszClassName = ::SysAllocString( lpszClassName ) ;
   StringCat( szClassName, bszClassName );
   if ( bszClassName ) {
	   ::SysFreeString( bszClassName ) ;
   }

   TRACE( _T("Oops! Found unknown class name: %s\n"), szClassName );

   return TRUE;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BOOL  CheckIfValidClassName( CHAR* pszClassName )
{
   int      nLength;
   WCHAR*   pszwClassName;
   BOOL     bRez = FALSE ;

   nLength        = strlen( pszClassName );

   pszwClassName  = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );
   if ( pszwClassName ) {
	   memset( pszwClassName, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            pszClassName,
                            nLength,
                            pszwClassName,
                            nLength + 1 );

       bRez  = CheckIfValidClassName( pszwClassName );

       free( pszwClassName );
   }

   return bRez;


   return TRUE;
}


/***********************************************************
  Function:
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
int   GetImageListIndex( DWORD dwObjectType )
{
   int   nIndex;

   nIndex   = 0;
   dwObjectType   = dwObjectType >> 1;
   while( dwObjectType )
   {
      nIndex++;
      dwObjectType   = dwObjectType >> 1;
   }

   return nIndex;
}


/***********************************************************
  Function:    GetBitmapImageId
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
UINT  GetBitmapImageId( DWORD dwObjectType )
{
   switch( dwObjectType )
   {
      case  USER:
         return IDB_USER;

      case  SERVICE:
         return IDB_SERVICE;

      case  DOMAIN:
         return IDB_DOMAIN;

      case  COMPUTER:
         return IDB_COMPUTER;

      case  PRINTQUEUE:
      case  PRINTER:
         return IDB_PRINTQUEUE;

      case  FILESHARE:
         return IDB_FILESHARE;

      case  GROUP:
         return IDB_GROUP;

      case  SESSION:
         return IDB_SESSION;

      case  RESOURCE:
         return IDB_RESOURCE;

      case  PRINTJOB:
         return IDB_PRINTJOB;

      case  NDSROOT:
         return IDB_ROOT;

      case  NDSORG:
         return IDB_ORGANISATION;

      case  NDSOU:
         return IDB_ORGANISATIONUNIT;

      case  NAMESPACES:
         return IDB_NAMESPACES;

      case  NAMESPACE:
         return IDB_NAMESPACE;

      case  NDSALIAS:
         return IDB_NDS_ALIAS;

      case  NDSDIRECTORYMAP:
         return IDB_NDS_DIRECTORY_MAP;

      case  NDSDISTRIBUTIONLIST:
         return IDB_NDS_DISTRIBUTION_LIST;

      case  NDSAFPSERVER:
         return IDB_NDS_AFP_SERVER;

      case  NDSCOMMUNICATIONSSERVER:
         return IDB_NDS_COMMUNICATIONS_SERVER;

      case  NDSMESSAGEROUTINGGROUP:
         return IDB_NDS_MESSAGE_ROUTING_GROUP;

      case  NDSNETWARESERVER:
         return IDB_NDS_NETWARE_SERVER;

      case  NDSORGANIZATIONALROLE:
         return IDB_NDS_ORGANIZATIONAL_ROLE;

      case  NDSPRINTQUEUE:
         return IDB_NDS_PRINT_QUEUE;

      case  NDSPRINTSERVER:
         return IDB_NDS_PRINT_SERVER;

      case  NDSPROFILE:
         return IDB_NDS_PROFILE;

      case  NDSVOLUME:
         return IDB_NDS_VOLUME;

      case  SYNTAX:
         return IDB_SYNTAX;

      case  PROPERTY:
         return IDB_PROPERTY;

      case  CLASS:
      case  SCHEMA:
         return IDB_CLASS;

      default:
         return IDB_DUMMY;
   }
}


/***********************************************************
  Function:    AllocBSTR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BSTR  AllocBSTR( WCHAR* pszwString )
{
   return SysAllocString( pszwString );
}


/***********************************************************
  Function:    AllocBSTR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
***********************************************************/
BSTR  AllocBSTR( CHAR* pszString )
{
   int      nLength;
   WCHAR*   pszwString;
   BSTR     bstrText;

   nLength     = strlen( pszString );

   pszwString  = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );

   if ( pszwString ) {
       memset( pszwString, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            pszString,
                            nLength,
                            pszwString,
                            nLength + 1 );
   }
   bstrText    = AllocBSTR( pszwString );
   if ( pszwString ) {
       free( pszwString );
   }

   return bstrText;
}


/*******************************************************************
  Function:    Get
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  Get( IADs* pIOleDs, CHAR* pszProperty, VARIANT* pVar)
{
   int      nLength;
   WCHAR*   pszwProperty;
   HRESULT  hResult;

   nLength        = strlen( pszProperty );

   pszwProperty   = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );
   if ( pszwProperty ) {
       memset( pszwProperty, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            pszProperty,
                            nLength,
                            pszwProperty,
                            nLength + 1 );

       hResult  = Get( pIOleDs, pszwProperty, pVar );
       free( pszwProperty );
   }
   else {
	   hResult = E_OUTOFMEMORY ;
   }

   return hResult;
}


/*******************************************************************
  Function:    Get
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  Get( IADs* pIOleDs, WCHAR* pszwProperty, VARIANT* pVar)
{
   HRESULT  hResult;
   BSTR bszProperty = ::SysAllocString( pszwProperty ) ;

   VariantInit( pVar );

   hResult  = pIOleDs->Get( bszProperty, pVar );
   if ( bszProperty ) {
	   ::SysFreeString( bszProperty ) ;
   }

   return hResult;
}


/*******************************************************************
  Function:    Put
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  Put( IADs* pIOleDs, CHAR* pszProperty, VARIANT Var)
{
   int      nLength;
   WCHAR*   pszwProperty;
   HRESULT  hResult;

   nLength        = strlen( pszProperty );

   pszwProperty   = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );
   if ( pszwProperty ) {
       memset( pszwProperty, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            pszProperty,
                            nLength,
                            pszwProperty,
                            nLength + 1 );

       hResult  = Put( pIOleDs, pszwProperty, Var ) ;
       free( pszwProperty );
   }
   else {
	   hResult = E_OUTOFMEMORY ;
   } ;

   return hResult;
}


/*******************************************************************
  Function:    Put
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  Put( IADs* pIOleDs, WCHAR* pszwProperty, VARIANT Var)
{
   HRESULT  hResult;
   BSTR bszProperty = ::SysAllocString( pszwProperty ) ;
   hResult  = pIOleDs->Put( bszProperty, Var );
   if ( bszProperty ) {
	   ::SysFreeString( bszProperty ) ;
   }

   return hResult;
}


/*******************************************************************
  Function:    XGetOleDsObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  XOleDsGetObject( WCHAR* pszwPath, REFIID refiid, void** pVoid )
{
   // cahged to add the hack for Win95.
   HRESULT  hResult;

   hResult  = ADsGetObject( pszwPath, refiid, pVoid );
   if( FAILED( hResult ) )
   {
      // now's the hack.
      // Danilo says take OLE DS paths and prepent a "@"
      // to and change the first ":" into a "!"
      WCHAR szHackPath[ 256 ];

      // first, add @
      wcscpy( szHackPath, L"@" );
      wcscat( szHackPath, pszwPath );

      // second, change the first ":" into a "!"
      for( UINT nIdx = 0 ; nIdx < wcslen( szHackPath ); nIdx++ )
      {
         if( szHackPath[ nIdx ] == L':' )
         {
            szHackPath[ nIdx ] = L'!';
            break;
         }
      }

      hResult  = ADsGetObject( szHackPath, refiid, pVoid );
   }

   return hResult;
}


/*******************************************************************
  Function:    XGetOleDsObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  XOleDsGetObject( CHAR* pszPath, REFIID refiid, void** pVoid )
{
   int      nLength;
   WCHAR*   pszwPath;
   HRESULT  hResult;

   nLength  = strlen( pszPath );

   pszwPath = (WCHAR*) malloc( ( nLength + 1 ) * sizeof(WCHAR) );
   if ( pszwPath ) {
       memset( pszwPath, 0, ( nLength + 1 ) * sizeof(WCHAR) );

       MultiByteToWideChar( CP_ACP,
                            MB_PRECOMPOSED,
                            pszPath,
                            nLength,
                            pszwPath,
                            nLength + 1 );

       hResult  = XOleDsGetObject( pszwPath, refiid, pVoid );
       free( pszwPath );
   }
   else {
	   hResult = E_OUTOFMEMORY ;
   }

   return hResult;
}


/*******************************************************************
  Function:    XOleDsOpenObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  XOleDsOpenObject( WCHAR* lpszPathName,
                           WCHAR* lpszUserName,
                           WCHAR* lpszPassword,
                           REFIID refiid,
                           void** pVoid )
{
   HRESULT  hResult;

   hResult  = ADsOpenObject(
                             lpszPathName,
                             lpszUserName,
                             lpszPassword,
                             NULL,
                             refiid,
                             pVoid );
   if( FAILED( hResult ) )
   {
      // now's the hack.
      // Danilo says take OLE DS paths and prepent a "@"
      // to and change the first ":" into a "!"
      WCHAR szHackPath[ 256 ];

      // first, add @
      wcscpy( szHackPath, L"@" );
      wcscat( szHackPath, lpszPathName );

      // second, change the first ":" into a "!"
      for( UINT nIdx = 0 ; nIdx < wcslen( szHackPath ); nIdx++ )
      {
         if( szHackPath[ nIdx ] == L':' )
         {
            szHackPath[ nIdx ] = L'!';
            break;
         }
      }
      hResult  = ADsOpenObject( szHackPath,
                                lpszUserName,
                                lpszPassword,
                                NULL,
                                refiid,
                                pVoid );
   }

   return hResult;
}


/*******************************************************************
  Function:    XOleDsOpenObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  XOleDsOpenObject( CHAR* lpszPathName,
                           CHAR* lpszUserName,
                           CHAR* lpszPassword,
                           REFIID refiid,
                           void** pVoid )
{
   BSTR     bstrPathName, bstrUserName, bstrPassword;
   HRESULT  hResult;

   bstrPathName   = AllocBSTR( lpszPathName );
   bstrUserName   = AllocBSTR( lpszUserName );
   bstrPassword   = AllocBSTR( lpszPassword );

   hResult  = XOleDsOpenObject( bstrPathName, bstrUserName, bstrPassword,
                                refiid, pVoid );

   SysFreeString( bstrPathName );
   SysFreeString( bstrUserName );
   SysFreeString( bstrPassword );

   return hResult;
}



/*******************************************************************
  Function:    StringCat
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
void  StringCat( WCHAR* pszString, BSTR bstrText )
{
   wcscat( pszString, bstrText );
}


/*******************************************************************
  Function:    StringCat
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
void  StringCat( CHAR* pszString, BSTR bstrText )
{
   CHAR* pszText;
   UINT  nLength;
   CHAR  defChar  = ' ';
   BOOL  bUseDefault;
   int   nRez;
   DWORD dwError;

   nLength  = SysStringLen( bstrText );
   pszText  = (CHAR*) malloc( (nLength + 1) * sizeof(CHAR) );
   if ( pszText ) {
       memset( pszText, 0, (nLength + 1) * sizeof(CHAR) );

	   nRez  = WideCharToMultiByte( CP_ACP,
                                    0L,
                                    bstrText,
                                    nLength,
                                    pszText,
                                    nLength + 1,
                                    &defChar,
                                    &bUseDefault );
       if( !nRez )
       {
          dwError  = GetLastError( );
       }

       strcat( pszString, pszText );
   }

   free( pszText );
}


/*******************************************************************
  Function:    XGetOleDsObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
void  SetLastProfileString( TCHAR* szSection, CString& rValue )
{
   WritePrivateProfileString( _T("LastParameters"), szSection,
                              rValue.GetBuffer( 256 ), _T("adsvw.ini") );
}


/*******************************************************************
  Function:    SetLastProfileString
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
void  GetLastProfileString( TCHAR* szSection, CString& rValue )
{
   TCHAR szValue[ 256 ];

   GetPrivateProfileString( _T("LastParameters"), szSection,
                            _T(""), szValue, 255, _T("adsvw.ini") );

   rValue   = szValue;
}


/*******************************************************************
  Function:    GetByteValue
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
BYTE  GetByteValue( TCHAR* szString )
{
   BYTE  bBytes[ 2 ];

   bBytes[ 0 ] = bBytes[ 1 ]  = 0;

   for( int i = 0; i < 2 ; i++ )
   {
      if( !szString[ i ] )
         break;

#ifdef UNICODE
      if( !iswdigit( szString[ i ] ) )
      {
         bBytes[ i ] = ( (BYTE) ( szString[ i ] ) ) - 0x37;
      }
#else
      if( !isdigit( szString[ i ] ) )
      {
         bBytes[ i ] = ( (BYTE) ( szString[ i ] ) ) - 0x37;
      }
#endif
      else
      {
         bBytes[ i ] = ( (BYTE) ( szString[ i ] ) ) - 0x30;
      }
   }

   return ( bBytes[ 0 ] << 4 ) + bBytes[ 1 ];
}

/*******************************************************************
  Function:    CreateBlobArray
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  CreateBlobArrayFromFile( CString& rText, VARIANT& rBlob )
{
   TCHAR*         pszFileName;
   TCHAR          pszTemp[ 2 * MAX_PATH ];
   CFile          aFile;
   CFileException e;

   rText.TrimLeft( );

   _tcscpy( pszTemp, (LPCTSTR)rText );
   pszFileName = pszTemp;

   pszFileName   += _tcslen( _T("[FILE]") );
   while( *pszFileName == _T(' ') )
      pszFileName++;

   if( !aFile.Open( pszFileName, CFile::modeRead, &e ) )
   {

#ifdef _DEBUG
      afxDump << "File could not be opened " << e.m_cause << "\n";
#endif
   }
   else
   {
      SAFEARRAY*     psa;
      SAFEARRAYBOUND sab;
      LONG           lItem;
      DWORD          dwIdx;
      DWORD          dwRead;
      HRESULT        hResult;
      BYTE           bBuffer[ 128 ];

      sab.cElements  = (ULONG)(aFile.GetLength( ));
      sab.lLbound    = LBOUND;
      psa            = SafeArrayCreate( VT_UI1, 1, &sab );
      lItem          = LBOUND;

      while( TRUE )
      {
         dwRead   = aFile.Read( (LPVOID)bBuffer, 128 );

         for( dwIdx = 0; dwIdx < dwRead ; dwIdx++ )
         {
            hResult  = SafeArrayPutElement( psa, &lItem, bBuffer + dwIdx );
            ASSERT( SUCCEEDED( hResult ) );
         }
         if( dwRead != 128 )
            break;
      }

      V_VT( &rBlob )     = VT_UI1 | VT_ARRAY;
      V_ARRAY( &rBlob )  = psa;

      aFile.Close( );
   }

   return S_OK;
}


/*******************************************************************
  Function:    CreateBlobArray
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  CreateBlobArray( CString& rText, VARIANT& rBlob )
{
   SAFEARRAY*     psa;
   SAFEARRAYBOUND sab;
   TCHAR*         strText;
   int            nItems   = 0;
   int            nIdx;
   int            nSize;
   HRESULT        hResult;
   BYTE           bVal;

   rText.MakeUpper( );
   rText.TrimLeft( );

   if( !_tcsnicmp( (LPCTSTR)rText,
                   _T("[FILE]"),
                   min( (int)rText.GetLength( ), (int)_tcslen( _T("[FILE]") ) )
                 )
     )
   {
      hResult  = CreateBlobArrayFromFile( rText, rBlob );
      return hResult;
   }

   strText  = (TCHAR*) new TCHAR[ rText.GetLength( ) + 1 ];
   if( !strText )
   {
      return E_FAIL;
   }

   _tcscpy( strText, rText.GetBuffer( rText.GetLength( ) ) );
   nSize    = rText.GetLength( );
   nItems   = 0;
   for( nIdx = 0; nIdx < nSize ; nIdx++ )
   {
      if( strText[ nIdx ] == _T('X') )
      {
         nItems++;
      }
   }

   sab.cElements   = nItems;
   sab.lLbound     = LBOUND;
   psa             = SafeArrayCreate( VT_UI1, 1, &sab );
   ASSERT( NULL != psa );
   if ( psa )
   {
      nItems = 0;

      for( nIdx = LBOUND; nIdx < ( LBOUND + nSize ); nIdx++ )
      {
         if( strText[ nIdx ] == _T('X') )
         {
            bVal  = GetByteValue( strText + nIdx + 1 );
            hResult  = SafeArrayPutElement( psa, (long FAR *)&nItems, &bVal );
            nIdx += 3;
            nItems++;
         }
      }
      V_VT( &rBlob )     = VT_UI1 | VT_ARRAY;
      V_ARRAY( &rBlob )  = psa;
   }

   delete [] strText;

   return hResult;
}


/*******************************************************************
  Function:    CreateBlobArrayEx
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
*******************************************************************/
HRESULT  CreateBlobArrayEx( CString& rText, VARIANT& rBlob, TCHAR cSeparator )
{
   SAFEARRAY*     psa;
   SAFEARRAYBOUND sab;
   TCHAR*         strText;
   TCHAR*         strStore;
   int            nItems   = 0;
   int            nIdx;
   int            nSize;
   HRESULT        hResult;

   rText.MakeUpper( );

   strText  = (TCHAR*) new TCHAR[ rText.GetLength( ) + 1 ];
   strStore = strText;
   if( !strText )
   {
      return E_FAIL;
   }

   _tcscpy( strText, rText.GetBuffer( rText.GetLength( ) ) );
   nSize    = rText.GetLength( );
   nItems   = 1;
   for( nIdx = 0; nIdx < nSize ; nIdx++ )
   {
      if( strText[ nIdx ] == cSeparator )
      {
         strText[ nIdx ]   = _T('\0');
         nItems++;
      }
   }

   sab.cElements   = nItems;
   sab.lLbound     = LBOUND;
   psa             = SafeArrayCreate( VT_VARIANT, 1, &sab );
   ASSERT( NULL != psa );
   if ( psa )
   {
      for( nIdx = LBOUND; nIdx < ( LBOUND + nItems ) ; nIdx++ )
      {
         VARIANT  var;
         CString  strTemp;

         strTemp  = strText;
         strText += _tcslen( strText ) + 1;

         CreateBlobArray( strTemp, var );
         hResult  = SafeArrayPutElement( psa, (long FAR *)&nIdx, &var );
         VariantClear( &var );
      }

      V_VT( &rBlob )     = VT_VARIANT | VT_ARRAY;
      V_ARRAY( &rBlob )  = psa;
   }
   else {
	   hResult = E_OUTOFMEMORY ;
   }

   delete [] strStore;

   return hResult;
}


/******************************************************************************
  Function:    Convert
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
void  Convert( CHAR* pszDest, WCHAR* pszwSrc )
{
   int   nRes  = 0;

   if( wcslen( pszwSrc ) )
   {
      nRes  = WideCharToMultiByte( CP_ACP,
                                   WC_COMPOSITECHECK,
                                   pszwSrc,
                                   wcslen( pszwSrc ),
                                   pszDest,
                                   wcslen( pszwSrc ) + 1,
                                   NULL,
                                   NULL );
      ASSERT( nRes );
   }

   pszDest[ nRes ]	= '\0';

}


/******************************************************************************
  Function:    Convert
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
void  Convert  ( WCHAR* pszwDest, CHAR* pszSrc )
{
   BSTR  bstrTemp;

   bstrTemp = AllocBSTR( pszSrc );
   wcscpy( pszwDest, bstrTemp );
   SysFreeString( bstrTemp );
}


/******************************************************************************
  Function:    Convert
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
void  Convert  ( WCHAR* pszwDest, WCHAR* pszwSrc )
{
   wcscpy( pszwDest, pszwSrc );
}


/******************************************************************************
  Function:    Convert
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
void  Convert( CHAR* pszDest, CHAR* pszSrc )
{
   strcpy( pszDest, pszSrc );
}


/******************************************************************************
  Function:    StringToLARGE_INTEGER
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
HRESULT     StringToLARGE_INTEGER( TCHAR* szString, LARGE_INTEGER* pValue )
{
	if ( 0 == _stscanf( szString, _T("%I64d"), pValue ) ) {
		pValue = NULL ;
	}

   return S_OK;

   HRESULT  hResult;
   VARIANT  vString, vR8;
   double   dLowPart, dHighPart;
   ULONG    ulLowPart, ulHighPart;
   WCHAR    szValue[ 32 ];

   VariantInit( &vString );
   VariantInit( &vR8 );

   V_VT( &vString )   = VT_BSTR;
   Convert( szValue, szString );
   V_BSTR( &vString ) = szValue;

   hResult  = VariantChangeType( &vR8, &vString, VARIANT_NOVALUEPROP, VT_R8 );
   if( SUCCEEDED( hResult ) )
   {
      dHighPart   = V_R8( &vR8 ) / ((double) 1.0 + (double)(ULONG_MAX));
      ulHighPart  = (ULONG)dHighPart;
      dHighPart   = (double)ulHighPart;
      dLowPart    = V_R8( &vR8 ) - dHighPart*((double) 1.0 + (double)(ULONG_MAX));
      ulLowPart   = (ULONG)dLowPart;

      pValue->HighPart= (LONG)ulHighPart;
      pValue->LowPart = ulHighPart;
   }

   return hResult;
}


/******************************************************************************
  Function:    StringToLARGE_INTEGER
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
HRESULT     LARGE_INTEGERToString( TCHAR* szString,
                                   LARGE_INTEGER* pValue )
{
   if ( pValue ) {
	   _stprintf( szString, _T("%I64d"), pValue->QuadPart );
   }
   return S_OK;

   /*TCHAR    szText[ 32 ];
   DWORD    dwStatus;
   BOOL     bOK   = FALSE;

   HMODULE  hModule;

   while( TRUE )
   {
      hModule  = LoadLibrary( _T("NTDLL.DLL" ) );
      if( NULL == hModule )
         break;

      LargeIntegerToString = (LARGEINTTOSTRING)GetProcAddress( hModule, _T("RtlLargeIntegerToChar") );
      if( NULL == LargeIntegerToString )
         break;

      dwStatus = LargeIntegerToString( pValue, 10, 31, szText );
      if( 0 == dwStatus )
      {
         Convert( szString, szText );
         bOK   = TRUE;
      }

      break;
   }

   if( NULL != hModule )
   {
      FreeLibrary( hModule );
   }

   if( bOK )
   {
      return S_OK;
   }


   HRESULT  hResult;
   double   dVal;
   VARIANT  vString, vR8;

   dVal  = (double)pValue->HighPart;
   dVal  = dVal * ( (double) 1.0 + (double)(ULONG_MAX) );

   dVal  = dVal + (double)pValue->LowPart;


   VariantInit( &vString );
   VariantInit( &vR8 );

   V_VT( &vR8 )   = VT_R8;
   V_R8( &vR8 )   = dVal;

   hResult  = VariantChangeType( &vString, &vR8, VARIANT_NOVALUEPROP, VT_BSTR );
   ASSERT( SUCCEEDED( hResult ) );

   if( SUCCEEDED( hResult ) )
   {

      Convert( szString, V_BSTR( &vString ) );
      VariantClear( &vString );
   }

   return hResult;*/
}


/******************************************************************************
  Function:    CopyACE
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
IDispatch*  CopyACE( IDispatch*  pSrc )
{
   IADsAccessControlEntry* pACE;
   IADsAccessControlEntry* pSrcACE;
   IDispatch*              pNewACE  = NULL;
   HRESULT                 hResult;
   LONG                    lValue;
   BSTR                    bstrValue   = NULL;

   hResult  = pSrc->QueryInterface( IID_IADsAccessControlEntry, (void**)&pSrcACE );

   if( FAILED( hResult ) )
      return NULL;


   hResult = CoCreateInstance(
                               CLSID_AccessControlEntry,
                               NULL,
                               CLSCTX_INPROC_SERVER,
                               IID_IADsAccessControlEntry,
                               (void **)&pACE );
   if( SUCCEEDED( hResult ) )
   {
      //******************************************
      hResult  = pSrcACE->get_AccessMask( &lValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_AccessMask( lValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_AccessMask returns %lx\n"), hResult );
         }
      }

      //******************************************
      hResult  = pSrcACE->get_AceType( &lValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_AceType( lValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_AceType returns %lx\n"), hResult );
         }
      }

      //******************************************
      hResult  = pSrcACE->get_AceFlags( &lValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_AceFlags( lValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_AceFlags returns %lx\n"), hResult );
         }
      }

      //******************************************
      hResult  = pSrcACE->get_Flags( &lValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_Flags( lValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_Flags returns %lx\n"), hResult );
         }
      }

      //******************************************
      hResult  = pSrcACE->get_ObjectType( &bstrValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_ObjectType( bstrValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_ObjectType returns %lx\n"), hResult );
         }
         SysFreeString( bstrValue );
         bstrValue   = NULL;

      }

      //******************************************
      hResult  = pSrcACE->get_InheritedObjectType( &bstrValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_InheritedObjectType( bstrValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_InheritedObjectType returns %lx\n"), hResult );
         }
         SysFreeString( bstrValue );
         bstrValue   = NULL;
      }


      //******************************************
      hResult  = pSrcACE->get_Trustee( &bstrValue );
      ASSERT( SUCCEEDED( hResult ) );

      if( SUCCEEDED( hResult ) )
      {
         hResult  = pACE->put_Trustee( bstrValue );
         if( FAILED( hResult ) )
         {
            TRACE( _T("[ADSI] Error: put_Trustee returns %lx\n"), hResult );
         }
         SysFreeString( bstrValue );
         bstrValue   = NULL;
      }
      hResult  = pACE->QueryInterface( IID_IDispatch, (void**)&pNewACE );
      pACE->Release( );

   }

   pSrcACE->Release( );

   return pNewACE;
}


/******************************************************************************
  Function:    CopyACL
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
IDispatch*  CopyACL( IDispatch*  pSrcACL )
{
   IADsAccessControlList*  pACL        = NULL;
   IADsAccessControlList*  pADsNewACL  = NULL;
   IDispatch*              pNewACL     = NULL;
   IUnknown*               pEnum       = NULL;
   IEnumVARIANT*           pEnumVAR    = NULL;
   HRESULT                 hResult;
   LONG                    lValue;
   ULONG                   lGet;
   VARIANT                 var;

   hResult  = pSrcACL->QueryInterface( IID_IADsAccessControlList, (void**)&pACL );

   while( TRUE )
   {
      if( FAILED( hResult ) )
         break;

      hResult  = pACL->CopyAccessList( &pNewACL );
      if( FAILED( hResult ) )
      {
         TRACE( _T("[ADSI] Error: CopyAccessList returns %lx\n"), hResult );
      }

      if( SUCCEEDED( hResult ) )
         break;

      hResult  = CoCreateInstance(
                                   CLSID_AccessControlList,
                                   NULL,
                                   CLSCTX_INPROC_SERVER,
                                   IID_IADsAccessControlList,
                                   (void **)&pADsNewACL );

      ASSERT( SUCCEEDED( hResult ) );
      if( FAILED( hResult ) )
         break;

      hResult  = pACL->get_AclRevision( &lValue );
      if( SUCCEEDED( hResult ) )
      {
         hResult  = pADsNewACL->put_AclRevision( lValue );
         ASSERT( SUCCEEDED( hResult ) );
      }

      hResult  = pACL->get__NewEnum( &pEnum );
      ASSERT( SUCCEEDED( hResult ) );
      if( FAILED( hResult ) )
         break;

      hResult  = pEnum->QueryInterface( IID_IEnumVARIANT, (void**)&pEnumVAR );
      ASSERT( SUCCEEDED( hResult ) );
      if( FAILED( hResult ) )
         break;

      while( TRUE )
      {
         lGet  = 0;
         VariantInit( &var );

         hResult  = pEnumVAR->Next( 1, &var,  &lGet );
         if( 0 == lGet )
            break;

         hResult  = pADsNewACL->AddAce( CopyACE( V_DISPATCH( &var ) ) );
         VariantClear( &var );
      }

      hResult  = pADsNewACL->QueryInterface( IID_IDispatch, (void**)& pNewACL );
      break;
   }

   if( NULL != pACL )
      pACL->Release( );

   if( NULL != pADsNewACL )
      pADsNewACL->Release( );

   if( NULL != pEnum )
      pEnum->Release( );

   if( NULL != pEnumVAR )
      pEnumVAR->Release( );

   return pNewACL;
}


/******************************************************************************
  Function:    CopySD
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
IDispatch*  CopySD( IDispatch*  pSrcSD )
{
   IADsSecurityDescriptor* pSD;
   IDispatch*              pNewSD  = NULL;
   IADsSecurityDescriptor* pADsNewSD  = NULL;
   HRESULT                 hResult;
   LONG                    lValue;
   BSTR                    bstrValue;
   IDispatch*              pACL;

   //hResult  = pSrcSD->QueryInterface( IID_IDispatch, (void**)&pNewSD );

   //return pNewSD;

   hResult  = pSrcSD->QueryInterface( IID_IADsSecurityDescriptor, (void**)&pSD );

   while( TRUE )
   {
      if( FAILED( hResult ) )
         break;

      hResult  = pSD->CopySecurityDescriptor( &pNewSD );
      if( FAILED( hResult ) )
      {
         TRACE( _T("[ADSI] Error: CopySecurityDescriptor returns %lx\n"), hResult );
      }

      if( SUCCEEDED( hResult ) )
      {
         pSD->Release( );
         break;
      }

      hResult  = CoCreateInstance(
                                   CLSID_SecurityDescriptor,
                                   NULL,
                                   CLSCTX_INPROC_SERVER,
                                   IID_IADsSecurityDescriptor,
                                   (void **)&pADsNewSD );

      ASSERT( SUCCEEDED( hResult ) );

      if( FAILED( hResult ) )
         break;

      hResult  = pSD->get_Revision( &lValue );
      if( SUCCEEDED( hResult ) )
      {
         hResult  = pADsNewSD->put_Revision( lValue );
         ASSERT( SUCCEEDED( hResult ) );
      }

      hResult  = pSD->get_Control( &lValue );
      if( SUCCEEDED( hResult ) )
      {
         hResult  = pADsNewSD->put_Control( lValue );
         ASSERT( SUCCEEDED( hResult ) );
      }

      hResult  = pSD->get_Owner( &bstrValue );
      if( SUCCEEDED( hResult ) )
      {
         hResult  = pADsNewSD->put_Owner( bstrValue );
         ASSERT( SUCCEEDED( hResult ) );
         SysFreeString( bstrValue );
      }

      hResult  = pSD->get_Group( &bstrValue );
      if( SUCCEEDED( hResult ) )
      {
         hResult  = pADsNewSD->put_Group( bstrValue );
         ASSERT( SUCCEEDED( hResult ) );
         SysFreeString( bstrValue );
      }

      hResult  = pSD->get_DiscretionaryAcl( &pACL );
      if( SUCCEEDED( hResult ) && NULL != pACL )
      {
         IDispatch*  pCopy;

         pCopy = CopyACL( pACL );
         if( NULL != pCopy )
         {
            hResult  = pADsNewSD->put_DiscretionaryAcl( pCopy );
            ASSERT( SUCCEEDED( hResult ) );
            pCopy->Release( );
         }
         pACL->Release( );
      }

      hResult  = pSD->get_SystemAcl( &pACL );
      if( SUCCEEDED( hResult ) && NULL != pACL )
      {
         IDispatch*  pCopy;

         pCopy = CopyACL( pACL );
         if( NULL != pCopy )
         {
            hResult  = pADsNewSD->put_SystemAcl( pCopy );
            ASSERT( SUCCEEDED( hResult ) );
            pCopy->Release( );
         }
         pACL->Release( );
      }

      hResult  = pADsNewSD->QueryInterface( IID_IDispatch, (void**)&pNewSD );
      ASSERT( SUCCEEDED( hResult ) );

      pADsNewSD->Release( );

      break;
   }

   return pNewSD;
}

/******************************************************************************
  Function:    ConvertFromPropertyValue
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
BOOL  ConvertFromPropertyValue( VARIANT& rVar, TCHAR* szText )
{
   IADsPropertyValue*   pPropValue  = NULL;
   HRESULT              hResult;
   long                 lType;
   BSTR                 bstrVal = NULL;

   if( VT_DISPATCH != V_VT(&rVar ) )
      return FALSE;

   hResult  = V_DISPATCH( &rVar )->QueryInterface( IID_IADsPropertyValue, (void**)&pPropValue );
   if( FAILED( hResult ) )
      return FALSE;

   while( TRUE )
   {
      hResult  = pPropValue->get_ADsType( &lType );
      if( FAILED( hResult ) )
         break;

      switch( (ADSTYPEENUM)lType )
      {
         case  ADSTYPE_DN_STRING:
         {
            hResult  = pPropValue->get_DNString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               Convert( szText, bstrVal );
               SysFreeString( bstrVal );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_DNString returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_CaseExactString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_CaseExactString should fail\n") );
               SysFreeString( bstrVal );
            }

            break;
         }

         case  ADSTYPE_CASE_EXACT_STRING:
         {
            hResult  = pPropValue->get_CaseExactString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               Convert( szText, bstrVal );
               SysFreeString( bstrVal );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_CaseExactString returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_DNString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_DNString should fail\n") );
               SysFreeString( bstrVal );
            }

            break;
         }

         case  ADSTYPE_CASE_IGNORE_STRING:
         {
            hResult  = pPropValue->get_CaseIgnoreString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               Convert( szText, bstrVal );
               SysFreeString( bstrVal );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_CaseIgnoreString returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_DNString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_DNString should fail\n") );
               SysFreeString( bstrVal );
            }

            break;
         }

         case  ADSTYPE_PRINTABLE_STRING:
         {
            hResult  = pPropValue->get_PrintableString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               Convert( szText, bstrVal );
               SysFreeString( bstrVal );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_PrintableString returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_DNString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_DNString should fail\n") );
               SysFreeString( bstrVal );
            }

            break;
         }

         case  ADSTYPE_NUMERIC_STRING:
         {
            hResult  = pPropValue->get_NumericString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               Convert( szText, bstrVal );
               SysFreeString( bstrVal );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_NumericString returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_DNString( &bstrVal );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_DNString should fail\n") );
               SysFreeString( bstrVal );
            }

            break;
         }

         case  ADSTYPE_BOOLEAN:
         {
            long  lValue;

            hResult  = pPropValue->get_Boolean( &lValue );
            if( SUCCEEDED( hResult ) )
            {
               _ltot( lValue, szText, 10 );
            }
            else
            {
               TRACE( _T("[ADSVW] Error: get_Boolean returns %lx\n"), hResult );
            }
            hResult  = pPropValue->get_Integer( &lValue );
            if( SUCCEEDED( hResult ) )
            {
               TRACE( _T("[ADSVW] Error: get_Integer should fail\n") );
            }

            break;
         }


         default:
            ASSERT( FALSE );
            break;
      }

      break;
   }

   pPropValue->Release( );

   return TRUE;
}


/******************************************************************************
  Function:    PurgeObject
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
HRESULT  PurgeObject( IADsContainer* pParent, IUnknown* pIUnknown, LPWSTR pszPrefix )
{
   BSTR              bstrName       = NULL;
   BSTR              bstrClass      = NULL;
   VARIANT           var;
   HRESULT           hResult;
   IUnknown*         pIChildUnk     = NULL;
   IADs*             pIChildOleDs   = NULL;
   IADs*             pADs;
   BSTR              bstrObjName, bstrObjClass;
   IEnumVARIANT*     pIEnumVar   = NULL;
   IADsContainer*    pIContainer = NULL;
   ULONG             ulFetch     = 0L;
   //BOOL              bDelete;

   if( NULL == pParent || NULL == pIUnknown )
      return FALSE;

   hResult  = pIUnknown->QueryInterface( IID_IADs,
                                         (void**)&pADs );
   if( FAILED( hResult ) )
      return FALSE;

   pADs->get_Name( &bstrObjName );
   pADs->get_Class( &bstrObjClass );
   pADs->Release( );


   hResult  = pIUnknown->QueryInterface( IID_IADsContainer,
                                         (void**)&pIContainer );
   if( FAILED( hResult ) )
   {
      if( NULL != pszPrefix && !_wcsnicmp( bstrObjName, pszPrefix, wcslen(pszPrefix) ) )
      {
         hResult  = pParent->Delete( bstrObjClass, bstrObjName );
         TRACE( _T("Delete %S returns %lx\n"), bstrObjName, hResult );
      }
      if( NULL == pszPrefix )
      {
         hResult  = pParent->Delete( bstrObjClass, bstrObjName );
         TRACE( _T("Delete %S returns %lx\n"), bstrObjName, hResult );
      }

      SysFreeString( bstrObjClass );
      SysFreeString( bstrObjName );
      return S_OK;
   }


   hResult  = ADsBuildEnumerator( pIContainer, &pIEnumVar );

   while( SUCCEEDED( hResult ) )
   {
      ulFetch  = 0L;

      hResult  = ADsEnumerateNext( pIEnumVar, 1, &var, &ulFetch );
      if( FAILED( hResult ) )
         continue;

      if( !ulFetch )
         break;

      V_DISPATCH( &var )->QueryInterface( IID_IUnknown, (void**)&pIChildUnk );

      VariantClear( &var );

      if( NULL != pIChildUnk )
      {
         PurgeObject( pIContainer, pIChildUnk, pszPrefix );
         pIChildUnk->Release( );
      }
      pIChildUnk  = NULL;
   }

   if( NULL != pIEnumVar )
   {
      ADsFreeEnumerator( pIEnumVar );
   }
   pIContainer->Release( );

   hResult  = pParent->Delete( bstrObjClass, bstrObjName );

   TRACE( _T("\tDelete %S (%S) ends with %lx\n"), bstrObjName, bstrObjClass );

   SysFreeString( bstrObjClass );
   SysFreeString( bstrObjName );

   return hResult;
}


/******************************************************************************
  Function:    Bolb2String
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
CString  Blob2String( void* pData, DWORD dwSize )
{
   DWORD    dwIdx;
   TCHAR*   pText;
   BYTE*    pByte = (BYTE*)pData;
   CString  strText;

   pText = (TCHAR*)AllocADsMem( 1 + dwSize * 3 * sizeof( TCHAR ) );
   memset( pText, 0, 1 + dwSize * 3 * sizeof( TCHAR ) );


   for( dwIdx = 0; dwIdx < dwSize ; dwIdx++ )
   {
      _stprintf( pText + _tcslen(pText),
                 _T("%02x"),
                 ((BYTE*)pData)[ dwIdx ] );
   }

   strText  = pText;
   FreeADsMem( pText );

   return strText;
}


/******************************************************************************
  Function:    String2Blob
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
HRESULT  String2Blob( TCHAR* pszText, void** ppData, DWORD* pdwLength )
{
   HRESULT     hResult;
   CString     strText;
   VARIANT     vBlob;
   SAFEARRAY*  pSafeArray;
   long        lBound, uBound, lItem;
   BYTE*       pbData;

   strText     = pszText;
   *pdwLength  = 0;

   hResult     = CreateBlobArray( strText, vBlob );
   if( FAILED( hResult ) )
   {
      return hResult;
   }

   pSafeArray  = V_ARRAY( &vBlob );

   hResult     = SafeArrayGetLBound(pSafeArray, 1, &lBound);
   hResult     = SafeArrayGetUBound(pSafeArray, 1, &uBound);
   *pdwLength  = (uBound - lBound + 1);

   pbData      = (BYTE*) AllocADsMem( sizeof(BYTE) * (uBound - lBound + 1) );

   for( lItem = lBound; lItem <= uBound ; lItem++ )
   {
      hResult  = SafeArrayGetElement( pSafeArray,
                                      &lItem,
                                      pbData + (lItem - lBound) );
      if( FAILED( hResult ) )
      {
         ASSERT( FALSE );
         break;
      }
   }

   *ppData  = (void*)pbData;

   return hResult;
}


/******************************************************************************
  Function:    AllocTCHAR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
TCHAR*   AllocTCHAR ( CHAR* pszText )
{
   TCHAR*   pszAlloc = NULL;

   while( TRUE )
   {
      ASSERT( NULL != pszText );
      if( NULL == pszText )
         break;

      pszAlloc = (TCHAR*) AllocADsMem( sizeof(TCHAR)*(strlen(pszText) + 1) );
      if( NULL == pszAlloc )
         break;

      Convert( pszAlloc, pszText );
      break;
   }

   return pszAlloc;
}



/******************************************************************************
  Function:    AllocTCHAR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
WCHAR*   AllocWCHAR ( CHAR* pszText )
{
   WCHAR*   pszAlloc = NULL;

   while( TRUE )
   {
      ASSERT( NULL != pszText );
      if( NULL == pszText )
         break;

      pszAlloc = (WCHAR*) AllocADsMem( sizeof(WCHAR)*(strlen(pszText) + 1) );
      if( NULL == pszAlloc )
         break;

      Convert( pszAlloc, pszText );
      break;
   }

   return pszAlloc;
}


/******************************************************************************
  Function:    AllocTCHAR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
TCHAR*   AllocTCHAR( WCHAR* pszText )
{
   TCHAR*   pszAlloc = NULL;

   while( TRUE )
   {
      ASSERT( NULL != pszText );
      if( NULL == pszText )
         break;

      pszAlloc = (TCHAR*) AllocADsMem( sizeof(TCHAR)*(wcslen(pszText) + 1) );
      if( NULL == pszAlloc )
         break;

      Convert( pszAlloc, pszText );
      break;
   }

   return pszAlloc;
}

/******************************************************************************
  Function:    AllocTCHAR
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
WCHAR*   AllocWCHAR( WCHAR* pszText )
{
   WCHAR*   pszAlloc = NULL;

   while( TRUE )
   {
      ASSERT( NULL != pszText );
      if( NULL == pszText )
         break;

      pszAlloc = (WCHAR*) AllocADsMem( sizeof(WCHAR)*(wcslen(pszText) + 1) );
      if( NULL == pszAlloc )
         break;

      Convert( pszAlloc, pszText );
      break;
   }

   return pszAlloc;
}


/*****************************************************************************
  Function:    GetVARIANTSize
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
long  GetVARIANTSize( VARIANT &rVar )
{
   SAFEARRAY      *psa = NULL;
   HRESULT        hResult;
   long           lLow, lUp;

   ASSERT( VT_ARRAY & V_VT( &rVar ) );

   if( !( VT_ARRAY & V_VT( &rVar ) ) )
      return -1;

   psa   = V_ARRAY(&rVar);

   if( NULL == psa )
      return 0;

   hResult  = SafeArrayGetLBound( psa, 1, &lLow );
   hResult  = SafeArrayGetUBound( psa, 1, &lUp );

   return (lUp - lLow + 1);
}

/*****************************************************************************
  Function:    GetVARIANTAt
  Arguments:
  Return:
  Purpose:
  Author(s):
  Revision:
  Date:
******************************************************************************/
HRESULT  GetVARIANTAt( long lIdx, VARIANT& vArray, VARIANT &vItem )
{
   SAFEARRAY      *psa = NULL;
   HRESULT        hResult;
   long           lLow, lUp, lPos;

   if( !( VT_ARRAY & V_VT( &vArray ) ) )
      return E_FAIL;

   psa   = V_ARRAY(&vArray);

   if( NULL == psa )
      return E_FAIL;

   VariantInit( &vItem );

   hResult  = SafeArrayGetLBound( psa, 1, &lLow );
   hResult  = SafeArrayGetUBound( psa, 1, &lUp );

   lPos     = lLow + lIdx;
   hResult  = SafeArrayGetElement( psa, &lPos, &vItem );

   return hResult;
}


/******************************************************************************
  Function:    GetValuesCount
  Arguments:   szText   - ptr to TCHAR string to be "tokanized"
               cSep     - Token separator
  Return:      number of tokens in szText (cSep being the token separator)
  Purpose:     The method id used to parse strings. The most common usage is for
               a string containing multiple values.
  Author(s):   cezaru
  Revision:    1
  Date:        08/10/97
******************************************************************************/
long  GetValuesCount( CString& szText, TCHAR cSep  )
{
   int   nIter;
   long  lCount   = 0;

   for( nIter = 0; nIter < szText.GetLength( ) ; nIter++ )
   {
      if( cSep == szText.GetAt( nIter ) )
         lCount++;
   }

   return ++lCount;
}


/******************************************************************************
  Function:    GetElements
  Arguments:   szText   string to be parsed
               cSep     token separator character
               lValues  tokens count
  Return:      an array of strings, each string being a token
  Purpose:     breaks a string into multiple tokens
  Author(s):   cezaru
  Revision:    1
  Date:        08/10/97
******************************************************************************/
CString GetValueAt( CString& szText, TCHAR cSep, long lValue )
{
   TCHAR*  pszString;
   long    lIter, lPos, lVal, lLength;
   TCHAR*  pszTemp;
   CString  strRes;

   if( lValue >=  GetValuesCount( szText, cSep ) )
      return _T("");

   lIter = 0;
   lPos  = 0;
   lLength     = sizeof(TCHAR) * ( 1 + szText.GetLength( ) );
   pszTemp     = (TCHAR*)  AllocADsMem( lLength );

   pszString   = (TCHAR*) AllocADsMem( lLength );


   while( lIter < lValue )
   {
      if( szText.GetAt( lPos++ ) == cSep )
         lIter++;
   }

   lVal  = 0;

   while( lPos < szText.GetLength( ) && szText.GetAt( lPos ) != cSep )
   {
      pszTemp[ lVal++ ] = szText.GetAt( lPos );
      pszTemp[ lVal ]   = _T('\0');
      lPos++;
   }

   strRes   = pszTemp;

   FreeADsMem( pszTemp );

   return strRes;
}


/******************************************************************************
  Function:    CreateLargeInteger
  Arguments:
  Return:
  Purpose:
  Author(s):   cezaru
  Revision:    1
  Date:        08/10/97
******************************************************************************/
IDispatch* CreateLargeInteger( CString& strText )
{
   LARGE_INTEGER     aLargeInteger;
   IADsLargeInteger* pLInt = NULL;
   IDispatch*        pDisp = NULL;
   HRESULT           hResult;


   while( TRUE )
   {
      hResult  = StringToLARGE_INTEGER( strText.GetBuffer( 128 ), &aLargeInteger );

      hResult = CoCreateInstance(
                               CLSID_LargeInteger,
                               NULL,
                               CLSCTX_INPROC_SERVER,
                               IID_IADsLargeInteger,
                               (void **)&pLInt );

      ASSERT( SUCCEEDED( hResult ) );
      if( FAILED( hResult ) )
      {
         TRACE( "\tERROR: CoCreateInstance(CLSID_LargeInteger,...) fails with %lx\n", hResult );
         break;
      }

      pLInt->put_HighPart( (LONG)aLargeInteger.HighPart );
      pLInt->put_LowPart(  (LONG)aLargeInteger.LowPart );

      hResult  = pLInt->QueryInterface( IID_IDispatch, (void**)&pDisp );

      pLInt->Release( );
      break;
   }

   return pDisp;
}



/******************************************************************************
  Function:    FromLargeInteger
  Arguments:
  Return:
  Purpose:
  Author(s):   cezaru
  Revision:    1
  Date:        08/10/97
******************************************************************************/
CString FromLargeInteger( IDispatch* pDisp )
{
   LARGE_INTEGER     aLargeInteger;
   IADsLargeInteger* pLInt = NULL;
   HRESULT           hResult;
   TCHAR             szText[ 128 ];

   _tcscpy( szText, _T("") );

   while( TRUE )
   {
      hResult  = pDisp->QueryInterface( IID_IADsLargeInteger, (void**)&pLInt );
      if( FAILED( hResult ) )
         break;

      hResult  = pLInt->get_HighPart( &aLargeInteger.HighPart );
      hResult  = pLInt->get_LowPart( (long*) &aLargeInteger.LowPart );
      pLInt->Release( );

      hResult  = LARGE_INTEGERToString( szText, &aLargeInteger );
      break;
   }

   return szText;
}