able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/dscmd/dsquery/output.cpp

1570 lines
48 KiB
C++
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000
//
// File: output.cpp
//
// Contents: Defines the functions which displays the query output
// History: 05-OCT-2000 hiteshr Created
//
//
//--------------------------------------------------------------------------
#include "pch.h"
#include "cstrings.h"
#include "usage.h"
#include "querytable.h"
#include "querybld.h"
#include "dsquery.h"
#include "query.h"
#include "resource.h"
#include "stdlib.h"
#include "output.h"
#include "sddl.h"
#include <dscmn.h>
//
// list was causing unused formal parameter warnings when compiling with /W4
//
#pragma warning(disable : 4100)
#include <list>
#pragma warning(default : 4100)
HRESULT GetStringFromADs(const ADSVALUE *pValues,
ADSTYPE dwADsType,
LPWSTR pBuffer,
DWORD dwBufferLen,
LPCWSTR lpszAttrName);
HRESULT OutputFetchAttr(IN LPWSTR * ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch *pSearch,
IN BOOL bListFormat);
HRESULT OutputAllAttr(IN CDSSearch *pSearch, BOOL bAttrOnly);
HRESULT OutputSingleAttr(IN LPWSTR * ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch *pSearch);
BOOL IsQueryLimitReached(int iResultsDisplayed)
{
if(g_iQueryLimit != 0)
{
if(iResultsDisplayed == g_iQueryLimit)
{
if(!g_bQuiet)
{
if(g_bDeafultLimit)
WriteStringIDToStandardOut(IDS_DEFAULT_QUERY_LIMIT_REACHED);
else
WriteStringIDToStandardOut(IDS_QUERY_LIMIT_REACHED);
}
return TRUE;
}
}
return FALSE;
}
HRESULT LocalCopyString(LPTSTR* ppResult, LPCTSTR pString)
{
if ( !ppResult || !pString )
return E_INVALIDARG;
*ppResult = (LPTSTR)LocalAlloc(LPTR, (wcslen(pString)+1)*sizeof(WCHAR) );
if ( !*ppResult )
return E_OUTOFMEMORY;
lstrcpy(*ppResult, pString);
return S_OK; // success
}
//+--------------------------------------------------------------------------
//
// Function: DisplayList
//
// Synopsis: Dispalys a name and value in list format.
// Arguments: [szName - IN] : name of the attribute
// [szValue - IN]: value of the attribute
// [bShowAttribute - IN] : if true the attribute name will be
// prepended to the output
//
//
// History: 05-OCT-2000 hiteshr Created
// 13-Dec-2000 JeffJon Modified - Added the bShowAttribute flag
// so that the caller can determine whether
// or not to show the attribute name
//
//---------------------------------------------------------------------------
VOID DisplayList(LPCWSTR szName, LPCWSTR szValue, bool bShowAttribute = true)
{
if(!szName)
return;
CComBSTR strTemp;
if (bShowAttribute)
{
strTemp = szName;
strTemp += L": ";
}
if(szValue)
strTemp += szValue;
DisplayOutput(strTemp);
}
//+--------------------------------------------------------------------------
//
// Function: DsQueryOutput
//
// Synopsis: This functions outputs the query results.
//
// Arguments: [outputFormat IN] Output format specified at commandline.
// [ppszAttributes IN] List of attributes fetched by query
// [cAttributes,IN] Number of arributes in above array
// [*pSeach,IN] Search Object which has queryhandle
// [bListFormat IN] Is Output to shown in List Format.
// This is valid for "dsquery *" only.
// Returns: HRESULT : S_OK if everything succeeded
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
// History: 25-Sep-2000 hiteshr Created
//
//---------------------------------------------------------------------------
HRESULT DsQueryOutput( IN DSQUERY_OUTPUT_FORMAT outputFormat,
IN LPWSTR * ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch *pSearch,
IN BOOL bListFormat )
{
ENTER_FUNCTION_HR(FULL_LOGGING, DsQueryOutput, hr);
if(!pSearch)
{
ASSERT(FALSE);
hr = E_INVALIDARG;
return hr;
}
if(outputFormat == DSQUERY_OUTPUT_ATTRONLY)
{
hr = OutputAllAttr(pSearch, TRUE);
return hr;
}
else if(outputFormat == DSQUERY_OUTPUT_ATTR)
{
//
//Attributes to display were specified at command line
//
if(cAttributes)
{
hr = OutputFetchAttr(ppszAttributes,
cAttributes,
pSearch,
bListFormat);
return hr;
}
else
{
//
//No attributes were specified at commandline Display All the attributes.
//
hr = OutputAllAttr(pSearch, FALSE);
return hr;
}
}
else
{
//
//Do the output for "dsquery objecttype"
//
hr = OutputSingleAttr(ppszAttributes,
cAttributes,
pSearch);
return hr;
}
}
//+--------------------------------------------------------------------------
//
// Function: GetServerSearchRoot
//
// Synopsis: Builds the path to the root of the search as determined by
// the parameters passed in from the command line.
//
// Arguments: [pCommandArgs IN] : the table of the command line input
// [refBasePathsInfo IN] : reference to the base paths info
// [refsbstrDN OUT] : reference to a CComBSTR that will
// receive the DN at which to start
// the search
//
// Returns: SERVER_QUERY_SCOPE : a value from the enumeration that represents
// the scope that will be searched
//
// History: 11-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
DWORD GetServerSearchRoot(IN PARG_RECORD pCommandArgs,
IN CDSCmdBasePathsInfo& refBasePathsInfo,
OUT CComBSTR& refsbstrDN)
{
ENTER_FUNCTION(LEVEL3_LOGGING, GetServerSearchRoot);
DWORD scope = SERVER_QUERY_SCOPE_FOREST;
CComBSTR sbstrRootDN = L"CN=Sites,";
sbstrRootDN += refBasePathsInfo.GetConfigurationNamingContext();
do // false loop
{
//
// Validate parameters
//
if (!pCommandArgs)
{
ASSERT(pCommandArgs);
break;
}
if (pCommandArgs[eServerSite].bDefined &&
pCommandArgs[eServerSite].strValue)
{
DEBUG_OUTPUT(FULL_LOGGING,
L"Using the site as the root of the search: %s",
pCommandArgs[eServerSite].strValue);
//
// Prepend the named site container to the current root
//
CComBSTR sbstrTemp = L"CN=";
sbstrTemp += pCommandArgs[eServerSite].strValue;
sbstrTemp += L",";
sbstrTemp += sbstrRootDN;
sbstrRootDN = sbstrTemp;
DEBUG_OUTPUT(FULL_LOGGING,
L"scope = SERVER_QUERY_SCOPE_SITE");
scope = SERVER_QUERY_SCOPE_SITE;
}
else
{
DEBUG_OUTPUT(FULL_LOGGING,
L"scope = SERVER_QUERY_SCOPE_FOREST");
scope = SERVER_QUERY_SCOPE_FOREST;
}
if (pCommandArgs[eServerDomain].bDefined &&
pCommandArgs[eServerDomain].strValue)
{
DEBUG_OUTPUT(FULL_LOGGING,
L"scope |= SERVER_QUERY_SCOPE_DOMAIN");
scope |= SERVER_QUERY_SCOPE_DOMAIN;
}
refsbstrDN = sbstrRootDN;
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"search root = %s",
refsbstrDN);
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"search scope = 0x%x",
scope);
} while (false);
return scope;
}
//+--------------------------------------------------------------------------
//
// Function: GetSubnetSearchRoot
//
// Synopsis: Builds search root path for Subnet. Its always
// cn=subnet,cn=site in configuration container
//
// Arguments: [refBasePathsInfo IN] : reference to the base paths info
// [refsbstrDN OUT] : reference to a CComBSTR that will
// receive the DN at which to start
// the search
//
// Returns: HRESULT
//
// History: 24-April-2001 hiteshr Created
//
//---------------------------------------------------------------------------
VOID GetSubnetSearchRoot(IN CDSCmdBasePathsInfo& refBasePathsInfo,
OUT CComBSTR& refsbstrDN)
{
ENTER_FUNCTION(LEVEL3_LOGGING, GetSubnetSearchRoot);
refsbstrDN = L"CN=subnets,CN=Sites,";
refsbstrDN += refBasePathsInfo.GetConfigurationNamingContext();
return;
}
//+--------------------------------------------------------------------------
//
// Function: GetSiteContainerPath
//
// Synopsis: Returns the DN for site container in Configuration
// container
//
// Arguments: [refBasePathsInfo IN] : reference to the base paths info
// [refsbstrDN OUT] : reference to a CComBSTR that will
// receive the DN
//
// Returns: HRESULT
//
// History: 24-April-2001 hiteshr Created
//
//---------------------------------------------------------------------------
VOID GetSiteContainerPath(IN CDSCmdBasePathsInfo& refBasePathsInfo,
OUT CComBSTR& refSubSiteSuffix)
{
ENTER_FUNCTION(LEVEL3_LOGGING, GetSubnetSearchRoot);
refSubSiteSuffix = L"CN=Sites,";
refSubSiteSuffix += refBasePathsInfo.GetConfigurationNamingContext();
return;
}
//+--------------------------------------------------------------------------
//
// Function: GetGCList
//
// Synopsis: Does a search from the passed in path looking for GCs
//
// Arguments: [pszSearchRootPath IN] : the path to the root of the search
// [refCredObject IN] : reference to the credential object
// [refGCList OUT] : reference to an STL list that will
// take the DNs of the GCs
//
//
// Returns: HRESULT : S_OK if everything succeeded
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
// Remarks: Caller must free all strings added to the list by calling
// SysFreeString()
//
// History: 08-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
HRESULT GetGCList( IN PCWSTR pszSearchRootPath,
IN const CDSCmdCredentialObject& refCredObject,
OUT std::list<PWSTR>& refGCList)
{
ENTER_FUNCTION_HR(LEVEL3_LOGGING, GetGCList, hr);
do // false loop
{
//
// Verify parameters
//
if (!pszSearchRootPath)
{
ASSERT(pszSearchRootPath);
hr = E_INVALIDARG;
break;
}
//
// Search for NTDSDSA objects that have the options bit set for a GC
//
CDSSearch gcSearchObj;
hr = gcSearchObj.Init(pszSearchRootPath,
refCredObject);
if (FAILED(hr))
{
break;
}
//
// Prepare the search object
//
PWSTR ppszAttrs[] = { L"distinguishedName" };
DWORD dwAttrCount = sizeof(ppszAttrs)/sizeof(PCWSTR);
PWSTR pszGCFilter = L"(&(objectClass=nTDSDSA)(options:LDAP_MATCHING_RULE_BIT_AND_W:=1))";
gcSearchObj.SetFilterString(pszGCFilter);
gcSearchObj.SetSearchScope(ADS_SCOPE_SUBTREE);
gcSearchObj.SetAttributeList(ppszAttrs, dwAttrCount);
hr = gcSearchObj.DoQuery();
if (FAILED(hr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Failed to search for NTDSDSA objects that are GCs: hr = 0x%x",
hr);
break;
}
while (SUCCEEDED(hr))
{
hr = gcSearchObj.GetNextRow();
if (FAILED(hr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"GetNextRow() failed: hr = 0x%x",
hr);
break;
}
if (hr == S_ADS_NOMORE_ROWS)
{
hr = S_OK;
break;
}
ADS_SEARCH_COLUMN column;
ZeroMemory(&column, sizeof(ADS_SEARCH_COLUMN));
hr = gcSearchObj.GetColumn(ppszAttrs[0], &column);
if (FAILED(hr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Failed to get column %s",
ppszAttrs[0]);
break;
}
ASSERT(0 == _wcsicmp(column.pszAttrName, ppszAttrs[0]));
if (column.dwNumValues == 1 &&
column.pADsValues)
{
//
// Since the server is really the parent of the NTDSDSA object,
// get the server DN and add it to the list
//
CComBSTR sbstrParentDN;
hr = CPathCracker::GetParentDN(column.pADsValues->DNString,
sbstrParentDN);
if (SUCCEEDED(hr))
{
refGCList.push_back(sbstrParentDN.Copy());
DEBUG_OUTPUT(FULL_LOGGING,
L"GC found: %s",
column.pADsValues->DNString);
}
else
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Failed to get the parent DN from the NTDSDSA DN: %s",
column.pADsValues->DNString);
break;
}
}
else
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"The column has no values!");
}
hr = gcSearchObj.FreeColumn(&column);
ASSERT(SUCCEEDED(hr));
}
} while (false);
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: GetFSMOList
//
// Synopsis: Does a search from the passed in path looking for the FSMO
// role owners
//
// Arguments: [pszSearchRootPath IN] : the path to the root of the search
// [refBasePathsInfo IN] : reference to the base paths info
// [refCredObject IN] : reference to the credential object
// [pszFSMOArg IN] : the value of the -hasfsmo arg
// [refFSMOList OUT] : reference to the search object that
// will hold the results
//
//
// Returns: HRESULT : S_OK if everything succeeded
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
// Remarks: Caller must free all strings added to the list by calling
// SysFreeString()
//
// History: 11-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
HRESULT GetFSMOList( IN PCWSTR pszSearchRootPath,
IN CDSCmdBasePathsInfo& refBasePathsInfo,
IN const CDSCmdCredentialObject& refCredObject,
IN PCWSTR pszFSMOArg,
OUT std::list<PWSTR>& refFSMOList)
{
ENTER_FUNCTION_HR(LEVEL3_LOGGING, GetFSMOList, hr);
do // false loop
{
//
// Verify parameters
//
if (!pszSearchRootPath ||
!pszFSMOArg)
{
ASSERT(pszSearchRootPath);
hr = E_INVALIDARG;
break;
}
FSMO_TYPE fsmoType = SCHEMA_FSMO;
if (0 == _wcsicmp(pszFSMOArg, g_pszSchema))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching for the schema FSMO holder");
fsmoType = SCHEMA_FSMO;
}
else if (0 == _wcsicmp(pszFSMOArg, g_pszName))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching for the domain naming master FSMO holder");
fsmoType = DOMAIN_NAMING_FSMO;
}
else if (0 == _wcsicmp(pszFSMOArg, g_pszInfr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching for the infrastructure FSMO holder");
fsmoType = INFRASTUCTURE_FSMO;
}
else if (0 == _wcsicmp(pszFSMOArg, g_pszPDC))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching for the PDC FSMO holder");
fsmoType = PDC_FSMO;
}
else if (0 == _wcsicmp(pszFSMOArg, g_pszRID))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching for the RID FSMO holder");
fsmoType = RID_POOL_FSMO;
}
else
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Unknown FSMO was passed in: %s",
pszFSMOArg);
hr = E_INVALIDARG;
break;
}
CComBSTR sbstrServerDN;
hr = FindFSMOOwner(refBasePathsInfo,
refCredObject,
fsmoType,
sbstrServerDN);
if (FAILED(hr))
{
break;
}
refFSMOList.push_back(sbstrServerDN.Copy());
} while (false);
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: IsObjectValidInAllLists
//
// Synopsis: Determines if the passed in DN exists in the other lists
//
// Arguments: [pszDN IN] : DN to search for in the lists
// [refGCList IN] : reference to the list of GCs found
// [bUseGCList IN] : if true refGCList will be used to validate DN
// [refFSMOList IN] : reference to the list of FSMO holders found
// [bUseFSMOList IN] : if true refFSMOList will be used to validate DN
//
// Returns: bool : true if the object is in all valid lists
// false otherwise
//
// History: 12-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
bool IsObjectValidInAllLists(IN PCWSTR pszDN,
IN DWORD scope,
IN PCWSTR pszDomain,
IN const std::list<PWSTR>& refGCList,
IN bool bUseGCList,
IN const std::list<PWSTR>& refFSMOList,
IN bool bUseFSMOList)
{
ENTER_FUNCTION(LEVEL3_LOGGING, IsObjectValidInAllLists);
bool bReturn = false;
PWSTR pszName = 0;
do // false loop
{
//
// Validate parameters
//
if (!pszDN)
{
ASSERT(pszDN);
return false;
}
bool bFoundInGCList = false;
bool bFoundInFSMOList = false;
DEBUG_OUTPUT(LEVEL7_LOGGING,
L"Searching for %s",
pszDN);
if (scope & SERVER_QUERY_SCOPE_DOMAIN)
{
if (!pszDomain)
{
//
// If no domain was specified there is no way we could find a match
//
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"The scope is domain but no domain argument was specified!");
bReturn = false;
break;
}
DEBUG_OUTPUT(FULL_LOGGING,
L"Looking for domain: %s",
pszDomain);
//
// Use CrackName to get the domain name from the DN
//
HRESULT hr = CrackName(const_cast<PTSTR>(pszDN),
&pszName,
GET_DNS_DOMAIN_NAME,
NULL);
if (FAILED(hr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Failed to crack the DN into a domain name: hr = 0x%x",
hr);
bReturn = false;
break;
}
if (0 != _wcsicmp(pszName, pszDomain))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Domain names don't match");
bReturn = false;
break;
}
}
if (bUseGCList)
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching through GC list...");
std::list<PWSTR>::iterator itr;
for (itr = refGCList.begin(); itr != refGCList.end(); ++itr)
{
if (0 == _wcsicmp(*itr, pszDN))
{
bFoundInGCList = true;
break;
}
}
}
if (bUseFSMOList)
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Searching through FSMO list...");
std::list<PWSTR>::iterator itr;
for (itr = refFSMOList.begin(); itr != refFSMOList.end(); ++itr)
{
DEBUG_OUTPUT(FULL_LOGGING,
L"Comparing: %s and %s",
*itr,
pszDN);
if (0 == _wcsicmp(*itr, pszDN))
{
bFoundInFSMOList = true;
break;
}
}
}
bReturn = ((bUseGCList && bFoundInGCList) || !bUseGCList) &&
((bUseFSMOList && bFoundInFSMOList) || !bUseFSMOList);
} while (false);
if(pszName)
LocalFree(pszName);
if (bReturn)
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"%s is a valid result",
pszDN);
}
else
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"%s is NOT a valid result",
pszDN);
}
return bReturn;
}
//+--------------------------------------------------------------------------
//
// Function: OutputValidSearchResult
//
// Synopsis: Determines if the passed in DN exists in the other lists
//
// Arguments: [refSearchObject - IN] : reference to the object that performed
// the search
// [ppszAttributes - IN] : list of attributes to be displayed
// [cAttributes - IN] : count of attributes in ppszAttributes
//
// Returns:
//
// History: 12-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
void OutputValidSearchResult(IN DSQUERY_OUTPUT_FORMAT outputFormat,
IN CDSSearch& refSearchObject,
IN PWSTR* ppszAttributes,
IN DWORD cAttributes)
{
ENTER_FUNCTION(LEVEL5_LOGGING, OutputValidSearchResult);
HRESULT hr = S_OK;
WCHAR pBuffer[MAXSTR];
if (!ppszAttributes ||
cAttributes == 0)
{
ASSERT(cAttributes > 0);
ASSERT(ppszAttributes);
return;
}
//
// Output in list format, note that we are only displaying one attribute
// The first attribute in the array must be the one we want to display
//
ADS_SEARCH_COLUMN ColumnData;
hr = refSearchObject.GetColumn(ppszAttributes[0], &ColumnData);
if(SUCCEEDED(hr))
{
ADSVALUE *pValues = ColumnData.pADsValues;
for( DWORD j = 0; j < ColumnData.dwNumValues && pValues; ++j )
{
hr = GetStringFromADs(pValues,
ColumnData.dwADsType,
pBuffer,
MAXSTR,
ppszAttributes[0]);
if(SUCCEEDED(hr))
{
CComBSTR sbstrTemp;
if (outputFormat == DSQUERY_OUTPUT_DN)
{
sbstrTemp = L"\"";
sbstrTemp += pBuffer;
sbstrTemp += L"\"";
}
else
{
sbstrTemp = pBuffer;
}
DisplayList(ppszAttributes[0], sbstrTemp, false);
}
++pValues;
}
refSearchObject.FreeColumn(&ColumnData);
}
}
//+--------------------------------------------------------------------------
//
// Function: DsQueryServerOutput
//
// Synopsis: This functions outputs the query results for server object.
//
// Arguments: [outputFormat IN] Output format specified at commandline.
// [ppszAttributes IN] List of attributes fetched by query
// [cAttributes,IN] Number of arributes in above array
// [refServerSearch,IN]reference to the search Object
// [refBasePathsInfo IN] reference to the base paths info
// [pCommandArgs,IN] The pointer to the commands table
//
// Returns: HRESULT : S_OK if everything succeeded
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
// History: 08-Dec-2000 JeffJon Created
//
//---------------------------------------------------------------------------
HRESULT DsQueryServerOutput( IN DSQUERY_OUTPUT_FORMAT outputFormat,
IN LPWSTR* ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch& refServerSearch,
IN const CDSCmdCredentialObject& refCredObject,
IN CDSCmdBasePathsInfo& refBasePathsInfo,
IN PARG_RECORD pCommandArgs)
{
ENTER_FUNCTION_HR(LEVEL3_LOGGING, DsQueryServerOutput, hr);
std::list<PWSTR> gcList;
std::list<PWSTR> fsmoList;
do // false loop
{
//
// Validate parameters
//
if (!ppszAttributes ||
!pCommandArgs)
{
ASSERT(ppszAttributes);
ASSERT(pCommandArgs);
hr = E_INVALIDARG;
break;
}
//
// Determine the scope that should be used
//
CComBSTR sbstrSearchRootDN;
DWORD scope = GetServerSearchRoot(pCommandArgs,
refBasePathsInfo,
sbstrSearchRootDN);
CComBSTR sbstrSearchRootPath;
refBasePathsInfo.ComposePathFromDN(sbstrSearchRootDN, sbstrSearchRootPath);
//
// Build the list of GCs if needed
//
bool bUseGCSearchResults = false;
if (pCommandArgs[eServerIsGC].bDefined &&
pCommandArgs[eServerIsGC].bValue)
{
hr = GetGCList(sbstrSearchRootPath,
refCredObject,
gcList);
if (FAILED(hr))
{
break;
}
//
// If we didn't get any values then there is no reason to continue
// since we won't have anything that matches the -isgc flag
//
if (gcList.size() < 1)
{
break;
}
bUseGCSearchResults = true;
}
//
// Build the list of FSMO owners if needed
//
bool bUseFSMOSearchResults = false;
if (pCommandArgs[eServerHasFSMO].bDefined &&
pCommandArgs[eServerHasFSMO].strValue)
{
hr = GetFSMOList(sbstrSearchRootPath,
refBasePathsInfo,
refCredObject,
pCommandArgs[eServerHasFSMO].strValue,
fsmoList);
if (FAILED(hr))
{
break;
}
bUseFSMOSearchResults = true;
}
//
// See if we need to filter on domain
//
bool bUseDomainFiltering = false;
if (pCommandArgs[eServerDomain].bDefined &&
pCommandArgs[eServerDomain].strValue)
{
bUseDomainFiltering = true;
}
if (!bUseGCSearchResults &&
!bUseFSMOSearchResults &&
!bUseDomainFiltering)
{
hr = DsQueryOutput(outputFormat,
ppszAttributes,
cAttributes,
&refServerSearch,
true);
}
else
{
//
// Either -isgc or -hasfsmo was specified so we have to take the intersection
// of the lists of objects found in each search to use as output
//
while (SUCCEEDED(hr))
{
hr = refServerSearch.GetNextRow();
if (FAILED(hr))
{
break;
}
if (hr == S_ADS_NOMORE_ROWS)
{
hr = S_OK;
break;
}
ADS_SEARCH_COLUMN column;
ZeroMemory(&column, sizeof(ADS_SEARCH_COLUMN));
//
// Get the DN
//
hr = refServerSearch.GetColumn((PWSTR)g_szAttrServerReference, &column);
if (FAILED(hr))
{
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"Failed to get the distinguishedName for a column: hr = 0x%x",
hr);
DEBUG_OUTPUT(LEVEL3_LOGGING,
L"continuing...");
hr = S_OK;
continue;
}
if (column.dwNumValues == 1 &&
column.pADsValues)
{
//
// Search the lists and determine if the DN exists in all the lists
//
bool bValidEntry = IsObjectValidInAllLists(column.pADsValues->DNString,
scope,
pCommandArgs[eServerDomain].strValue,
gcList,
bUseGCSearchResults,
fsmoList,
bUseFSMOSearchResults);
if (bValidEntry)
{
//
// Output this server object since it matches all search criteria
//
OutputValidSearchResult(outputFormat,
refServerSearch,
ppszAttributes,
cAttributes);
}
}
hr = refServerSearch.FreeColumn(&column);
ASSERT(SUCCEEDED(hr));
}
}
} while (false);
std::list<PWSTR>::iterator gcItr;
for (gcItr = gcList.begin(); gcItr != gcList.end(); ++gcItr)
{
SysFreeString(*gcItr);
}
std::list<PWSTR>::iterator fsmoItr;
for (fsmoItr = fsmoList.begin(); fsmoItr != fsmoList.end(); ++fsmoItr)
{
SysFreeString(*fsmoItr);
}
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: OutputFetchAttr
//
// Synopsis: Dispalys the fetched attributes in either list or table format
// Arguments: [ppszAttributes - IN] : Array containing list of attributes to display
// [cAttributes - IN]: Count of attributes in ppszAttributes
// [pSearch - IN]: pointer to search object
// [bListFormat - IN]: List or Table format
// Returns HRESULT S_OK if Successful
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
//
// History: 05-OCT-2000 hiteshr Created
//
//---------------------------------------------------------------------------
HRESULT OutputFetchAttr(IN LPWSTR * ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch *pSearch,
IN BOOL bListFormat)
{
ENTER_FUNCTION_HR(FULL_LOGGING, OutputFetchAttr, hr);
WCHAR pBuffer[MAXSTR];
ZeroMemory(pBuffer, sizeof(pBuffer));
if(bListFormat)
{
//
//Display in list format
//
int cListDisplayed = 0;
while(TRUE)
{
hr = pSearch->GetNextRow();
if(IsQueryLimitReached(cListDisplayed))
break;
if(hr == S_ADS_NOMORE_ROWS || FAILED(hr))
break;
bool bShowAttributes = false;
if (cAttributes > 1)
{
bShowAttributes = true;
}
for(DWORD i = 0; i < cAttributes; ++i)
{
ADS_SEARCH_COLUMN ColumnData;
hr = pSearch->GetColumn(ppszAttributes[i], &ColumnData);
if(SUCCEEDED(hr))
{
ADSVALUE *pValues = ColumnData.pADsValues;
for( DWORD j = 0; j < ColumnData.dwNumValues; ++j )
{
hr = GetStringFromADs(pValues,
ColumnData.dwADsType,
pBuffer,
MAXSTR,
ppszAttributes[i]);
if(SUCCEEDED(hr))
DisplayList(ppszAttributes[i], pBuffer, bShowAttributes);
++pValues;
}
pSearch->FreeColumn(&ColumnData);
}
else if(hr == E_ADS_COLUMN_NOT_SET)
DisplayList(ppszAttributes[i], L"", bShowAttributes);
}
cListDisplayed++;
}
if(hr == S_ADS_NOMORE_ROWS)
hr = S_OK;
return hr;
}
else
{
//
//Display in table format
//
//
//format will use first 80 rows to calculate column width
//
CFormatInfo format;
LONG sampleSize = 80;
//
//sampleSize should be lessthan or equal to QueryLimit
//
if(g_iQueryLimit != 0 && (sampleSize > g_iQueryLimit))
sampleSize = g_iQueryLimit;
LONG cRow = 0;
hr = format.Init(sampleSize,cAttributes,ppszAttributes);
if(FAILED(hr))
return hr;
//
//Display in table format
//
while(TRUE)
{
//
//we have reached sampleSize, so display column headers and
//display all the sample rows.
//
if(cRow == sampleSize)
{
format.DisplayHeaders();
format.DisplayAllRows();
}
hr = pSearch->GetNextRow();
//We are done
if(hr == S_ADS_NOMORE_ROWS || FAILED(hr))
break;
//
//Check if we have reached querylimit
//
if(IsQueryLimitReached(cRow))
break;
//
//Fetch columns
//
for( DWORD i = 0; i < cAttributes; ++i )
{
ADS_SEARCH_COLUMN ColumnData;
hr = pSearch->GetColumn(ppszAttributes[i], &ColumnData);
CComBSTR strValue;
if(SUCCEEDED(hr))
{
strValue = "";
ADSVALUE *pValues = ColumnData.pADsValues;
for( DWORD j = 0; j < ColumnData.dwNumValues; ++j )
{
hr = GetStringFromADs(pValues,
ColumnData.dwADsType,
pBuffer,
MAXSTR,
ppszAttributes[i]);
//
//In table format multiple values are shown separated by ;
//
if(SUCCEEDED(hr))
{
strValue += pBuffer;
if(ColumnData.dwNumValues > 1)
{
strValue += L";";
}
}
++pValues;
}
pSearch->FreeColumn(&ColumnData);
}
if(SUCCEEDED(hr) || hr == E_ADS_COLUMN_NOT_SET)
{
if(cRow < sampleSize)
{
//
//Cache this value in format and use it to calculate column width
//
format.Set(cRow,i,strValue);
}
else
{
//
//Display the column value
//
format.DisplayColumn(i,strValue);
if(i == (cAttributes - 1))
format.NewLine();
}
}
}
++cRow;
}//End of while loop
if(hr == S_ADS_NOMORE_ROWS)
hr = S_OK;
if(cRow && (cRow < sampleSize))
{
//
//if total number of rows is less that sample size they are not
//displayed yet. Display them
//
format.DisplayHeaders();
format.DisplayAllRows();
}
return hr;
}
}
//+--------------------------------------------------------------------------
//
// Function: OutputSingleAttr
//
// Synopsis: Displays the single attribute which user has asked for.
// Arguments: [ppszAttributes - IN] : Array containing list of attributes to display
// [cAttributes - IN]: Count of attributes in ppszAttributes. Should be 1
// [pSearch - IN]: pointer to search object
// Returns HRESULT S_OK if Successful
// E_INVALIDARG
// Anything else is a failure code from an ADSI call
//
//
// History: 05-OCT-2000 hiteshr Created
//
//---------------------------------------------------------------------------
HRESULT OutputSingleAttr(IN LPWSTR * ppszAttributes,
IN DWORD cAttributes,
IN CDSSearch *pSearch)
{
ENTER_FUNCTION_HR(FULL_LOGGING, OutputSingleAttr, hr);
if(!ppszAttributes || !cAttributes || !pSearch)
{
ASSERT(FALSE);
hr = E_INVALIDARG;
return hr;
}
ASSERT(cAttributes > 0);
WCHAR pBuffer[MAXSTR];
ZeroMemory(pBuffer, sizeof(pBuffer));
LONG cRow = 0;
while(TRUE)
{
hr = pSearch->GetNextRow();
//We are done
if(hr == S_ADS_NOMORE_ROWS || FAILED(hr))
break;
//
//Check if we have reached querylimit
//
if(IsQueryLimitReached(cRow))
break;
ADS_SEARCH_COLUMN ColumnData;
hr = pSearch->GetColumn(ppszAttributes[0], &ColumnData);
if(SUCCEEDED(hr))
{
hr = GetStringFromADs(ColumnData.pADsValues,
ColumnData.dwADsType,
pBuffer,
MAXSTR,
ppszAttributes[0]);
if(SUCCEEDED(hr))
{
//Display the output enclosed in Double Quotes
CComBSTR strTemp;
strTemp = L"\"" ;
strTemp += pBuffer;
strTemp += L"\"";
DisplayOutput(strTemp);
}
pSearch->FreeColumn(&ColumnData);
}
else if(hr == E_ADS_COLUMN_NOT_SET)
{
//
//If Attribute is not set display ""
//
DisplayOutput(L"\"\"");
}
//
//Increment number of Row displayed
//
cRow++;
}//End of while loop
if(hr == S_ADS_NOMORE_ROWS)
hr = S_OK;
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: OutputAllAttr
//
// Synopsis: Displays all the attributes.
// Arguments: [pSearch - IN]: pointer to search object
// [bAttrOnly - IN]: display attributes names only
// Returns HRESULT S_OK if Successful
// E_INVALIDARG
// Anything else is a failure code from an ADSI
// call
//
//
// History: 05-OCT-2000 hiteshr Created
//
//---------------------------------------------------------------------------
HRESULT OutputAllAttr(IN CDSSearch *pSearch, BOOL bAttrOnly)
{
ENTER_FUNCTION_HR(FULL_LOGGING, OutputAllAttr, hr);
if(!pSearch)
{
ASSERT(FALSE);
hr = E_INVALIDARG;
return hr;
}
WCHAR pBuffer[MAXSTR];
LONG cRow = 0;
while(TRUE)
{
hr = pSearch->GetNextRow();
//We are done
if(hr == S_ADS_NOMORE_ROWS || FAILED(hr))
break;
//
//Check if we reached querylimit
//
if(IsQueryLimitReached(cRow))
break;
LPWSTR pszColumnName;
BOOL bColumnNameDisplayed = FALSE;
//
//Get the name of next column which has value
//
while(pSearch->GetNextColumnName(&pszColumnName) != S_ADS_NOMORE_COLUMNS)
{
if(bAttrOnly)
{
wsprintf(pBuffer, L"%ws ", pszColumnName);
DisplayOutputNoNewline(pBuffer);
bColumnNameDisplayed = TRUE;
}
else
{
ADS_SEARCH_COLUMN ColumnData;
hr = pSearch->GetColumn(pszColumnName, &ColumnData);
if(SUCCEEDED(hr))
{
ADSVALUE *pValues = ColumnData.pADsValues;
for( DWORD j = 0; j < ColumnData.dwNumValues; ++j )
{
hr = GetStringFromADs(pValues,
ColumnData.dwADsType,
pBuffer,
MAXSTR,
pszColumnName);
if(SUCCEEDED(hr))
DisplayList(pszColumnName, pBuffer);
++pValues;
}
pSearch->FreeColumn(&ColumnData);
}
else if(hr == E_ADS_COLUMN_NOT_SET)
DisplayList(pszColumnName, L"");
}
pSearch->FreeColumnName(pszColumnName);
}
if(bAttrOnly)
{
if(bColumnNameDisplayed)
{
DisplayOutputNoNewline(L"\r\n");
cRow++;
}
}
else
cRow++;
}//End of while loop
if(hr == S_ADS_NOMORE_ROWS)
hr = S_OK;
return hr;
}
//+--------------------------------------------------------------------------
//
// Function: GetStringFromADs
//
// Synopsis: Converts Value into string depending upon type
// Arguments: [pValues - IN]: Value to be converted to string
// [dwADsType-IN]: ADSTYPE of pValue
// [pBuffer - OUT]:Output buffer which gets the string
// [dwBufferLen-IN]:Size of output buffer
// Returns HRESULT S_OK if Successful
// E_INVALIDARG
// Anything else is a failure code from an ADSI
// call
//
//
// History: 05-OCT-2000 hiteshr Created
//
//---------------------------------------------------------------------------
HRESULT GetStringFromADs(IN const ADSVALUE *pValues,
IN ADSTYPE dwADsType,
OUT LPWSTR pBuffer,
IN DWORD dwBufferLen,
IN LPCWSTR pszAttrName)
{
ENTER_FUNCTION_HR(FULL_LOGGING, GetStringFromADs, hr);
if(!pValues || !pBuffer || !dwBufferLen)
{
ASSERT(FALSE);
hr = E_INVALIDARG;
return hr;
}
pBuffer[0] = 0;
if( dwADsType == ADSTYPE_INVALID )
{
hr = E_INVALIDARG;
return hr;
}
switch( dwADsType )
{
case ADSTYPE_DN_STRING :
{
CComBSTR sbstrOutputDN;
HRESULT hr = GetOutputDN( &sbstrOutputDN, pValues->DNString );
if (FAILED(hr))
return hr;
wcsncpy(pBuffer, (BSTR)sbstrOutputDN, dwBufferLen-1);
}
break;
case ADSTYPE_CASE_EXACT_STRING :
wcsncpy(pBuffer ,pValues->CaseExactString, dwBufferLen-1);
break;
case ADSTYPE_CASE_IGNORE_STRING:
wcsncpy(pBuffer ,pValues->CaseIgnoreString, dwBufferLen-1);
break;
case ADSTYPE_PRINTABLE_STRING :
wcsncpy(pBuffer ,pValues->PrintableString, dwBufferLen-1);
break;
case ADSTYPE_NUMERIC_STRING :
wcsncpy(pBuffer ,pValues->NumericString, dwBufferLen-1);
break;
case ADSTYPE_OBJECT_CLASS :
wcsncpy(pBuffer ,pValues->ClassName, dwBufferLen-1);
break;
case ADSTYPE_BOOLEAN :
wsprintf(pBuffer ,L"%s", ((DWORD)pValues->Boolean) ? L"TRUE" : L"FALSE");
break;
case ADSTYPE_INTEGER :
wsprintf(pBuffer ,L"%d", (DWORD) pValues->Integer);
break;
case ADSTYPE_OCTET_STRING :
{
BYTE b;
WCHAR sOctet[128];
DWORD dwLen = 0;
//
//Special case objectguid and objectsid attribute
//
if(pszAttrName && !_wcsicmp(pszAttrName, L"objectguid"))
{
GUID *pguid = (GUID*)pValues->OctetString.lpValue;
StringFromGUID2(*pguid,(LPOLESTR)pBuffer,dwBufferLen);
break;
}
if(pszAttrName && !_wcsicmp(pszAttrName, L"objectsid"))
{
LPWSTR pszSid = NULL;
PSID pSid = (PSID)pValues->OctetString.lpValue;
if(ConvertSidToStringSid(pSid, &pszSid))
{
wcscpy(pBuffer,pszSid);
LocalFree(pszSid);
break;
}
}
for ( DWORD idx=0; idx<pValues->OctetString.dwLength; idx++)
{
b = ((BYTE *)pValues->OctetString.lpValue)[idx];
wsprintf(sOctet,L"0x%02x ", b);
dwLen += static_cast<DWORD>(wcslen(sOctet));
if(dwLen > (dwBufferLen - 1) )
break;
else
wcscat(pBuffer,sOctet);
}
}
break;
case ADSTYPE_LARGE_INTEGER :
{
CComBSTR strLarge;
LARGE_INTEGER li = pValues->LargeInteger;
litow(li, strLarge);
wcsncpy(pBuffer,strLarge,dwBufferLen-1);
}
break;
case ADSTYPE_UTC_TIME :
wsprintf(pBuffer,
L"%02d/%02d/%04d %02d:%02d:%02d", pValues->UTCTime.wMonth, pValues->UTCTime.wDay, pValues->UTCTime.wYear,
pValues->UTCTime.wHour, pValues->UTCTime.wMinute, pValues->UTCTime.wSecond
);
break;
case ADSTYPE_NT_SECURITY_DESCRIPTOR: // I use the ACLEditor instead
{
//ISSUE:2000/01/05-hiteshr
//I am not sure what to do with the NT_SECURITY_DESCRIPTOR and also
//with someother datatypes not coverd by dsquery.
}
break;
default :
break;
}
DEBUG_OUTPUT(FULL_LOGGING, L"string = %w", pBuffer);
return hr;
}
Reference in a new issue Copy permalink