1570 lines
49 KiB
C++
1570 lines
49 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// 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;
|
|
}
|
|
|