Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

512 lines
15 KiB

//----------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 2000.
//
// File: umi.cxx
//
// Contents: Contains miscellaneous UMI routines.
//
// History: 02-28-00 SivaramR Created.
//
//----------------------------------------------------------------------------
#include "winnt.hxx"
//----------------------------------------------------------------------------
// Function: IsPreDefinedErrorCode
//
// Synopsis: Returns TRUE if the error code passed in is a valid UMI error
// code i.e one that can be returned by a UMI method. Returns
// FALSE otherwise.
//
// Arguments: Self explanatory
//
// Returns: TRUE/FALSE as mentioned above
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
BOOL IsPreDefinedErrorCode(HRESULT hr)
{
switch(hr) {
case E_UNEXPECTED:
case E_NOTIMPL:
case E_OUTOFMEMORY:
case E_INVALIDARG:
case E_NOINTERFACE:
case E_POINTER:
case E_HANDLE:
case E_ABORT:
case E_FAIL:
case E_ACCESSDENIED:
case E_PENDING:
case UMI_E_TYPE_MISMATCH:
case UMI_E_NOT_FOUND:
case UMI_E_INVALID_FLAGS:
case UMI_E_UNSUPPORTED_OPERATION:
case UMI_E_UNSUPPORTED_FLAGS:
case UMI_E_SYNCHRONIZATION_REQUIRED:
case UMI_E_UNBOUND_OBJECT:
RRETURN(TRUE);
default:
RRETURN(FALSE);
}
}
//----------------------------------------------------------------------------
// Function: MapHrToUmiError
//
// Synopsis: This function returns the UMI error corresponding to a HRESULT
// returned by the WinNT provider. The HRESULT can be retrieved
// using GetLastStatus(), if required.
//
// Arguments: Self explanatory
//
// Returns: UMI error corresponding to the HRESULT
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
HRESULT MapHrToUmiError(HRESULT hr)
{
if(SUCCEEDED(hr)) {
if(S_FALSE == hr) // may be returned by end of cursor enumeration
RRETURN(UMI_S_FALSE);
else
RRETURN(UMI_S_NO_ERROR);
}
// we had a failure
if(TRUE == IsPreDefinedErrorCode(hr))
RRETURN(hr); // OK to return this as a UMI error
// Try to map ADSI errors to appropriate UMI errors. Default is to
// map to E_FAIL.
switch(hr) {
case E_ADS_INVALID_DOMAIN_OBJECT:
case E_ADS_INVALID_USER_OBJECT:
case E_ADS_INVALID_COMPUTER_OBJECT:
case E_ADS_UNKNOWN_OBJECT:
RRETURN(UMI_E_OBJECT_NOT_FOUND);
case E_ADS_PROPERTY_NOT_FOUND:
RRETURN(UMI_E_PROPERTY_NOT_FOUND);
case E_ADS_BAD_PARAMETER:
RRETURN(UMI_E_INVALIDARG);
case E_ADS_CANT_CONVERT_DATATYPE:
RRETURN(UMI_E_TYPE_MISMATCH);
case E_ADS_BAD_PATHNAME:
RRETURN(UMI_E_INVALIDARG);
case E_ADS_OBJECT_UNBOUND:
RRETURN(UMI_E_UNBOUND_OBJECT);
case HRESULT_FROM_WIN32(NERR_UserNotFound):
case HRESULT_FROM_WIN32(NERR_GroupNotFound):
case HRESULT_FROM_WIN32(ERROR_NO_SUCH_DOMAIN):
case HRESULT_FROM_WIN32(ERROR_BAD_NETPATH):
RRETURN(UMI_E_OBJECT_NOT_FOUND);
default:
RRETURN(UMI_E_FAIL);
}
}
//----------------------------------------------------------------------------
// Function: ValidateUrl
//
// Synopsis: This function checks to see if a UMI path has the correct
// namespace and server.
//
// Arguments:
//
// pURL Pointer to URL interface containing the UMI path
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
static HRESULT ValidateUrl(
IUmiURL *pURL
)
{
HRESULT hr = S_OK;
WCHAR pszTmpArray[MAX_URL+1];
ULONG ulTmpArraySize = 0;
ULONGLONG PathType = 0;
hr = pURL->GetPathInfo(0, &PathType);
BAIL_ON_FAILURE(hr);
if(PathType & UMIPATH_INFO_RELATIVE_PATH)
// relative paths cannot be converted to a WinNT path
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
// Make sure server name is empty. WinNT does not support servername
// in UMI path.
ulTmpArraySize = MAX_URL;
hr = pURL->GetLocator(
&ulTmpArraySize,
pszTmpArray
);
if(WBEM_E_BUFFER_TOO_SMALL == hr)
// Locator is not an empty string
hr = UMI_E_INVALID_PATH;
BAIL_ON_FAILURE(hr);
if(wcscmp(pszTmpArray, L""))
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
// Make sure namespace is WinNT
ulTmpArraySize = MAX_URL;
hr = pURL->GetRootNamespace(
&ulTmpArraySize,
pszTmpArray
);
if(WBEM_E_BUFFER_TOO_SMALL == hr)
// Namespace is not WinNT
hr = UMI_E_INVALID_PATH;
BAIL_ON_FAILURE(hr);
if(_wcsicmp(pszTmpArray, L"WinNT"))
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
error:
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: UmiToWinNTPath
//
// Synopsis: This function converts a UMI path into a native path.
//
// Arguments:
//
// pURL Pointer to URL interface containing the UMI path
// ppszWinNTPath Returns the WinNT path
// pdwNumComps Returns the number of components in the UMI path
// pppszClasses Returns the class of each component in the UMI path
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: *ppszWinNTPath to return the WinNT path
// *pdwNumComps to return the number of components
// *pppszClasses to return the class of each component
//
//----------------------------------------------------------------------------
HRESULT UmiToWinNTPath(
IUmiURL *pURL,
WCHAR **ppszWinNTPath,
DWORD *pdwNumComps,
LPWSTR **pppszClasses
)
{
HRESULT hr = S_OK;
WCHAR *pszWinNTPath = NULL;
WCHAR pszTmpArray[MAX_URL+1], pszValueArray[MAX_URL+1];
WCHAR *pszValuePtr = NULL, pszClassArray[MAX_URL+1];
ULONG ulTmpArraySize = 0, ulNumComponents = 0, ulIndex = 0;
ULONG ulKeyCount = 0, ulValueArraySize = 0, ulClassArraySize = 0;
IUmiURLKeyList *pKeyList = NULL;
LPWSTR *ppszClasses = NULL;
ADsAssert( (pURL != NULL) && (ppszWinNTPath != NULL) &&
(pdwNumComps != NULL) && (pppszClasses != NULL) );
*ppszWinNTPath = NULL;
*pdwNumComps = 0;
*pppszClasses = NULL;
hr = ValidateUrl(pURL);
BAIL_ON_FAILURE(hr);
// Get the total length needed for the WinNT path
ulTmpArraySize = MAX_URL;
hr = pURL->Get(0, &ulTmpArraySize, pszTmpArray);
if(hr != WBEM_E_BUFFER_TOO_SMALL)
BAIL_ON_FAILURE(hr);
pszWinNTPath = (WCHAR *) AllocADsMem(ulTmpArraySize * sizeof(WCHAR));
if(NULL == pszWinNTPath)
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
wsprintf(pszWinNTPath, L"%s", L"WinNT:");
hr = pURL->GetComponentCount(&ulNumComponents);
BAIL_ON_FAILURE(hr);
if(0 == ulNumComponents) {
// umi:///winnt translates to WinNT: . Nothing more to do
*ppszWinNTPath = pszWinNTPath;
RRETURN(S_OK);
}
ppszClasses = (LPWSTR *) AllocADsMem(ulNumComponents * sizeof(LPWSTR *));
if(NULL == ppszClasses) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
memset(ppszClasses, 0, ulNumComponents * sizeof(LPWSTR *));
// we have at least one component in the path
wcscat(pszWinNTPath, L"/");
for(ulIndex = 0; ulIndex < ulNumComponents; ulIndex++) {
ulClassArraySize = MAX_URL;
pKeyList = NULL;
hr = pURL->GetComponent(
ulIndex,
&ulClassArraySize,
pszClassArray,
&pKeyList
);
if(WBEM_E_BUFFER_TOO_SMALL == hr)
// none of the WinNT classes is so long, so this has to be a bad path.
hr = UMI_E_INVALID_PATH;
BAIL_ON_FAILURE(hr);
// WinNT does not supports components with an empty class name
if(!wcscmp(pszClassArray, L""))
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
ppszClasses[ulIndex] = AllocADsStr(pszClassArray);
if(NULL == ppszClasses[ulIndex]) {
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
}
ADsAssert(pKeyList != NULL);
// make sure there is only one key
hr = pKeyList->GetCount(&ulKeyCount);
BAIL_ON_FAILURE(hr);
if(ulKeyCount != 1)
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
ulValueArraySize = MAX_URL;
ulTmpArraySize = MAX_URL;
pszValuePtr = pszValueArray;
hr = pKeyList->GetKey(
0,
0,
&ulTmpArraySize,
pszTmpArray,
&ulValueArraySize,
pszValueArray
);
if( (WBEM_E_BUFFER_TOO_SMALL == hr) && (ulValueArraySize > MAX_URL) ) {
pszValuePtr = (WCHAR *) AllocADsMem(ulValueArraySize);
if(NULL == pszValuePtr)
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
hr = pKeyList->GetKey(
0,
0,
&ulTmpArraySize,
pszTmpArray,
&ulValueArraySize,
pszValuePtr
);
}
if(WBEM_E_BUFFER_TOO_SMALL == hr)
// Key is always "Name" in WinNT. So, if the size required if so
// high, it indicates a bad path
hr = UMI_E_INVALID_PATH;
BAIL_ON_FAILURE(hr);
// Key has to be "Name" or empty in WinNT
if( _wcsicmp(pszTmpArray, WINNT_KEY_NAME) && wcscmp(pszTmpArray, L"") )
BAIL_ON_FAILURE(hr = UMI_E_INVALID_PATH);
// append the value to the WinNT path
wcscat(pszWinNTPath, L"/");
wcscat(pszWinNTPath, pszValuePtr);
if(pszValuePtr != pszValueArray)
FreeADsMem(pszValuePtr);
pKeyList->Release();
} // for
// append the class to the WInNT path
wcscat(pszWinNTPath, L",");
wcscat(pszWinNTPath, pszClassArray);
*ppszWinNTPath = pszWinNTPath;
*pdwNumComps = ulNumComponents;
*pppszClasses = ppszClasses;
RRETURN(S_OK);
error:
if(pszWinNTPath != NULL)
FreeADsMem(pszWinNTPath);
if( (pszValuePtr != NULL) && (pszValuePtr != pszValueArray) )
FreeADsMem(pszValuePtr);
if(ppszClasses != NULL) {
for(ulIndex = 0; ulIndex < ulNumComponents; ulIndex++) {
if(ppszClasses[ulIndex] != NULL)
FreeADsStr(ppszClasses[ulIndex]);
}
FreeADsMem(ppszClasses);
}
if(pKeyList != NULL)
pKeyList->Release();
RRETURN(hr);
}
//----------------------------------------------------------------------------
// Function: ADsToUmiPath
//
// Synopsis: This function converts an ADsPath to a UMI path (full, short or
// relative depending on a flag).
//
// Arguments:
//
// bstrADsPath ADsPath to be converted
// pObjectInfo Contains the values of each component in the ADsPath
// CompClasses Array containing the classes of each component of the ADsPath
// dwNumComponents Number of classes(components) in the ADsPath
// dwUmiPathType Specifies the format of the UMI path to be returned
// ppszUmiPath Returns UMI path in the requested format
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: *ppszUmiPath to return the UMI path
//
//----------------------------------------------------------------------------
HRESULT ADsToUmiPath(
BSTR bstrADsPath,
OBJECTINFO *pObjectInfo,
LPWSTR CompClasses[],
DWORD dwNumComponents,
DWORD dwUmiPathType,
LPWSTR *ppszUmiPath
)
{
HRESULT hr = S_OK;
DWORD dwBufferLen = 0, dwIndex = 0;
LPWSTR pszUmiPath = NULL, *pszComponents = NULL;
ADsAssert( (bstrADsPath != NULL) && (CompClasses != NULL) &&
(pObjectInfo != NULL) && (ppszUmiPath != NULL) );
*ppszUmiPath = NULL;
// calculate approximate length of buffer required to return the UMI path
// Each component is of the form "class.name=value". "value" is already
// part of the ADSI path. Include the size of each class and add 6 to
// account for "Name" and '.' and '='.
dwBufferLen = wcslen(L"umi:///winnt/") + wcslen(bstrADsPath) +
dwNumComponents * (MAX_CLASS + 6) + 1;
pszUmiPath = (LPWSTR) AllocADsMem(dwBufferLen * sizeof(WCHAR));
if(NULL == pszUmiPath)
BAIL_ON_FAILURE(hr = UMI_E_OUT_OF_MEMORY);
// if ADsPath is empty and it is not a namespace object, then this must be
// a session, resource or printjob object. Return an empty path for these.
// Namespace objects have no components in the ADsPath, but they have a
// non-empty ADsPath ("WinNT:")
if( (0 == dwNumComponents) && _wcsicmp(CompClasses[0], L"Namespace") ) {
wcscpy(pszUmiPath, L"");
*ppszUmiPath = pszUmiPath;
RRETURN(S_OK);
}
if( (RELATIVE_UMI_PATH == dwUmiPathType) ||
(FULL_RELATIVE_UMI_PATH == dwUmiPathType) ) {
// return the last component, if any
if(0 == dwNumComponents) {
*pszUmiPath = '\0';
}
else {
wcscpy(pszUmiPath,
CompClasses[dwNumComponents - 1]
);
if(FULL_RELATIVE_UMI_PATH == dwUmiPathType)
wcscat(pszUmiPath, L".Name=");
else
wcscat(pszUmiPath, L"=");
pszComponents = pObjectInfo->DisplayComponentArray;
wcscat(pszUmiPath, pszComponents[dwNumComponents - 1]);
}
*ppszUmiPath = pszUmiPath;
RRETURN(S_OK);
}
wcscpy(pszUmiPath, L"umi:///winnt");
// for namespace objects, there are no components and hence the umi path
// is completely constructed at this point.
if(0 == dwNumComponents) {
*ppszUmiPath = pszUmiPath;
RRETURN(S_OK);
}
wcscat(pszUmiPath, L"/");
pszComponents = pObjectInfo->DisplayComponentArray;
for(dwIndex = 0; dwIndex < dwNumComponents; dwIndex++) {
wcscat(pszUmiPath, CompClasses[dwIndex]);
if(FULL_UMI_PATH == dwUmiPathType)
wcscat(pszUmiPath, L".Name=");
else if(SHORT_UMI_PATH == dwUmiPathType)
wcscat(pszUmiPath, L"=");
wcscat(pszUmiPath, pszComponents[dwIndex]);
if(dwIndex != (dwNumComponents - 1))
wcscat(pszUmiPath, L"/");
}
*ppszUmiPath = pszUmiPath;
RRETURN(S_OK);
error:
if(pszUmiPath != NULL)
FreeADsMem(pszUmiPath);
RRETURN(hr);
}