able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/admt/arext/upnupdt/updtupn.cpp

859 lines
30 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//---------------------------------------------------------------------------
// UPDTUPN.cpp
//
// Comment: This is a COM object extension for the MCS DCTAccountReplicator.
// This object implements the IExtendAccountMigration interface.
// The process method on this object updates the userPrincipalName
// property on the user object.
//
// (c) Copyright 1995-1998, Mission Critical Software, Inc., All Rights Reserved
//
// Proprietary and confidential to Mission Critical Software, Inc.
//---------------------------------------------------------------------------
#include "stdafx.h"
#include "ARExt.h"
#include "ARExt_i.c"
#include "UPNUpdt.h"
#include "ErrDCT.hpp"
#include "Names.hpp"
#include <iads.h>
#include <AdsHlp.h>
#include "resstr.h"
//#import "\bin\NetEnum.tlb" no_namespace
#import "NetEnum.tlb" no_namespace
#include "UpdtUPN.h"
TErrorDct err;
/////////////////////////////////////////////////////////////////////////////
// CUpdtUPN
StringLoader gString;
//---------------------------------------------------------------------------
// Get and set methods for the properties.
//---------------------------------------------------------------------------
STDMETHODIMP CUpdtUPN::get_sName(BSTR *pVal)
{
*pVal = m_sName;
return S_OK;
}
STDMETHODIMP CUpdtUPN::put_sName(BSTR newVal)
{
m_sName = newVal;
return S_OK;
}
STDMETHODIMP CUpdtUPN::get_sDesc(BSTR *pVal)
{
*pVal = m_sDesc;
return S_OK;
}
STDMETHODIMP CUpdtUPN::put_sDesc(BSTR newVal)
{
m_sDesc = newVal;
return S_OK;
}
//---------------------------------------------------------------------------
// ProcessObject : This method doesn't do anything.
//---------------------------------------------------------------------------
STDMETHODIMP CUpdtUPN::PreProcessObject(
IUnknown *pSource, //in- Pointer to the source AD object
IUnknown *pTarget, //in- Pointer to the target AD object
IUnknown *pMainSettings, //in- Varset filled with the settings supplied by user
IUnknown **ppPropsToSet //in,out - Varset filled with Prop-Value pairs that will be set
// once all extension objects are executed.
)
{
IVarSetPtr pVs = pMainSettings;
_variant_t var;
_bstr_t sTemp;
_bstr_t sUPN;
_bstr_t sPref;
_bstr_t sSuff;
IADs * pAds = NULL;
IADs * pAdsSource = NULL;
HRESULT hr;
WCHAR sTempUPN[7000];
long ub, lb;
_bstr_t sFull;
_variant_t HUGEP * pDt;
_bstr_t sAdsPath;
_variant_t varDN;
_bstr_t sIntraforest;
_bstr_t sDomainDNS;
_bstr_t sTargetOU;
WCHAR fileName[MAX_PATH];
bool bReplace = false;
tstring sSAMName;
tstring sUPNName;
_bstr_t sOldUPN;
bool bConflicted = false;
SUPNStruc UPNStruc;
// We need to process the user accounts only
sTemp = pVs->get(GET_BSTR(DCTVS_CopiedAccount_Type));
if (!sTemp.length())
return HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
if (_wcsicmp((WCHAR*)sTemp,L"user"))
return S_OK;
//store the name of this user in the UPN list
sSAMName = _bstr_t(pVs->get(GET_BSTR(DCTVS_CopiedAccount_SourceSam)));
//get the target domain DNS name
sDomainDNS = pVs->get(GET_BSTR(DCTVS_Options_TargetDomainDns));
//get the target OU path
sTargetOU = pVs->get(GET_BSTR(DCTVS_Options_OuPath));
//if not retrieved yet, get the default UPN suffix for this domain
if (m_sUPNSuffix.length() == 0)
{
//if failed, use the domain's DNS name
if (!GetDefaultUPNSuffix(sDomainDNS, sTargetOU))
m_sUPNSuffix = sDomainDNS;
}
// Get the Error log filename from the Varset
wcscpy(fileName, (WCHAR*)(pVs->get(GET_BSTR(DCTVS_Options_Logfile)).bstrVal));
// Open the error log
err.LogOpen(fileName, 1);
sPref = pVs->get(GET_BSTR(DCTVS_Options_Prefix));
sSuff = pVs->get(GET_BSTR(DCTVS_Options_Suffix));
sIntraforest = pVs->get(GET_BSTR(DCTVS_Options_IsIntraforest));
sTemp = pVs->get(GET_BSTR(DCTVS_AccountOptions_ReplaceExistingAccounts));
if (!UStrICmp(sTemp,GET_STRING(IDS_YES)))
bReplace = true;
sAdsPath = L"";
if ( pSource )
{
// Get the UPN from the source domain
hr = pSource->QueryInterface(IID_IADs, (void**) &pAdsSource);
}
if ( pAdsSource )
{
if ( SUCCEEDED(hr) )
{
hr = pAdsSource->GetEx(L"userPrincipalName", &var);
if (SUCCEEDED(hr) )
{
SAFEARRAY * pArray = V_ARRAY(&var);
hr = SafeArrayGetLBound(pArray, 1, &lb);
hr = SafeArrayGetUBound(pArray, 1, &ub);
hr = SafeArrayAccessData(pArray, (void HUGEP **) &pDt);
if ( SUCCEEDED(hr) )
{
// translate all the UPNs to the target domain.
for ( long x = lb; x <= ub; x++)
{
wcsncpy(sTempUPN, (WCHAR*) pDt[x].bstrVal, 5000);
sTempUPN[4999] = 0;
//Get the stuff before the LAST @ sign.
WCHAR * ndx = NULL;
WCHAR * tempNdx = sTempUPN;
do
{
tempNdx = wcschr(tempNdx + 1, L'@');
if ( tempNdx )
ndx = tempNdx;
} while (tempNdx);
if (ndx) *ndx = L'\0';
if ( sPref.length() )
sFull = sPref + _bstr_t(sTempUPN);
else if ( sSuff.length() )
sFull = _bstr_t(sTempUPN) + sSuff;
else
sFull = sTempUPN;
sTemp = sFull;
sUPN = sTemp + _bstr_t(L"@");
sUPN = sUPN + m_sUPNSuffix;
//store UPN name as it enters
sOldUPN = sUPN;
sUPNName = sUPN;
//get unigue UPN on target
GetUniqueUPN(sUPN, pVs, false, sAdsPath);
//see if the two UPN's differ. If they do, then we had a conflict
// if ((_wcsicmp(sOldUPN, sUPN) != 0) && (!bReplace))
if (_wcsicmp((WCHAR*)sOldUPN, sUPN) != 0)
{
sUPNName = sUPN;
hr = ERROR_OBJECT_ALREADY_EXISTS;
bConflicted = true;
}
pDt[x] = _variant_t(sUPN);
}
SafeArrayUnaccessData(pArray);
}
}
else
{
sTemp = pVs->get(GET_BSTR(DCTVS_CopiedAccount_TargetSam));
sUPN = sTemp + _bstr_t(L"@");
sUPN = sUPN + m_sUPNSuffix;
//store UPN name as it enters
sOldUPN = sUPN;
sUPNName = sUPN;
//get unigue UPN on target
GetUniqueUPN(sUPN, pVs, true, sAdsPath);
//see if the two UPN's differ. If they do, then we had a conflict
// if ((_wcsicmp(sOldUPN, sUPN) != 0) && (!bReplace))
if (_wcsicmp((WCHAR*)sOldUPN, sUPN) != 0)
{
sUPNName = sUPN;
hr = ERROR_OBJECT_ALREADY_EXISTS;
bConflicted = true;
}
}
}
}
else
{
sTemp = pVs->get(GET_BSTR(DCTVS_CopiedAccount_TargetSam));
sUPN = sTemp + _bstr_t(L"@");
sUPN = sUPN + m_sUPNSuffix;
//store UPN name as it enters
sOldUPN = sUPN;
sUPNName = sUPN;
//get unigue UPN on target
GetUniqueUPN(sUPN, pVs, true, sAdsPath);
//see if the two UPN's differ. If they do, then we had a conflict
// if ((_wcsicmp(sOldUPN, sUPN) != 0) && (!bReplace))
if (_wcsicmp((WCHAR*)sOldUPN, sUPN) != 0)
{
sUPNName = sUPN;
hr = ERROR_OBJECT_ALREADY_EXISTS;
bConflicted = true;
}
}
if ( pAds ) pAds->Release();
if (pAdsSource) pAdsSource->Release();
UPNStruc.sName = sUPNName;
UPNStruc.sOldName = sOldUPN;
UPNStruc.bConflicted = bConflicted;
//insert UPN into Map
mUPNMap.insert(CUPNMap::value_type(sSAMName, UPNStruc));
return hr;
}
//---------------------------------------------------------------------------
// ProcessObject : This method updates the UPN property of the object. It
// first sees if a E-Mail is specified then it will set UPN
// to that otherwise it builds it from SAMAccountName and the
// Domain name
//---------------------------------------------------------------------------
STDMETHODIMP CUpdtUPN::ProcessObject(
IUnknown *pSource, //in- Pointer to the source AD object
IUnknown *pTarget, //in- Pointer to the target AD object
IUnknown *pMainSettings, //in- Varset filled with the settings supplied by user
IUnknown **ppPropsToSet //in,out - Varset filled with Prop-Value pairs that will be set
// once all extension objects are executed.
)
{
IVarSetPtr pVs = pMainSettings;
_bstr_t sTemp;
IADs * pAds = NULL;
_variant_t var;
HRESULT hr;
WCHAR fileName[MAX_PATH];
CUPNMap::iterator itUPNMap;
tstring sSam;
SUPNStruc UPNStruc;
bool bReplace = false;
_bstr_t sOldUPNSuffix;
// We need to process the user accounts only
sTemp = pVs->get(GET_BSTR(DCTVS_CopiedAccount_Type));
if ( _wcsicmp((WCHAR*)sTemp,L"user") ) return S_OK;
sTemp = pVs->get(GET_BSTR(DCTVS_AccountOptions_ReplaceExistingAccounts));
if (!UStrICmp(sTemp,GET_STRING(IDS_YES)))
bReplace = true;
//get the target SAM name
sSam = _bstr_t(pVs->get(GET_BSTR(DCTVS_CopiedAccount_SourceSam)));
// Get the Error log filename from the Varset
wcscpy(fileName, (WCHAR*)(pVs->get(GET_BSTR(DCTVS_Options_Logfile)).bstrVal));
// Open the error log
err.LogOpen(fileName, 1);
// And only need to process the accounts copied to Win2k domain.
if ( pTarget )
{
//Get the IADs pointer to manipulate properties
hr = pTarget->QueryInterface(IID_IADs, (void**) &pAds);
if (SUCCEEDED(hr))
{
//get the UPN name for this user from the list
itUPNMap = mUPNMap.find(sSam);
if (itUPNMap != mUPNMap.end())
UPNStruc = itUPNMap->second;
if (!UPNStruc.sName.empty())
{
bool bSame = false;
//if replace mode, don't set UPN if same object we are replacing and
//if not the same object, get it's current UPN Suffix
if (bReplace)
{
hr = pAds->Get(L"userPrincipalName", &var);
if (SUCCEEDED(hr))
{
//if replacing the object whose UPN conflicted, don't change it
if (!UPNStruc.sOldName.compare(var.bstrVal))
bSame = true;
else //else, get the object's current UPN suffix for re-use
sOldUPNSuffix = GetUPNSuffix(var.bstrVal);
}
}
if (!bSame)
{
var = UPNStruc.sName.c_str();
//if replacing an existing object, use it's old UPN suffix
if ((bReplace) && (sOldUPNSuffix.length() != 0))
{
//change the suffix on the old name, since it may longer conflict
_bstr_t sUPN = ChangeUPNSuffix(UPNStruc.sOldName.c_str(), sOldUPNSuffix);
//if changed, make sure we don't still have a UPN conflict and save the
//new UPN for setting
if (sUPN.length() != 0)
{
_bstr_t sTempUPN = sUPN;
//get unigue UPN on target, now that we could conflict
GetUniqueUPN(sUPN, pVs, true, _bstr_t(L""));
//if changed, set conflicted flag and names for error message
if (sUPN != sTempUPN)
{
UPNStruc.sName = sUPN;
UPNStruc.sOldName = sTempUPN;
UPNStruc.bConflicted = true;
}
else
UPNStruc.bConflicted = false;
var = sUPN;
}
}
hr = pAds->Put(L"userPrincipalName", var);
if (SUCCEEDED(hr))
{
hr = pAds->SetInfo();
if (SUCCEEDED(hr))
{
// If we changed the UPN Name due to conflict, we need to log a
//message indicating the fact that we changed it.
if (UPNStruc.bConflicted)
err.MsgWrite(1, DCT_MSG_CREATE_FAILED_UPN_CONF_SS,
UPNStruc.sOldName.c_str(), UPNStruc.sName.c_str());
}
}
}
}
}
}
if ( pAds ) pAds->Release();
return hr;
}
//---------------------------------------------------------------------------
// ProcessUndo : We are not going to undo this.
//---------------------------------------------------------------------------
STDMETHODIMP CUpdtUPN::ProcessUndo(
IUnknown *pSource, //in- Pointer to the source AD object
IUnknown *pTarget, //in- Pointer to the target AD object
IUnknown *pMainSettings, //in- Varset filled with the settings supplied by user
IUnknown **ppPropsToSet //in,out - Varset filled with Prop-Value pairs that will be set
// once all extension objects are executed.
)
{
IVarSetPtr pVs = pMainSettings;
_bstr_t sTemp, sSUPN;
IADs * pAds = NULL;
_variant_t var;
HRESULT hr = S_OK;
_bstr_t sAdsPath = L"";
_bstr_t sTempUPN;
// We need to process the user accounts only
sTemp = pVs->get(GET_BSTR(DCTVS_CopiedAccount_Type));
if ( _wcsicmp((WCHAR*)sTemp,L"user") ) return S_OK;
// get the original source account's UPN
sSUPN = pVs->get(GET_BSTR(DCTVS_CopiedAccount_SourceUPN));
if (sSUPN.length())
{
sTempUPN = sSUPN;
GetUniqueUPN(sTempUPN, pVs, true, sAdsPath);
int len;
WCHAR * ndx, * tempNdx = (WCHAR*)sTempUPN;
do
{
tempNdx = wcschr(tempNdx + 1, L'@');
if ( tempNdx )
ndx = tempNdx;
} while (tempNdx);
if (ndx) len = ndx - sTempUPN;
if (_wcsnicmp(sTempUPN, sSUPN, len) != 0)
return S_OK;
// And only need to process the accounts copied to Win2k domain.
if ( pTarget )
{
//Get the IADs pointer to manipulate properties
hr = pTarget->QueryInterface(IID_IADs, (void**) &pAds);
if ( SUCCEEDED(hr) )
{
var = sSUPN;
hr = pAds->Put(L"userPrincipalName", var);
hr = pAds->SetInfo();
}
}
if ( pAds ) pAds->Release();
}
return S_OK;
}
//---------------------------------------------------------------------------
// GetUniqueUPN : This function checks if the UPN is unique if not then
// appends a number starting with 0 and retries till a unique
// UPN is found.
//---------------------------------------------------------------------------
void CUpdtUPN::GetUniqueUPN(_bstr_t &sUPN, IVarSetPtr pVs, bool bUsingSamName, _bstr_t sAdsPath)
{
// Here are the steps that we follow to get the unique UPN name
// 1. Check if the current name is unique. If it is then return that.
// 2. Append collision prefix and suffix if the sam account name has changed due to pref/suffix.
// 3. Add a numeric suffix to the UPN and repeat till a unique UPN is found.
// If the user tells us not to do this then we simply return the current UPN name.
_bstr_t sProcess = pVs->get(GET_BSTR(DCTVS_Options_AllowDuplicateUPNs));
if ( sProcess == GET_BSTR(IDS_YES) ) return;
WCHAR sTempUPN[5000];
// long x = 0;
WCHAR sQuery[5000], sPath[5000];
HRESULT hr = E_FAIL;
// LPWSTR pCols[] = { L"distinguishedName" };
LPWSTR pCols[] = { L"sAMAccountName" };
BSTR * pData = NULL;
SAFEARRAY * pSaCols = NULL;
SAFEARRAYBOUND bd = { 1, 0 };
_bstr_t sTgtDomain = pVs->get(GET_BSTR(DCTVS_Options_TargetDomainDns));
INetObjEnumeratorPtr pQuery(__uuidof(NetObjEnumerator));
IEnumVARIANT * pEnum = NULL;
DWORD fetched = 0;
_variant_t var;
bool bCollPrefSufProcessed = false;
_bstr_t sSourceSam = pVs->get(GET_BSTR(DCTVS_CopiedAccount_SourceSam));
_bstr_t sTargetSam = pVs->get(GET_BSTR(DCTVS_CopiedAccount_TargetSam));
_bstr_t sPrefix = pVs->get(GET_BSTR(DCTVS_AccountOptions_Prefix));
_bstr_t sSuffix = pVs->get(GET_BSTR(DCTVS_AccountOptions_Suffix));
_bstr_t sPref = pVs->get(GET_BSTR(DCTVS_Options_Prefix));
_bstr_t sSuff = pVs->get(GET_BSTR(DCTVS_Options_Suffix));
int offset = 0;
WCHAR sTemp[5000];
SAFEARRAY * psaPath = NULL;
_variant_t varPath;
_variant_t * pVar;
bool bReplace = false;
WCHAR sTempSAM[MAX_PATH];
_bstr_t sNewSAM;
_bstr_t sUPNSuffix;
_bstr_t sUPNPrefix;
_bstr_t sReplace = pVs->get(GET_BSTR(DCTVS_AccountOptions_ReplaceExistingAccounts));
if (!UStrICmp(sReplace,GET_STRING(IDS_YES)))
bReplace = true;
wcscpy(sTempSAM, (WCHAR*)sSourceSam);
StripSamName(sTempSAM);
if ( sPref.length() )
sNewSAM = sPref + _bstr_t(sTempSAM);
else if ( sSuff.length() )
sNewSAM = _bstr_t(sTempSAM) + sSuff;
else
sNewSAM = sTempSAM;
wcscpy(sTempUPN, (WCHAR*) sUPN);
//Get the stuff before the LAST @ sign.
WCHAR * ndx = NULL;
WCHAR * tempNdx = sTempUPN;
do
{
tempNdx = wcschr(tempNdx + 1, L'@');
if ( tempNdx )
ndx = tempNdx;
} while (tempNdx);
if (ndx) *ndx = L'\0';
sUPNSuffix = ndx+1;
sUPNPrefix = sTempUPN;
// Setup the path name to the domain.
wsprintf(sPath, L"LDAP://%s", (WCHAR*)sTgtDomain);
// setup the columns that we want the query to return to us.
pSaCols = SafeArrayCreate(VT_BSTR, 1, &bd);
if (pSaCols)
{
hr = SafeArrayAccessData(pSaCols, (void HUGEP **) &pData);
if ( SUCCEEDED(hr) )
{
pData[0] = SysAllocString(pCols[0]);
}
hr = SafeArrayUnaccessData(pSaCols);
}
if ( SUCCEEDED(hr) )
{
// First we need to set up a query to find the UPN
wcscpy(sTempUPN, (WCHAR*)sUPN);
do
{
wsprintf(sQuery, L"(userPrincipalName=%s)", sTempUPN);
hr = pQuery->raw_SetQuery(sPath, sTgtDomain, sQuery, ADS_SCOPE_SUBTREE, FALSE);
if ( SUCCEEDED(hr) )
hr = pQuery->raw_SetColumns(pSaCols);
if ( SUCCEEDED(hr) )
hr = pQuery->raw_Execute(&pEnum);
if ( SUCCEEDED(hr) )
{
hr = pEnum->Next(1, &var, &fetched);
while ( hr == S_OK )
{
if ( var.vt & VT_ARRAY )
{
psaPath = var.parray;
hr = SafeArrayAccessData(psaPath, (void HUGEP**) &pVar);
if ( SUCCEEDED(hr) )
{
varPath = pVar[0];
}
SafeArrayUnaccessData(psaPath);
//SafeArrayGetElement(psaPath, &x, (void*)&varPath);
if ( !wcslen((WCHAR*) varPath.bstrVal) )
{
hr = S_FALSE;
}
if ((!_wcsicmp((WCHAR*)varPath.bstrVal, (WCHAR*)sNewSAM)) && (bReplace))
{
// If the account found is the same as the account being processed then we
// need to see if any other accounts have this UPN. if they do then we need
// to change it other wise we do not need to process this any further.
hr = pEnum->Next(1, &var, &fetched);
continue;
}
else
break;
}
}
if ( hr == S_OK )
{
// If we are here that means we have a collision So we need to update the UPN and try again
// See if we have processed the Prefix/Suffix
if ( !bCollPrefSufProcessed )
{
// See if we renamed the samAccountName with the prefix/suffix. If we are already using
// sam name then there is no need to add the prefix/suffix.
if ( !bUsingSamName && RenamedWithPrefixSuffix(sSourceSam, sTargetSam, sPrefix, sSuffix))
{
// Since we renamed the sam names we can rename the UPN
if ( sPrefix.length() )
wsprintf(sTempUPN, L"%s%s", (WCHAR*)sPrefix, (WCHAR*)sUPNPrefix);
if ( sSuffix.length() )
wsprintf(sTempUPN, L"%s%s",(WCHAR*)sUPNPrefix, (WCHAR*)sSuffix);
sUPNPrefix = sTempUPN; // we want to apply the prefix/suffix in any case.
}
else
{
// just add a number to the end of the name.
wsprintf(sTempUPN, L"%s%d", (WCHAR*)sUPNPrefix, offset);
offset++;
}
bCollPrefSufProcessed = true;
}
else
{
// we went through prefix/suffix and still found a collision so we need to go by the count now.
wsprintf(sTempUPN, L"%s%d", (WCHAR*)sUPNPrefix, offset);
offset++;
}
wcscpy(sTemp, sTempUPN);
wsprintf(sTempUPN, L"%s@%s", sTemp, (WCHAR*)sUPNSuffix);
}
VariantInit(&var);
if ( pEnum ) pEnum->Release();
}
} while ( hr == S_OK );
SafeArrayDestroy(pSaCols);
}
sUPN = sTempUPN;
}
//---------------------------------------------------------------------------
// RenamedWithPrefixSuffix : Checks to see if the Target sam name
// was renamed with a prefix/suffix.
//---------------------------------------------------------------------------
bool CUpdtUPN::RenamedWithPrefixSuffix(_bstr_t sSourceSam, _bstr_t sTargetSam, _bstr_t sPrefix, _bstr_t sSuffix)
{
bool retVal = false;
if ( sSourceSam != sTargetSam )
{
if ( sPrefix.length() )
{
if ( !wcsncmp((WCHAR*) sTargetSam, (WCHAR*) sPrefix, sPrefix.length()) )
retVal = true;
}
if ( sSuffix.length() )
{
if ( !wcscmp((WCHAR*) sTargetSam + (sTargetSam.length() - sSuffix.length()), (WCHAR*) sSuffix ) )
retVal = true;
}
}
return retVal;
}
/*********************************************************************
* *
* Written by: Paul Thompson *
* Date: 24 MAR 2001 *
* *
* This function is responsible for retrieving the default UPN *
* suffix to be used in making UPN names. The suffix will be stored *
* in a class member variable. *
* First, using the given target OU path, see if the target OU *
* has any UPN suffixes defined for it. If so, return store the *
* last one enumerated. Otherwise, see if any UPN suffixes have *
* been defined on the configuration's partition. If so, store the *
* last one enumerated. If no success yet, use the forest root's *
* domain DNS name. *
* *
*********************************************************************/
//BEGIN GetDefaultUPNSuffix
bool CUpdtUPN::GetDefaultUPNSuffix(_bstr_t sDomainDNS, _bstr_t sTargetOU)
{
/* local variables */
IADs * pDSE = NULL;
IADs * pCont = NULL;
WCHAR sRoot[1000];
HRESULT hr = S_OK;
_variant_t var;
_variant_t HUGEP * pVar;
int nLast;
/* function body */
//check incoming parameters
if ((sDomainDNS.length() == 0) || (sTargetOU.length() == 0))
return false;
/* first see if the target OU has UPN suffixes defined */
//get a pointer to the target OU
hr = ADsGetObject(sTargetOU,IID_IADs,(void**)&pCont);
if ( SUCCEEDED(hr) )
{
//get any UPN suffixes defined
hr = pCont->Get( L"uPNSuffixes", &var);
if ( SUCCEEDED(hr) )
{
//if one, store it and return
if ( var.vt == VT_BSTR )
{
m_sUPNSuffix = var.bstrVal; //store the suffix
pCont->Release();
return true;
}
//else if nore than one, get the first one, store it, and return
else if ( var.vt & VT_ARRAY )
{
SAFEARRAY * multiVals = var.parray;
SafeArrayAccessData(multiVals, (void HUGEP **) &pVar);
nLast = multiVals->rgsabound->cElements - 1;
m_sUPNSuffix = _bstr_t(V_BSTR(&pVar[nLast]));
SafeArrayUnaccessData(multiVals);
pCont->Release();
return true;
}
}//end if suffixes defined on the partition
pCont->Release();
pCont = NULL;
}//if got partition
/* next try the UPN suffixes on the partition container or the root
domain's DNS name */
//get the root DSE container
wcscpy(sRoot,L"LDAP://RootDSE");
hr = ADsGetObject(sRoot,IID_IADs,(void**)&pDSE);
if ( SUCCEEDED(hr) )
{
//get the suffixes listed on the configuration partition
hr = pDSE->Get(L"configurationNamingContext",&var);
if ( SUCCEEDED(hr) )
{
swprintf(sRoot,L"LDAP://%ls/CN=Partitions,%ls", (WCHAR*)sDomainDNS, var.bstrVal);
hr = ADsGetObject(sRoot,IID_IADs,(void**)&pCont);
if ( SUCCEEDED(hr) )
{
//get any UPN suffixes defined
hr = pCont->Get( L"uPNSuffixes", &var);
if ( SUCCEEDED(hr) )
{
//if one, store it and return
if ( var.vt == VT_BSTR )
{
m_sUPNSuffix = var.bstrVal; //store the suffix
pDSE->Release();
pCont->Release();
return true;
}
//else if nore than one, get the first one, store it, and return
else if ( var.vt & VT_ARRAY )
{
SAFEARRAY * multiVals = var.parray;
SafeArrayAccessData(multiVals, (void HUGEP **) &pVar);
nLast = multiVals->rgsabound->cElements - 1;
m_sUPNSuffix = _bstr_t(V_BSTR(&pVar[nLast]));
SafeArrayUnaccessData(multiVals);
pDSE->Release();
pCont->Release();
return true;
}
}//end if suffixes defined on the partition
pCont->Release();
pCont = NULL;
}//if got partition
}//if got config naming context
//since no UPN suffixes defined on the partition, try the root domain's
//DNS name
hr = pDSE->Get(L"RootDomainNamingContext",&var);
if ( SUCCEEDED(hr) )
{
//convert the DN of the root domain to a DNS name, store it, and return
m_sUPNSuffix = GetDomainDNSFromPath(_bstr_t(var.bstrVal));
pDSE->Release();
return true;
}
pDSE->Release();
pDSE = NULL;
}//if got rootDSE
return false;
}
//END GetDefaultUPNSuffix
/*********************************************************************
* *
* Written by: Paul Thompson *
* Date: 26 MAR 2001 *
* *
* This function is responsible for extracting the UPN Suffix *
* from a given UPN name and returning that suffix. *
* *
*********************************************************************/
//BEGIN GetUPNSuffix
_bstr_t CUpdtUPN::GetUPNSuffix(_bstr_t sUPNName)
{
/* local variables */
_bstr_t sUPNSuffix = L"";
WCHAR * pTemp;
/* function body */
//check incoming parameters
if (sUPNName.length() == 0)
return sUPNSuffix;
//find the last '@'
pTemp = wcsrchr((WCHAR*)sUPNName, L'@');
//if found, copy the suffix to the return variable
if (pTemp)
sUPNSuffix = pTemp+1;
return sUPNSuffix;
}
//END GetUPNSuffix
/*********************************************************************
* *
* Written by: Paul Thompson *
* Date: 26 MAR 2001 *
* *
* This function is responsible for replacing the UPN Suffix *
* on a given UPN name with the given suffix and returning the new *
* UPN name. *
* *
*********************************************************************/
//BEGIN ChangeUPNSuffix
_bstr_t CUpdtUPN::ChangeUPNSuffix(_bstr_t sUPNName, _bstr_t sNewSuffix)
{
/* local variables */
_bstr_t sNewUPN = L"";
WCHAR * pTemp;
/* function body */
//check incoming parameters
if (sUPNName.length() == 0)
return sNewUPN;
//create a temporary buffer to hold the UPN Name
WCHAR* sUPN = new WCHAR[sUPNName.length() + 1];
if (!sUPN)
return sNewUPN;
//copy the UPN to this buffer
wcscpy(sUPN, sUPNName);
//find the last '@'
pTemp = wcsrchr(sUPN, L'@');
//if found, make the new UPN with the old Prefix and given suffix
if (pTemp)
{
//end the string after the '@'
*(pTemp+1) = L'\0';
//copy the Prefix plus the new Suffix to the new UPN name
sNewUPN = sUPN + sNewSuffix;
}
//delete the prefix string
delete [] sUPN;
return sNewUPN;
}
//END ChangeUPNSuffix
Reference in a new issue Copy permalink