windows-server-2003/admin/snapin/dsadmin/newobj.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1997 - 1999
//
//  File:       newobj.cpp
//
//--------------------------------------------------------------------------

/////////////////////////////////////////////////////////////////////
//	newobj.cpp
//
//	Implementation of the CNewADsObjectCreateInfo class.
//
//	HISTORY
//	20-Aug-97	Dan Morin	Creation.
//
/////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "resource.h"

#include "dsutil.h"
#include "util.h"
#include "uiutil.h"

#include "newobj.h"


///////////////////////////////////////////////////////////////////////
// GUIDs for the DS Admin default wizards


// {DE41B65A-8960-11d1-B93C-00A0C9A06D2D}
static const GUID USER_WIZ_GUID   = { 0xde41b65a, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B65B-8960-11d1-B93C-00A0C9A06D2D}
static const GUID VOLUME_WIZ_GUID = { 0xde41b65b, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B65C-8960-11d1-B93C-00A0C9A06D2D}
static const GUID COMPUTER_WIZ_GUID = { 0xde41b65c, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B65D-8960-11d1-B93C-00A0C9A06D2D}
static const GUID PRINTQUEUE_WIZ_GUID = { 0xde41b65d, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B65E-8960-11d1-B93C-00A0C9A06D2D}
static const GUID GROUP_WIZ_GUID = { 0xde41b65e, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {C05C260F-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID CONTACT_WIZ_GUID = { 0xc05c260f, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {DE41B65F-8960-11d1-B93C-00A0C9A06D2D}
static const GUID NTDSCONN_WIZ_GUID = { 0xde41b65f, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B660-8960-11d1-B93C-00A0C9A06D2D}
static const GUID FIXEDNAME_WIZ_GUID = { 0xde41b660, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
#ifdef FRS_CREATE
// {DE41B661-8960-11d1-B93C-00A0C9A06D2D}
static const GUID FRS_SUBSCRIBER_WIZ_GUID = { 0xde41b661, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
#endif // FRS_CREATE
// {DE41B662-8960-11d1-B93C-00A0C9A06D2D}
static const GUID SITE_WIZ_GUID = { 0xde41b662, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B663-8960-11d1-B93C-00A0C9A06D2D}
static const GUID SUBNET_WIZ_GUID = { 0xde41b663, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {DE41B664-8960-11d1-B93C-00A0C9A06D2D}
static const GUID OU_WIZ_GUID = { 0xde41b664, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };

// {DE41B667-8960-11d1-B93C-00A0C9A06D2D}
static const GUID SERVER_WIZ_GUID = { 0xde41b667, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
#ifdef FRS_CREATE
// {DE41B668-8960-11d1-B93C-00A0C9A06D2D}
static const GUID FRS_REPLICA_SET_WIZ_GUID = { 0xde41b668, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
// {C05C260C-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID FRS_MEMBER_WIZ_GUID = { 0xc05c260c, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
#endif // FRS_CREATE
// {C05C260D-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID SITE_LINK_WIZ_GUID = { 0xc05c260d, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C260E-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID SITE_LINK_BRIDGE_WIZ_GUID = { 0xc05c260e, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
/*
// {C05C2610-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2610, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2611-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2611, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2612-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2612, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2613-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2613, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2614-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2614, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2615-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2615, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2616-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2616, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2617-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2617, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2618-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2618, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C2619-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c2619, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261A-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261a, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261B-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261b, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261C-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261c, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261D-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261d, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261E-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261e, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
// {C05C261F-9DCA-11D1-B9B2-00C04FD8D5B0}
static const GUID <<name>> = { 0xc05c261f, 0x9dca, 0x11d1, { 0xb9, 0xb2, 0x0, 0xc0, 0x4f, 0xd8, 0xd5, 0xb0 } };
*/
/////////////////////////////////////////////////////////////////////
//	Structure to build a lookup table to match an object class
//	to a "create routine".

// flags for the _CREATE_NEW_OBJECT::dwFlags field
#define CNOF_STANDALONE_UI 0x00000001

struct _CREATE_NEW_OBJECT	// cno
{
	LPCWSTR pszObjectClass;				// Class of object to create. eg: user, computer, volume.
	PFn_HrCreateADsObject pfnCreate;	// Pointer to "create routine" to create the new object
	const GUID* pWizardGUID;            // guid of the DS Admin create wizard
	PVOID pvCreationParameter;			// Optional creation parameter
  DWORD dwFlags;                  // miscellanea flags
};

/////////////////////////////////////////////////////////////////////
//
// Lookup table
//
// Each entry contains an attribute and a pointer to a routine to create the object.
// If the attribute is not found in the table, then the object will be created
// using the HrCreateADsObject() routine.
//
static const _CREATE_NEW_OBJECT g_rgcno[] =
	{
	{ gsz_user,                   HrCreateADsUser,                &USER_WIZ_GUID,       NULL, CNOF_STANDALONE_UI },
#ifdef INETORGPERSON
  { gsz_inetOrgPerson,          HrCreateADsUser,                &USER_WIZ_GUID,       NULL, CNOF_STANDALONE_UI },
#endif
	{ gsz_volume,                 HrCreateADsVolume,              &VOLUME_WIZ_GUID,     NULL, CNOF_STANDALONE_UI },
	{ gsz_computer,               HrCreateADsComputer,            &COMPUTER_WIZ_GUID,   NULL, CNOF_STANDALONE_UI },
	{ gsz_printQueue,             HrCreateADsPrintQueue,          &PRINTQUEUE_WIZ_GUID, NULL, CNOF_STANDALONE_UI },
	{ gsz_group,                  HrCreateADsGroup,               &GROUP_WIZ_GUID,      NULL, CNOF_STANDALONE_UI },
  { gsz_contact,                  HrCreateADsContact,           &CONTACT_WIZ_GUID,    NULL, CNOF_STANDALONE_UI },

	{ gsz_nTDSConnection,         HrCreateADsNtDsConnection,      &NTDSCONN_WIZ_GUID,   NULL, 0x0 },

	// Note that names of DS objects are not internationalized.  I will leave
	// this string out of the resource file to make sure that INTL doesn't try
	// to internationalize it.
	{ gsz_nTDSSiteSettings,       HrCreateADsFixedName,           &FIXEDNAME_WIZ_GUID, (PVOID)L"NTDS Site Settings", 0x0 },
	{ gsz_serversContainer,       HrCreateADsFixedName,           &FIXEDNAME_WIZ_GUID, (PVOID)L"Servers", 0x0 },
	// CODEWORK could have a special wizard but this will do for now
	{ gsz_licensingSiteSettings,  HrCreateADsFixedName,           &FIXEDNAME_WIZ_GUID, (PVOID)L"Licensing Site Settings", 0x0 },
	{ gsz_siteLink,               HrCreateADsSiteLink,            &SITE_LINK_WIZ_GUID,  NULL, 0x0 },
	{ gsz_siteLinkBridge,         HrCreateADsSiteLinkBridge,      &SITE_LINK_BRIDGE_WIZ_GUID, NULL, 0x0 },


#ifdef FRS_CREATE
	//
	// FRS stuff
	//
	{ gsz_nTFRSSettings,          HrCreateADsFixedName,           &FIXEDNAME_WIZ_GUID, (PVOID)L"FRS Settings", 0x0 },
	{ gsz_nTFRSReplicaSet,        HrCreateADsSimpleObject,        &FRS_REPLICA_SET_WIZ_GUID, NULL, 0x0 },
	{ gsz_nTFRSMember,            HrCreateADsNtFrsMember,         &FRS_MEMBER_WIZ_GUID, NULL, 0x0 },
	// CODEWORK fixed name doesn't mesh with the ability to create a subtree of these
	{ gsz_nTFRSSubscriptions,     CreateADsNtFrsSubscriptions,    &FIXEDNAME_WIZ_GUID, (PVOID)L"FRS Subscriptions", 0x0 },
	{ gsz_nTFRSSubscriber,        HrCreateADsNtFrsSubscriber,     &FRS_SUBSCRIBER_WIZ_GUID,     NULL, 0x0 },
#endif // FRS_CREATE

	{ gsz_server,                 HrCreateADsServer,              &SERVER_WIZ_GUID,     NULL, 0x0 },
	{ gsz_site,                   HrCreateADsSite,                &SITE_WIZ_GUID,       NULL, 0x0 },
	{ gsz_subnet,                 HrCreateADsSubnet,              &SUBNET_WIZ_GUID,     NULL, 0x0 },

	{ gsz_organizationalUnit,     HrCreateADsOrganizationalUnit,  &OU_WIZ_GUID,         NULL, CNOF_STANDALONE_UI },

	};

////////////////////////////////////////////////////////////////////////////
// MarcoC: 
// Test only: simple dump function to print the table above
// need this to dump formatted table for documentation.

/*
void DumpCreateTable()
{
	for (int i = 0; i < LENGTH(g_rgcno); i++)
	{
		ASSERT(g_rgcno[i].pszObjectClass != NULL);
    WCHAR szBuf[256];
    StringFromGUID2(*(g_rgcno[i].pWizardGUID), szBuf, 256);
    LPCWSTR lpsz = (g_rgcno[i].dwFlags & CNOF_STANDALONE_UI) ? L"Y" : L"N";
    TRACE(L"%s\t%s\t%s\n", g_rgcno[i].pszObjectClass, szBuf, lpsz);
	} // for
}
*/

////////////////////////////////////////////////////////////////////////////
// simple lookup function to return the internal handler inf given
// a class name
BOOL FindHandlerFunction(/*IN*/ LPCWSTR lpszObjectClass, 
                         /*OUT*/ PFn_HrCreateADsObject* ppfFunc,
                         /*OUT*/ void** ppVoid)
{
  *ppfFunc = NULL;
  *ppVoid = NULL;
	for (int i = 0; i < ARRAYLEN(g_rgcno); i++)
	{
		ASSERT(g_rgcno[i].pszObjectClass != NULL);
		ASSERT(g_rgcno[i].pfnCreate != NULL);
    // compare class name
		if (0 == lstrcmp(g_rgcno[i].pszObjectClass, lpszObjectClass))
		{
      // found matching class, get the function from it
			*ppfFunc = g_rgcno[i].pfnCreate;
			*ppVoid = g_rgcno[i].pvCreationParameter;
      return TRUE;
    } // if
	} // for
  return FALSE;
}


/////////////////////////////////////////////////////////////////////////////////////
// Hackarama fix

HRESULT HrCreateFixedNameHelper(/*IN*/ LPCWSTR lpszObjectClass,
                                /*IN*/ LPCWSTR lpszAttrString, // typically "cn="
                                /*IN*/ IADsContainer* pIADsContainer)
{
  // find the fixed name on the table
  LPCWSTR lpszName = NULL;
	for (int i = 0; i < ARRAYLEN(g_rgcno); i++)
	{
		ASSERT(g_rgcno[i].pszObjectClass != NULL);
    // compare class name
		if (0 == lstrcmp(g_rgcno[i].pszObjectClass, lpszObjectClass))
		{
			lpszName = (LPCWSTR)(g_rgcno[i].pvCreationParameter);
      break;
    } // if
	} // for

  ASSERT(lpszName != NULL);
  if (lpszName == NULL)
    return E_INVALIDARG;

  // create the temporary object
  CString szAdsName;
  szAdsName.Format(_T("%s%s"), (LPCWSTR)lpszAttrString, lpszName);
  IDispatch* pIDispatch = NULL;
  HRESULT hr = pIADsContainer->Create(CComBSTR(lpszObjectClass),
		                                CComBSTR(szAdsName),
		                                &pIDispatch);
  if (FAILED(hr))
    return hr; // could not create
  ASSERT(pIDispatch != NULL);

  IADs* pIADs = NULL;
	hr = pIDispatch->QueryInterface(IID_IADs, (LPVOID *)&pIADs);
  pIDispatch->Release();
	if (FAILED(hr)) 
    return hr; // should never happen!!!

  //commit object
  hr = pIADs->SetInfo();
  pIADs->Release();
  return hr;
}


////////////////////////////////////////////////////////////////////////////
// This function just returns the values from the internal table
// To be used when other type of data retrieval fails
// returns S_OK if the info was found, E_FAIL if not
STDAPI DsGetClassCreationInfoInternal(LPCWSTR pClassName, LPDSCLASSCREATIONINFO* ppInfo)
{
  if (ppInfo == NULL)
    return E_INVALIDARG;

  *ppInfo = (DSCLASSCREATIONINFO*)::LocalAlloc(LPTR, sizeof(DSCLASSCREATIONINFO));
  if (*ppInfo != NULL)
  {
    ZeroMemory(*ppInfo, sizeof(DSCLASSCREATIONINFO));

	  for (int i = 0; i < ARRAYLEN(g_rgcno); i++)
	  {
		  ASSERT(g_rgcno[i].pszObjectClass != NULL);
		  ASSERT(g_rgcno[i].pfnCreate != NULL);
		  if (0 == lstrcmp(g_rgcno[i].pszObjectClass, pClassName))
		  {
        // found matching class
        (*ppInfo)->dwFlags = DSCCIF_HASWIZARDPRIMARYPAGE;
        (*ppInfo)->clsidWizardPrimaryPage = *(g_rgcno[i].pWizardGUID);
			  return S_OK;
      } // if
	  } // for
  }
  return E_FAIL;
}


//////////////////////////////////////////////////////////////////////////////////
// NOTICE: this #define is used to enable externsibility testing without having
// to modify the schema.

//#ifdef _DEBUG
//  #define _TEST_OVERRIDE
//#endif

#ifdef _TEST_OVERRIDE

BOOL g_bTestCreateOverride = FALSE;
//BOOL g_bTestCreateOverride = TRUE;

// {DE41B658-8960-11d1-B93C-00A0C9A06D2D}
static const GUID CLSID_CCreateDlg = 
{ 0xde41b658, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };


// {DE41B659-8960-11d1-B93C-00A0C9A06D2D}
static const GUID CLSID_WizExt = 
{ 0xde41b659, 0x8960, 0x11d1, { 0xb9, 0x3c, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };


// {C03793D2-A7C8-11d1-B940-00A0C9A06D2D}
static const GUID CLSID_WizExtNoUI = 
{ 0xc03793d2, 0xa7c8, 0x11d1, { 0xb9, 0x40, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };


// {C03793D3-A7C8-11d1-B940-00A0C9A06D2D}
static const GUID CLSID_WizExtUser = 
{ 0xc03793d3, 0xa7c8, 0x11d1, { 0xb9, 0x40, 0x0, 0xa0, 0xc9, 0xa0, 0x6d, 0x2d } };
#endif // _TEST_OVERRIDE

///////////////////////////////////////////////////////////////////////////
// Wrapper function to do filtering and error handling
HRESULT DsGetClassCreationInfoEx(IN MyBasePathsInfo* pBasePathsInfo, 
                                 IN LPCWSTR pClassName, 
                                 OUT LPDSCLASSCREATIONINFO* ppInfo)
{
  TRACE(L"DsGetClassCreationInfoEx(_, pClassName = %s, _)\n", pClassName);

  HRESULT hr;
  // do some filtering, to ignore overrides
  if (0 == lstrcmp(gsz_printQueue, pClassName))
  {
    // ignore override of this class
    hr = ::DsGetClassCreationInfoInternal(pClassName, ppInfo);
    ASSERT(SUCCEEDED(hr));
    return hr;
  }

#ifdef _TEST_OVERRIDE
  if (g_bTestCreateOverride)
  {
    //
    // this is just to test extensions
    //
    if ( (0 == lstrcmp(L"contact", pClassName)) ||
          (0 == lstrcmp(L"organizationalUnit", pClassName)) )
    {
      hr = ::DsGetClassCreationInfoInternal(pClassName, ppInfo);
      // replace the dialog completely
      (*ppInfo)->clsidWizardPrimaryPage = CLSID_CCreateDlg;
      (*ppInfo)->dwFlags |= DSCCIF_HASWIZARDPRIMARYPAGE;
      return S_OK;
    }
    else if (0 == lstrcmp(gsz_user, pClassName))
    {
      // add user specific extension and generic extension
      hr = ::DsGetClassCreationInfoInternal(pClassName, ppInfo);
      ASSERT(SUCCEEDED(hr));
      LPDSCLASSCREATIONINFO pTempInfo = (*ppInfo);
      (*ppInfo) = (DSCLASSCREATIONINFO*)::LocalAlloc(LPTR, sizeof(DSCLASSCREATIONINFO)+ sizeof(GUID));
      (*ppInfo)->clsidWizardPrimaryPage = pTempInfo->clsidWizardPrimaryPage;
      (*ppInfo)->dwFlags = pTempInfo->dwFlags;
      (*ppInfo)->cWizardExtensions = 2;
      (*ppInfo)->aWizardExtensions[0] = CLSID_WizExtUser;
      (*ppInfo)->aWizardExtensions[1] = CLSID_WizExt;
      ::LocalFree(pTempInfo);
      return S_OK;
    }
    else
    {
      // add a general purpose extension for other known classes
      hr = ::DsGetClassCreationInfoInternal(pClassName, ppInfo);
      if(SUCCEEDED(hr))
      {
        (*ppInfo)->cWizardExtensions = 1;
        (*ppInfo)->aWizardExtensions[0] = CLSID_WizExt;
        return S_OK;
      }
    }
  } // g_bTestCreateOverride
#endif // _TEST_OVERRIDE

  // try the display specifiers in the back end (DSUIEXT.DLL)
  TRACE(L"calling pBasePathsInfo->GetClassCreationInfo()\n");
  hr = pBasePathsInfo->GetClassCreationInfo(pClassName, ppInfo);
  ASSERT(SUCCEEDED(hr));
  ASSERT((*ppInfo) != NULL);

  // protect from somebody erroneously putting CLSID_DsAdminCreateObj
  if ( (*ppInfo)->clsidWizardPrimaryPage == CLSID_DsAdminCreateObj)
  {
    // just remove entry, next check below will try to fix if possible
    TRACE(L"// just remove entry, next check below will try to fix if possible\n");
    (*ppInfo)->dwFlags &= ~DSCCIF_HASWIZARDPRIMARYPAGE;
    (*ppInfo)->clsidWizardPrimaryPage = CLSID_NULL;
  }

  if (((*ppInfo)->dwFlags & DSCCIF_HASWIZARDPRIMARYPAGE) == 0)
  {
    // something went wrong or there is no specifier at all for the primary wizard,
    // just call the internal implementation to get the primary wizard
    TRACE(L"// just call the internal implementation to get the primary wizard\n");
    LPDSCLASSCREATIONINFO pTempInfo;
    HRESULT hrInternal = DsGetClassCreationInfoInternal(pClassName, &pTempInfo);
    if (SUCCEEDED(hrInternal))
    {
      // it is a class we know about, modify the info we got from backend
      (*ppInfo)->dwFlags |= DSCCIF_HASWIZARDPRIMARYPAGE;
      (*ppInfo)->clsidWizardPrimaryPage = pTempInfo->clsidWizardPrimaryPage;
      ::LocalFree(pTempInfo);
    }
  }

  TRACE(L"DsGetClassCreationInfoEx() returning hr = 0x%x\n", hr);

  return hr;
}




/////////////////////////////////////////////////////////////////////
//////////////////// CNewADsObjectCreateInfo ////////////////////////
/////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////
CNewADsObjectCreateInfo::CNewADsObjectCreateInfo(
                MyBasePathsInfo* pBasePathsInfo,
	              LPCTSTR pszObjectClass)
{
	ASSERT(pszObjectClass != NULL);
  ASSERT(pBasePathsInfo != NULL);
	m_pBasePathsInfo = pBasePathsInfo;
	m_pszObjectClass = pszObjectClass;
  m_hWnd = NULL;
	m_pvCreationParameter = NULL;
  m_pfnCreateObject = NULL;
	m_pIADsContainer = NULL;
	m_pDsCacheItem = NULL;
  m_pCD = NULL;
	m_pIADs = NULL;
  m_pCreateInfo = NULL;

  m_bPostCommit = FALSE;
  m_pCopyHandler = NULL;
}

/////////////////////////////////////////////////////////////////////
CNewADsObjectCreateInfo::~CNewADsObjectCreateInfo()
{
  if (m_pCreateInfo != NULL)
  {
    ::LocalFree(m_pCreateInfo);
    m_pCreateInfo = NULL;
  }
  if (m_pCopyHandler != NULL)
  {
    delete m_pCopyHandler;
  }
}


/////////////////////////////////////////////////////////////////////
//	Another method to inizialize the object with additional pointers.
void
CNewADsObjectCreateInfo::SetContainerInfo(
	  IN IADsContainer * pIADsContainer,
	  IN CDSClassCacheItemBase* pDsCacheItem,
    IN CDSComponentData* pCD,
    IN LPCWSTR lpszAttrString)
{
  ASSERT(m_pIADs == NULL);
	ASSERT(pIADsContainer != NULL);
	if (pDsCacheItem != NULL)
  {
    m_szCacheNamingAttribute = pDsCacheItem->GetNamingAttribute();
  }
  else
  {
    m_szCacheNamingAttribute = lpszAttrString;
  }
  
	m_pIADsContainer = pIADsContainer;
	m_pDsCacheItem = pDsCacheItem;
  m_pCD = pCD;
}


/////////////////////////////////////////////////////////////////////

HRESULT CNewADsObjectCreateInfo::SetCopyInfo(IADs* pIADsCopyFrom)
{
  ASSERT(pIADsCopyFrom != NULL);

  CWaitCursor wait;

  // load the object cache
  HRESULT hr = pIADsCopyFrom->GetInfo();
  if (FAILED(hr))
  {
    TRACE(L"pIADsCopyFrom->GetInfo() failed with hr = 0x%x\n", hr);
    return hr;
  }

  // get the object class
  CComBSTR bstrClassName;
  hr = pIADsCopyFrom->get_Class(&bstrClassName);
  if (FAILED(hr))
  {
    TRACE(L"spIADsCopyFrom->get_Class() failed with hr = 0x%x\n", hr);
    return hr;
  }

  // make sure we are dealing with the right class type
  if (wcscmp(m_pszObjectClass, bstrClassName) != 0)
  {
    hr = E_INVALIDARG;
    TRACE(L"ERROR: wrong source object class m_pszObjectClass = %s, bstrClassName = %s\n", 
      m_pszObjectClass, bstrClassName);
    return hr;
  }

  // determine if this is a copyable class
  // and create the appropriate copy handler
  ASSERT(m_pCopyHandler == NULL);
  if (wcscmp(m_pszObjectClass, L"user") == 0
#ifdef INETORGPERSON
      || _wcsicmp(m_pszObjectClass, L"inetOrgPerson") == 0
#endif
     )
  {
    ASSERT(m_pCopyHandler == NULL);
    m_pCopyHandler = new CCopyUserHandler();
  }
  else
  {
    // default, do-nothing copy handler
    m_pCopyHandler = new CCopyObjectHandlerBase();
  } 
  
  if (m_pCopyHandler == NULL)
    return E_OUTOFMEMORY;

  hr = m_pCopyHandler->Init(m_pBasePathsInfo, pIADsCopyFrom);

  return hr;
}




HRESULT CNewADsObjectCreateInfo::SetCopyInfo(LPCWSTR lpszCopyFromLDAPPath)
{
  TRACE(L"CNewADsObjectCreateInfo::SetCopyInfo(%s)\n", lpszCopyFromLDAPPath);

  // bind to the object
  CComPtr<IADs> spIADsCopyFrom;
  HRESULT hr = S_OK;

  {
    CWaitCursor wait;
    hr = DSAdminOpenObject(lpszCopyFromLDAPPath,
                           IN IID_IADs,
                           OUT (LPVOID *) &spIADsCopyFrom,
                           TRUE /*bServer*/);
  }

  if (FAILED(hr))
  {
    TRACE(L"DSAdminOpenObject(%s) failed with hr = 0x%x\n", lpszCopyFromLDAPPath, hr);
    return hr;
  }

  // do the copy info setup using the bound pointer
  return SetCopyInfo(spIADsCopyFrom);
}





/////////////////////////////////////////////////////////////////////
//      gets the current container (in canonical form)

LPCWSTR CNewADsObjectCreateInfo::GetContainerCanonicalName()
{
  if (m_szContainerCanonicalName.IsEmpty())
  {
    CComPtr<IADs> spObj;
    HRESULT hr = m_pIADsContainer->QueryInterface(
                          IID_IADs, (void **)&spObj);
    if (SUCCEEDED(hr)) 
    {
      CComBSTR bsPath, bsDN;
      LPWSTR pszCanonical = NULL;

      spObj->get_ADsPath(&bsPath);

      CPathCracker pathCracker;
      pathCracker.SetDisplayType(ADS_DISPLAY_FULL);
      pathCracker.Set(bsPath, ADS_SETTYPE_FULL);
      pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bsDN);

      hr = CrackName (bsDN, &pszCanonical, GET_OBJ_CAN_NAME, NULL);
      if (SUCCEEDED(hr))
        m_szContainerCanonicalName = pszCanonical;
      if (pszCanonical != NULL)
        LocalFreeStringW(&pszCanonical);
    }
  }
  return m_szContainerCanonicalName;
}

/////////////////////////////////////////////////////////////////////
//	_RemoveAttribute()

HRESULT CNewADsObjectCreateInfo::_RemoveAttribute(BSTR bstrAttrName, BOOL bDefaultList)
{
  if (bDefaultList)
    return _RemoveVariantInfo(bstrAttrName);
  else
    return _HrClearAttribute(bstrAttrName);
}




/////////////////////////////////////////////////////////////////////
//	_PAllocateVariantInfo()
//
//	Private routine to allocate and initialize a VARIANT_INFO structure.
//
//	Return pointer to VARIANT structure if successful, otherwise
//	return NULL.
//
//	INTERFACE NOTES
//	All allocated variants will be cleared when the class gets destroyed.
//

VARIANT* 
CNewADsObjectCreateInfo::_PAllocateVariantInfo(BSTR bstrAttrName)
{
  // first look if we have the attribute already in the list
  for (POSITION pos = m_defaultVariantList.GetHeadPosition(); pos != NULL; )
  {
    CVariantInfo* pCurrInfo = m_defaultVariantList.GetNext(pos);
    if (_wcsicmp (pCurrInfo->m_szAttrName, bstrAttrName) == 0)
    {
      // found, just recycle this one
      ::VariantClear(&pCurrInfo->m_varAttrValue);
      return &pCurrInfo->m_varAttrValue;
    }
  }

  // not found, create a new one and add to the list
  CVariantInfo* pVariantInfo = new CVariantInfo;
  if (pVariantInfo == NULL)
    return NULL;
  pVariantInfo->m_bPostCommit = m_bPostCommit;
  pVariantInfo->m_szAttrName = bstrAttrName;
  m_defaultVariantList.AddTail(pVariantInfo);
  return &pVariantInfo->m_varAttrValue;
}

/////////////////////////////////////////////////////////////////////
// 

HRESULT CNewADsObjectCreateInfo::_RemoveVariantInfo(BSTR bstrAttrName)
{
  POSITION deletePos = NULL;
  CVariantInfo* pCurrInfo = NULL;
  for (POSITION pos = m_defaultVariantList.GetHeadPosition(); pos != NULL; )
  {
    POSITION lastPos = pos;
    pCurrInfo = m_defaultVariantList.GetNext(pos);
    if (_wcsicmp (pCurrInfo->m_szAttrName, bstrAttrName) == 0)
    {
      // found
      deletePos = lastPos;
      break;
    }
  }
  if (deletePos != NULL)
  {
    m_defaultVariantList.RemoveAt(deletePos);
    delete pCurrInfo;
  }
  return S_OK;
}

/////////////////////////////////////////////////////////////////////
//	Add a BSTR variant where the value is name of the object.
//
//	Here are some examples where the name of the object is the
//	attribute value: "cn", "ou", "samAccountName"
//
HRESULT
CNewADsObjectCreateInfo::HrAddVariantFromName(BSTR bstrAttrName)
{
	ASSERT(bstrAttrName != NULL);
	ASSERT(!m_strObjectName.IsEmpty());
	return HrAddVariantBstr(bstrAttrName, m_strObjectName);
}


/////////////////////////////////////////////////////////////////////
//	Add a BSTR variant to the list.
HRESULT
CNewADsObjectCreateInfo::HrAddVariantBstr(BSTR bstrAttrName, LPCTSTR pszAttrValue,
                                          BOOL bDefaultList)
{
	ASSERT(bstrAttrName != NULL);

  // passing a NULL or empty string means remove the attribute
  if ( (pszAttrValue == NULL) || ((pszAttrValue != NULL) && (pszAttrValue[0] == NULL)) )
  {
    return _RemoveAttribute(bstrAttrName, bDefaultList);
  }


	ASSERT(pszAttrValue != NULL);
  HRESULT hr = S_OK;
  if (bDefaultList)
  {
    VARIANT * pVariant = _PAllocateVariantInfo(bstrAttrName);
	  if (pVariant == NULL)
		  hr = E_OUTOFMEMORY;
    else
    {
	    pVariant->vt = VT_BSTR;
	    pVariant->bstrVal = ::SysAllocString(pszAttrValue);
	    if (pVariant->bstrVal == NULL)
		    hr = E_OUTOFMEMORY;
    }
  }
  else
  {
    CComVariant v;
    v.vt = VT_BSTR;
	  v.bstrVal = ::SysAllocString(pszAttrValue);
	  if (v.bstrVal == NULL)
		  return E_OUTOFMEMORY;
    hr = _HrSetAttributeVariant(bstrAttrName, &v);
  }
  return hr;
}


/////////////////////////////////////////////////////////////////////
//	Add a BSTR variant to the list if the string value is not empty.
HRESULT
CNewADsObjectCreateInfo::HrAddVariantBstrIfNotEmpty(BSTR bstrAttrName, 
                                                    LPCWSTR pszAttrValue,
                                                    BOOL bDefaultList)
	{
	if (pszAttrValue == NULL)
		return S_OK;
	while (*pszAttrValue == _T(' '))
		pszAttrValue++;
	if (pszAttrValue[0] == _T('\0'))
		return S_OK;
	return HrAddVariantBstr(bstrAttrName, pszAttrValue, bDefaultList);
	}


/////////////////////////////////////////////////////////////////////
//	Add an integer variant to the list.
HRESULT CNewADsObjectCreateInfo::HrAddVariantLong(BSTR bstrAttrName, LONG lAttrValue,
                                          BOOL bDefaultList)
{
  ASSERT(bstrAttrName != NULL);
  HRESULT hr = S_OK;
  if (bDefaultList)
  {
	  VARIANT * pVariant = _PAllocateVariantInfo(bstrAttrName);
	  if (pVariant == NULL)
		  hr = E_OUTOFMEMORY;
    else
    {
	    pVariant->vt = VT_I4;
	    pVariant->lVal = lAttrValue;
    }
  }
  else
  {
    CComVariant v;
    v.vt = VT_I4;
	  v.lVal = lAttrValue;
    hr = _HrSetAttributeVariant(bstrAttrName, &v);
  }
  return hr;
}


/////////////////////////////////////////////////////////////////////
//	Add a boolean variant to the list.
HRESULT
CNewADsObjectCreateInfo::HrAddVariantBoolean(BSTR bstrAttrName, BOOL fAttrValue,
                                             BOOL bDefaultList)
{
  ASSERT(bstrAttrName != NULL);
  HRESULT hr = S_OK;
  if (bDefaultList)
  {
	  VARIANT * pVariant = _PAllocateVariantInfo(bstrAttrName);
	  if (pVariant == NULL)
		  hr = E_OUTOFMEMORY;
    else
    {
	    pVariant->vt = VT_BOOL;
      pVariant->boolVal = (VARIANT_BOOL)fAttrValue;
    }
  }
  else
  {
    CComVariant v;
    v.vt = VT_BOOL;
    v.boolVal = (VARIANT_BOOL)fAttrValue;
    hr = _HrSetAttributeVariant(bstrAttrName, &v);
  }
  return hr;
}

/////////////////////////////////////////////////////////////////////
//	HrAddVariantCopyVar()
//
//	Add an exact copy of an existing variant to the list.
//	This is the most generic routine to add a variant type that does
//	not have a frienldy wrapper.
//
//	INTERFACE NOTES
//	Depending on the type of variant to be copied, the routine may
//	allocate extra memory to store the data.
//	- If pvargSrc is a VT_BSTR, a copy of the string is made.
//	- If pvargSrc is a VT_ARRAY, the entire array is copied.
//	The user must clear the variant using ClearVariant(varSrc) when no longer needed.
//
HRESULT
CNewADsObjectCreateInfo::HrAddVariantCopyVar(IN BSTR bstrAttrName, IN VARIANT varSrc,
                                             BOOL bDefaultList)
{
  ASSERT(bstrAttrName != NULL);
  HRESULT hr = S_OK;
  if (bDefaultList)
  {
    VARIANT * pVariant = _PAllocateVariantInfo(bstrAttrName);
	  if (pVariant == NULL)
		  hr = E_OUTOFMEMORY;
    else
      hr = ::VariantCopy(OUT pVariant, IN &varSrc);
  }
  else
    hr = _HrSetAttributeVariant(bstrAttrName, IN &varSrc); 

  return hr;
} // HrAddVariantCopyVar()


/////////////////////////////////////////////////////////////////////
//	HrGetAttributeVariant()
//
//	Routine to get the attribute variant by calling pIADs->Get().
//
//	Sometimes there are attributes (typically flags) that
//	cannot be set directly.
//	1.  The flag must be read using pIADs->Get().
//	2.	The flag is updated by changing some bits (using binary operators)
//	3.	The flag is written back using pIADs->Put().
//
//	INTERFACE NOTES
//	- This routine is only available after the object has been
//	  successfully created.
//	- The variant does NOT need to be initialized.  The routine
//	  will initialize the variant for you.
//
HRESULT CNewADsObjectCreateInfo::HrGetAttributeVariant(BSTR bstrAttrName, OUT VARIANT * pvarData)
{
	ASSERT(bstrAttrName != NULL);
	ASSERT(pvarData != NULL);
	VariantInit(OUT pvarData);
	ASSERT(m_pIADs != NULL && "You must call HrSetInfo() first before extracting data from object.");

	return m_pIADs->Get(bstrAttrName, OUT pvarData);
} // HrGetAttributeVariant()


//////////////////////////////////////////////////////////////////////
// HrSetAttributeVariant
HRESULT
CNewADsObjectCreateInfo::_HrSetAttributeVariant(BSTR bstrAttrName, IN VARIANT * pvarData)
{
	ASSERT(bstrAttrName != NULL);
	ASSERT(pvarData != NULL);
	HRESULT hr = m_pIADs->Put(bstrAttrName, IN *pvarData);
  return hr;
}


//////////////////////////////////////////////////////////////////////
// _HrClearAttribute
HRESULT
CNewADsObjectCreateInfo::_HrClearAttribute(BSTR bstrAttrName)
{
  ASSERT(m_pIADs != NULL);
	ASSERT(bstrAttrName != NULL);
  HRESULT hr = S_OK;

  CComVariant varVal;

  // see if the attribute is there
  HRESULT hrFind = m_pIADs->Get(bstrAttrName, &varVal);
  if (SUCCEEDED(hrFind))
  {
    // found, need to clear the property
    if (m_bPostCommit)
    {
      // remove from the committed object
      hr = m_pIADs->PutEx(ADS_PROPERTY_CLEAR, bstrAttrName, varVal);
    }
    else
    {
      // remove from the cache of the temporary object
      IADsPropertyList* pPropList = NULL;
      hr = m_pIADs->QueryInterface(IID_IADsPropertyList, (void**)&pPropList);
      ASSERT(pPropList != NULL);
      if (SUCCEEDED(hr))
      {
        CComVariant v;
        v.vt = VT_BSTR;
        v.bstrVal = ::SysAllocString(bstrAttrName);
        hr = pPropList->ResetPropertyItem(v);
        pPropList->Release();
      }
    }
  }

  return hr;
}

/////////////////////////////////////////////////////////////////
// CNewADsObjectCreateInfo:: HrLoadCreationInfo()
//
//	The routine will do a lookup to match m_pszObjectClass
//	to the best "create routine".  If no match is found,
//	the create routine will point to the "Generic Create" wizard.
//

HRESULT CNewADsObjectCreateInfo::HrLoadCreationInfo()
{
	ASSERT(m_pszObjectClass != NULL);
	ASSERT(lstrlen(m_pszObjectClass) > 0);

  // Load the creation information from the display specifiers
  ASSERT(m_pCreateInfo == NULL);
  ASSERT(m_pfnCreateObject == NULL);

  HRESULT hr = ::DsGetClassCreationInfoEx(GetBasePathsInfo(), m_pszObjectClass, &m_pCreateInfo);
  if (FAILED(hr))
    return hr;

  ASSERT(m_pCreateInfo != NULL);

	// Set the default to point to the "Generic Create" wizard
	m_pfnCreateObject = HrCreateADsObjectGenericWizard;

	// Given an class name, search the lookup table for a specific create routine
  BOOL bFound = FALSE;
	for (int i = 0; i < ARRAYLEN(g_rgcno); i++)
	{
		ASSERT(g_rgcno[i].pszObjectClass != NULL);
		ASSERT(g_rgcno[i].pfnCreate != NULL);
    // compare class name
		if (0 == lstrcmp(g_rgcno[i].pszObjectClass, m_pszObjectClass))
		{
      // found matching class, compare provided GUID
      if ( (m_pCreateInfo->dwFlags & DSCCIF_HASWIZARDPRIMARYPAGE) && 
           (m_pCreateInfo->clsidWizardPrimaryPage == *(g_rgcno[i].pWizardGUID)) )
      {
        if ( IsStandaloneUI() && ((g_rgcno[i].dwFlags & CNOF_STANDALONE_UI)==0) )
        {
          return E_INVALIDARG;
        }
        else
        {
          // found matching GUID, this is our wizard
			    m_pfnCreateObject = g_rgcno[i].pfnCreate;
			    m_pvCreationParameter = g_rgcno[i].pvCreationParameter;
          bFound = TRUE;
        } // if
      } // if
      break;
    } // if
	} // for

  if (!bFound)
  {
    // we did not find any matching class name, but we might
    // have a derived class with a known wizard GUID
    for (i = 0; i < ARRAYLEN(g_rgcno); i++)
	  {
		  ASSERT(g_rgcno[i].pszObjectClass != NULL);
		  ASSERT(g_rgcno[i].pfnCreate != NULL);
      // found matching class
      if ((m_pCreateInfo->dwFlags & DSCCIF_HASWIZARDPRIMARYPAGE) && 
          (m_pCreateInfo->clsidWizardPrimaryPage == *(g_rgcno[i].pWizardGUID)))
      {
        if ( IsStandaloneUI() && ((g_rgcno[i].dwFlags & CNOF_STANDALONE_UI)==0) )
        {
          return E_INVALIDARG;
        }
        else
        {
          // found matching GUID, this is our wizard
			    m_pfnCreateObject = g_rgcno[i].pfnCreate;
			    m_pvCreationParameter = g_rgcno[i].pvCreationParameter;
          bFound = TRUE;
        } // if
        break;
      } // if
    } // for
  } // if

  if ( !bFound && (m_pCreateInfo->dwFlags & DSCCIF_HASWIZARDPRIMARYPAGE) && 
           (m_pCreateInfo->clsidWizardPrimaryPage != GUID_NULL) )
  {
    // we have a non null GUID,
    // assume this is provided a new dialog for creation
    m_pfnCreateObject = HrCreateADsObjectOverride;
  } // if

  ASSERT(m_pfnCreateObject != NULL);
	
  if ((m_pfnCreateObject == HrCreateADsObjectGenericWizard) && IsStandaloneUI())
  {
    // cannot call generic wizard under these conditions, just bail out
    m_pfnCreateObject = NULL;
    return E_INVALIDARG;
  }

  // finally we have a function pointer
  ASSERT(m_pfnCreateObject != NULL);
  return S_OK;
}
  
/////////////////////////////////////////////////////////////////////
//	HrDoModal()
//
//	Invoke a dialog to create a new object.
//
//	RETURNS
//	The return value depends on the return value of the "create routine".
//	S_OK - The object was created and persisted successfully.
//	S_FALSE - The user hit the "Cancel" button or object creation failed.
//
//	INTERFACE NOTES
//	The "create routine" will validate the data and create the object.
//	If the object creation fails, the routine should display an error
//	message and return S_FALSE.
//
//	EXTRA INFO
//	The "create routine" will validate the data and store each
//	attribute into a list of variants.
//

HRESULT
CNewADsObjectCreateInfo::HrDoModal(HWND hWnd)
{
  CThemeContextActivator activator;

	ASSERT(m_pszObjectClass != NULL);
	ASSERT(lstrlen(m_pszObjectClass) > 0);

  // Load the creation information from the display specifiers
  ASSERT(m_pCreateInfo != NULL);
  ASSERT(m_pfnCreateObject != NULL);
  if (m_pfnCreateObject == NULL)
    return E_INVALIDARG;

  ASSERT(hWnd != NULL);
  m_hWnd = hWnd;

  HRESULT hr = E_UNEXPECTED;
	TRY
	{
		// Invoke the "create routine" which will bring a wizard.
		hr = m_pfnCreateObject(INOUT this);
	}
	CATCH(CMemoryException, e)
	{
		hr = E_OUTOFMEMORY;
		ASSERT(e != NULL);
		e->Delete();
	}
	AND_CATCH_ALL(e)
	{
		hr = E_FAIL;
		ASSERT(e != NULL);
		e->Delete();
	}
	END_CATCH_ALL;
	return hr;
	} // HrDoModal()


/////////////////////////////////////////////////////////////////////
//	HrCreateNew()

HRESULT
CNewADsObjectCreateInfo::HrCreateNew(LPCWSTR pszName, BOOL bSilentError, BOOL bAllowCopy)
{
  ASSERT(m_bPostCommit == FALSE);
	ASSERT(m_pIADsContainer != NULL);

  CWaitCursor wait;

  // get rid of old object if there
  if (m_pIADs != NULL)
  {
    m_pIADs->Release();
    m_pIADs = NULL;
  }

  // set the given name
  m_strObjectName = pszName;
  ASSERT(!m_strObjectName.IsEmpty());
  if (m_strObjectName.IsEmpty())
    return E_INVALIDARG;
  
  m_strObjectName.TrimRight();
  m_strObjectName.TrimLeft();

  HRESULT hr;
  IDispatch * pIDispatch = NULL;
  
  CString strADsName = m_strADsName;
  if (strADsName.IsEmpty())
    {
      strADsName = m_szCacheNamingAttribute; // Typically "cn"
      strADsName += L"=";
      strADsName += GetName();
    }

  TRACE(_T("name, before escaping: %ws\n"), strADsName);
  CComBSTR bsEscapedName;

  CPathCracker pathCracker;
  hr = pathCracker.GetEscapedElement(0, //reserved
                                   (BSTR)(LPCWSTR)strADsName,
                                   &bsEscapedName);

#ifdef TESTING
  hr = _EscapeRDN ((BSTR)(LPCWSTR)strADsName,
                   &bsEscapedName);
  
#endif

  if (FAILED(hr))
    goto CleanUp;
  TRACE(_T("name, after escaping: %ws\n"), bsEscapedName);

  hr = m_pIADsContainer->Create(CComBSTR(m_pszObjectClass),
                                CComBSTR(bsEscapedName),
                                OUT &pIDispatch);
  if (FAILED(hr))
    goto CleanUp;
  ASSERT(pIDispatch != NULL);
  
  hr = pIDispatch->QueryInterface(IID_IADs, OUT (LPVOID *)&m_pIADs);
  if (FAILED(hr)) 
  {
    m_pIADs = NULL;
    goto CleanUp;
  }
  
  // if copy operation, do a bulk copy 
  if ((m_pCopyHandler != NULL) && bAllowCopy)
  {
    hr = m_pCopyHandler->CopyAtCreation(m_pIADs);
    if (FAILED(hr)) 
    {
      goto CleanUp;
    }
  }


  // write al the default attributes
  hr = HrAddDefaultAttributes();
  if (FAILED(hr)) 
  {
    goto CleanUp;
  }
  
  
CleanUp:
  if (pIDispatch != NULL)
    pIDispatch->Release();

  if (FAILED(hr)) 
  {
    if (!bSilentError)
    {
      PVOID apv[1] = {(LPWSTR)GetName()};
      ReportErrorEx (GetParentHwnd(),IDS_12_GENERIC_CREATION_FAILURE,hr,
                     MB_OK | MB_ICONERROR, apv, 1);
    }
    // reset to empty state
    m_strObjectName.Empty();
  }
  return hr;
}


/////////////////////////////////////////////////////////////////////
//	HrSetInfo()

HRESULT
CNewADsObjectCreateInfo::HrSetInfo(BOOL fSilentError)
{
  ASSERT(m_pIADsContainer != NULL);
  
  // we assume that HrCreateNew() has been already called
  ASSERT(m_pIADs != NULL);
  if (m_pIADs == NULL)
    return E_INVALIDARG;
  
  CWaitCursor wait;
  HRESULT hr;
  
  // Persist the object. This is it folks!!
  hr = m_pIADs->SetInfo();
  
  if (FAILED(hr)) 
  {
    if(!fSilentError)
    {
      PVOID apv[1] = {(LPWSTR)GetName()};
      ReportErrorEx (GetParentHwnd(),IDS_12_GENERIC_CREATION_FAILURE,hr,
                     MB_OK | MB_ICONERROR, apv, 1);
      m_strObjectName = L"";
    }
  }
  
  if (!FAILED(hr)) 
  {
    // Make sure re-fill the cache
    hr = m_pIADs->GetInfo();
    if (FAILED(hr))
    {
      if (!fSilentError)
      {
        PVOID apv[1] = {(LPWSTR)GetName()};
        ReportErrorEx (GetParentHwnd(),IDS_12_GENERIC_CREATION_FAILURE,hr,
                       MB_OK | MB_ICONERROR, apv, 1);
        m_strObjectName = L"";
      }
    }
  }
  
  return hr;
} // HrSetInfo()


////////////////////////////////////////////////////////////////////
// HrDeleteFromBackend()
//
//  deletes object from back end when post commit fails
//
HRESULT CNewADsObjectCreateInfo::HrDeleteFromBackend()
{
  ASSERT(m_pIADsContainer != NULL);
  ASSERT(m_pIADs != NULL);

  // get the name of the object
  CComBSTR bstrName;
  HRESULT hr = m_pIADs->get_Name(&bstrName);
  if (SUCCEEDED(hr))
  {
    // do the actual delete
    ASSERT(bstrName != NULL);
    hr = m_pIADsContainer->Delete(CComBSTR(m_pszObjectClass), bstrName);
  }

  // release the object only if we could delete it
  if (SUCCEEDED(hr))
    SetIADsPtr(NULL);
  return hr;
}


/////////////////////////////////////////////////////////////////////////
// CDsAdminCreateObj

HRESULT _ReBindToObj(INOUT CComPtr<IADs>& spIADs,
                     INOUT CString& szServerName)
{
  // get the path of the object

  CComBSTR bstrObjectLdapPath;
  HRESULT hr = spIADs->get_ADsPath(&bstrObjectLdapPath);
  if (FAILED(hr))
  {
    return hr;
  }

  // make sure we are bound to a server
  if (szServerName.IsEmpty())
  {
    hr = GetADSIServerName(szServerName, spIADs);
    if (FAILED(hr))
    {
      return hr;
    }
  }

  if (szServerName.IsEmpty())
  {
    return E_INVALIDARG;
  }

  // rebuild the LDAP path with the server
  CPathCracker pathCracker;

  CComBSTR bsX500DN;
  pathCracker.SetDisplayType(ADS_DISPLAY_FULL);
  pathCracker.Set(bstrObjectLdapPath, ADS_SETTYPE_FULL);
  pathCracker.put_EscapedMode(ADS_ESCAPEDMODE_ON);
  pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bsX500DN);

  CString szNewLdapPath;
  szNewLdapPath.Format(L"LDAP://%s/%s", (LPCWSTR)szServerName, bsX500DN);

  // bind to the object again
  CComPtr<IADs> spADsObjNew;
  hr = DSAdminOpenObject(szNewLdapPath,
                         IID_IADs, 
                         (void **)&spADsObjNew,
                         TRUE /*bServer*/);
  if (FAILED(hr))
  {
    return hr;
  }

  // update smart pointer
  spIADs = spADsObjNew;

  return S_OK;
  
}

HRESULT _ReBindToContainer(INOUT CComPtr<IADsContainer>& spADsContainerObj,
                           INOUT CString& szServerName)
{
  // get the path of the container
  CComPtr<IADs> spIADsCont;
  HRESULT hr = spADsContainerObj->QueryInterface(IID_IADs, (void**)&spIADsCont);
  if (FAILED(hr))
  {
    return hr;
  }

  hr = _ReBindToObj(spIADsCont, szServerName);
  if (FAILED(hr))
  {
    return hr;
  }

  CComPtr<IADsContainer> spADsContainerObjNew;
  hr = spIADsCont->QueryInterface(IID_IADsContainer, (void**)&spADsContainerObjNew);
  if (FAILED(hr))
  {
    return hr;
  }
  
  // update smart pointer
  spADsContainerObj = spADsContainerObjNew;

  return S_OK;
}





HRESULT CDsAdminCreateObj::Initialize(IADsContainer* pADsContainerObj,
                                      IADs* pADsCopySource,
                                      LPCWSTR lpszClassName)
{
  AFX_MANAGE_STATE(AfxGetStaticModuleState());
  
  if ((pADsContainerObj == NULL) || (lpszClassName == NULL))
  {
    // must have valid pointers
    return E_INVALIDARG;
  }

  m_szObjectClass = lpszClassName;
  m_szObjectClass.TrimRight();
  m_szObjectClass.TrimLeft();
  if (m_szObjectClass.IsEmpty())
  {
    // passed blank?
    return E_INVALIDARG;
  }

  if ((pADsCopySource != NULL) && (m_szObjectClass != L"user")
#ifdef INETORGPERSON
      && (m_szObjectClass != L"inetOrgPerson")
#endif
     )
  {
    // we allow the copy operation only for users
    return E_INVALIDARG;
  }

  // make sure we have the right LDAP path
  m_spADsContainerObj = pADsContainerObj;
  CString szServerName;
  HRESULT hr = _ReBindToContainer(m_spADsContainerObj, szServerName);
  if (FAILED(hr))
  {
    return hr;
  }

 
  hr = m_basePathsInfo.InitFromContainer(m_spADsContainerObj);
  if (FAILED(hr))
  {
    return hr;
  }

  hr = _GetNamingAttribute();
  if (FAILED(hr))
  {
    return hr;
  }

  ASSERT(m_pNewADsObjectCreateInfo == NULL);
  if (m_pNewADsObjectCreateInfo != NULL)
    delete m_pNewADsObjectCreateInfo;

  m_pNewADsObjectCreateInfo = new CNewADsObjectCreateInfo(&m_basePathsInfo, m_szObjectClass);
  if (m_pNewADsObjectCreateInfo == NULL)
    return E_OUTOFMEMORY;

  m_pNewADsObjectCreateInfo->SetContainerInfo(m_spADsContainerObj, NULL, NULL, m_szNamingAttribute);

  
  // copy operation, need to set the copy source
  if (pADsCopySource != NULL)
  {
    CComPtr<IADs> spADsCopySource = pADsCopySource;
    hr = _ReBindToObj(spADsCopySource, szServerName);
    if (FAILED(hr))
    {
      return hr;
    }

    hr = m_pNewADsObjectCreateInfo->SetCopyInfo(spADsCopySource);
    if (FAILED(hr))
    {
      return hr;
    }
  }

  
  hr = m_pNewADsObjectCreateInfo->HrLoadCreationInfo();

  if (FAILED(hr))
  {
    delete m_pNewADsObjectCreateInfo;
    m_pNewADsObjectCreateInfo = NULL;
  }
  return hr;
}

HRESULT CDsAdminCreateObj::CreateModal(HWND hwndParent,
                           IADs** ppADsObj)
{
  CThemeContextActivator activator;

  if ( (m_pNewADsObjectCreateInfo == NULL)
      || (hwndParent == NULL) || (m_spADsContainerObj == NULL)
      || m_szObjectClass.IsEmpty() || m_szNamingAttribute.IsEmpty())
    return E_INVALIDARG;

  AFX_MANAGE_STATE(AfxGetStaticModuleState());

  HRESULT hr = m_pNewADsObjectCreateInfo->HrDoModal(hwndParent);
  IADs* pIADs = m_pNewADsObjectCreateInfo->PGetIADsPtr();

  if ( (hr != S_FALSE) && SUCCEEDED(hr) && (ppADsObj != NULL))
  {
    *ppADsObj = pIADs;
    pIADs = NULL; // transfer ownership
  }

  if (pIADs != NULL)
    pIADs->Release();
  return hr;
}


HRESULT CDsAdminCreateObj::_GetNamingAttribute()
{
  CString szSchemaPath;
  m_basePathsInfo.GetAbstractSchemaPath(szSchemaPath);
  ASSERT(!szSchemaPath.IsEmpty());

  CString szSchemaClassPath;
  szSchemaClassPath.Format(L"%s/%s", (LPCWSTR)szSchemaPath, 
                                    (LPCWSTR)m_szObjectClass);

  CComPtr<IADsClass> spDsClass;
  CComBSTR bstr = szSchemaClassPath;
  HRESULT hr = DSAdminOpenObject(bstr,
                                 IID_IADsClass, 
                                 (void**)&spDsClass,
                                 TRUE /*bServer*/);
  if (FAILED(hr))
    return hr;

  CComVariant Var;
  hr = spDsClass->get_NamingProperties(&Var);
  if (FAILED(hr))
  {
    m_szNamingAttribute.Empty();
    return hr;
  }

  m_szNamingAttribute = Var.bstrVal;
  return hr;
}