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.
605 lines
14 KiB
605 lines
14 KiB
//***************************************************************************
|
|
|
|
//
|
|
|
|
// NAMEPATH.CPP
|
|
|
|
//
|
|
|
|
// Module: OLE MS Provider Framework
|
|
|
|
//
|
|
|
|
// Copyright (c) 1996-2001 Microsoft Corporation, All Rights Reserved
|
|
//
|
|
//***************************************************************************
|
|
|
|
#include "precomp.h"
|
|
#include <provtempl.h>
|
|
#include <provmt.h>
|
|
#include <instpath.h>
|
|
#include <strsafe.h>
|
|
|
|
static wchar_t *UnicodeStringAppend ( const wchar_t *prefix , const wchar_t *suffix )
|
|
{
|
|
int prefixTextLength = 0 ;
|
|
if ( prefix )
|
|
{
|
|
prefixTextLength = wcslen ( prefix ) ;
|
|
}
|
|
|
|
int suffixTextLength = 0 ;
|
|
if ( suffix )
|
|
{
|
|
suffixTextLength = wcslen ( suffix ) ;
|
|
}
|
|
|
|
if ( prefix || suffix )
|
|
{
|
|
int textLength = prefixTextLength + suffixTextLength ;
|
|
wchar_t *textBuffer = new wchar_t [ textLength + 1 ] ;
|
|
|
|
if ( prefix )
|
|
{
|
|
StringCchCopyW ( textBuffer , textLength + 1 , prefix ) ;
|
|
}
|
|
|
|
if ( suffix )
|
|
{
|
|
StringCchCopyW ( & textBuffer [ prefixTextLength ] , suffixTextLength + 1 , suffix ) ;
|
|
}
|
|
|
|
return textBuffer ;
|
|
}
|
|
else
|
|
return NULL ;
|
|
}
|
|
|
|
static wchar_t *UnicodeStringDuplicate ( const wchar_t *string )
|
|
{
|
|
if ( string )
|
|
{
|
|
int textLength = wcslen ( string ) ;
|
|
|
|
wchar_t *textBuffer = new wchar_t [ textLength + 1 ] ;
|
|
StringCchCopyW ( textBuffer , textLength + 1 , string ) ;
|
|
|
|
return textBuffer ;
|
|
}
|
|
else
|
|
{
|
|
return NULL ;
|
|
}
|
|
}
|
|
|
|
WbemNamespacePath :: WbemNamespacePath () : status ( FALSE ) ,
|
|
pushedBack ( FALSE ) ,
|
|
pushBack ( NULL ) ,
|
|
server ( NULL ) ,
|
|
relative ( FALSE ) ,
|
|
nameSpaceListPosition ( NULL )
|
|
{
|
|
nameSpaceList = new CList <wchar_t * , wchar_t * > ;
|
|
}
|
|
|
|
void WbemNamespacePath :: SetUp ()
|
|
{
|
|
status = FALSE ;
|
|
pushedBack = FALSE ;
|
|
pushBack = NULL ;
|
|
server = NULL ;
|
|
relative = FALSE ;
|
|
nameSpaceListPosition = NULL ;
|
|
nameSpaceList = new CList <wchar_t * , wchar_t * > ;
|
|
}
|
|
|
|
WbemNamespacePath :: WbemNamespacePath (
|
|
|
|
const WbemNamespacePath &nameSpacePathArg
|
|
|
|
) : status ( FALSE ) ,
|
|
pushedBack ( FALSE ) ,
|
|
pushBack ( NULL ) ,
|
|
server ( NULL ) ,
|
|
relative ( FALSE ) ,
|
|
nameSpaceListPosition ( NULL )
|
|
{
|
|
nameSpaceList = new CList <wchar_t * , wchar_t * > ;
|
|
CList <wchar_t * , wchar_t *> *nameList = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
CList <wchar_t * , wchar_t *> *copyNameList = ( CList <wchar_t * , wchar_t *> * ) nameSpacePathArg.nameSpaceList ;
|
|
|
|
POSITION position = copyNameList->GetHeadPosition () ;
|
|
while ( position )
|
|
{
|
|
wchar_t *name = copyNameList->GetNext ( position ) ;
|
|
nameList->AddTail ( UnicodeStringDuplicate ( name ) ) ;
|
|
}
|
|
|
|
server = UnicodeStringDuplicate ( nameSpacePathArg.server ) ;
|
|
}
|
|
|
|
WbemNamespacePath :: ~WbemNamespacePath ()
|
|
{
|
|
CleanUp () ;
|
|
}
|
|
|
|
void WbemNamespacePath :: CleanUp ()
|
|
{
|
|
if ( nameSpaceList )
|
|
{
|
|
CList <wchar_t * , wchar_t *> *nameList = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
POSITION position = nameList->GetHeadPosition () ;
|
|
while ( position )
|
|
{
|
|
wchar_t *value = nameList->GetNext ( position ) ;
|
|
delete [] value ;
|
|
}
|
|
|
|
nameList->RemoveAll () ;
|
|
|
|
delete ( CList <wchar_t * , wchar_t * > * ) nameSpaceList ;
|
|
nameSpaceList = NULL ;
|
|
}
|
|
|
|
if ( pushBack )
|
|
{
|
|
delete pushBack ;
|
|
pushBack = NULL ;
|
|
}
|
|
|
|
if ( server )
|
|
{
|
|
delete [] server ;
|
|
server = NULL ;
|
|
}
|
|
|
|
relative = FALSE ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: IsEmpty () const
|
|
{
|
|
CList <wchar_t * , wchar_t *> *list = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
return list->IsEmpty () ;
|
|
}
|
|
|
|
ULONG WbemNamespacePath :: GetCount () const
|
|
{
|
|
CList <wchar_t * , wchar_t *> *list = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
return list->GetCount () ;
|
|
}
|
|
|
|
void WbemNamespacePath :: Reset ()
|
|
{
|
|
CList <wchar_t * , wchar_t *> *list = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
nameSpaceListPosition = list->GetHeadPosition () ;
|
|
}
|
|
|
|
wchar_t *WbemNamespacePath :: Next ()
|
|
{
|
|
wchar_t *value = NULL ;
|
|
POSITION position = ( POSITION ) nameSpaceListPosition ;
|
|
if ( position )
|
|
{
|
|
CList <wchar_t * , wchar_t *> *list = ( CList <wchar_t * , wchar_t *> * ) nameSpaceList ;
|
|
value = list->GetNext ( position ) ;
|
|
nameSpaceListPosition = position ;
|
|
}
|
|
return value ;
|
|
}
|
|
|
|
void WbemNamespacePath :: SetServer ( wchar_t *serverArg )
|
|
{
|
|
delete [] server ;
|
|
DWORD t_TextLength = wcslen ( serverArg) + 1 ;
|
|
server = new wchar_t [ t_TextLength ] ;
|
|
StringCchCopyW ( server , t_TextLength , serverArg ) ;
|
|
}
|
|
|
|
void WbemNamespacePath :: Add ( wchar_t *nameSpace )
|
|
{
|
|
CList <wchar_t * , wchar_t * > *list = ( CList <wchar_t * , wchar_t * > * ) nameSpaceList ;
|
|
list->AddTail ( nameSpace ) ;
|
|
}
|
|
|
|
WbemNamespacePath :: operator void *()
|
|
{
|
|
return status ? this : NULL ;
|
|
}
|
|
|
|
wchar_t *WbemNamespacePath :: GetNamespacePath ()
|
|
{
|
|
if ( status )
|
|
{
|
|
wchar_t *path = NULL ;
|
|
|
|
if ( GetServer () )
|
|
{
|
|
path = UnicodeStringDuplicate ( L"\\\\" ) ;
|
|
wchar_t *concatPath = UnicodeStringAppend ( path , GetServer () ) ;
|
|
delete [] path ;
|
|
path = concatPath ;
|
|
}
|
|
|
|
if ( ! Relative () )
|
|
{
|
|
wchar_t *concatPath = UnicodeStringAppend ( path , L"\\" ) ;
|
|
delete [] path ;
|
|
path = concatPath ;
|
|
}
|
|
|
|
wchar_t *pathComponent ;
|
|
|
|
ULONG t_ComponentCount = 0 ;
|
|
Reset () ;
|
|
while ( pathComponent = Next () )
|
|
{
|
|
wchar_t *concatPath = NULL ;
|
|
|
|
t_ComponentCount ++ ;
|
|
if ( t_ComponentCount != GetCount () )
|
|
{
|
|
|
|
wchar_t *t_Temp = UnicodeStringAppend ( path , pathComponent ) ;
|
|
concatPath = UnicodeStringAppend ( t_Temp , L"\\" ) ;
|
|
delete [] t_Temp ;
|
|
}
|
|
else
|
|
{
|
|
concatPath = UnicodeStringAppend ( path , pathComponent ) ;
|
|
}
|
|
|
|
delete [] path ;
|
|
path = concatPath ;
|
|
}
|
|
|
|
return path ;
|
|
}
|
|
else
|
|
return NULL ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: ConcatenatePath ( WbemNamespacePath &relative )
|
|
{
|
|
BOOL status = FALSE ;
|
|
|
|
if ( relative.Relative () )
|
|
{
|
|
status = TRUE ;
|
|
|
|
relative.Reset () ;
|
|
wchar_t *namespaceComponent ;
|
|
while ( namespaceComponent = Next () )
|
|
{
|
|
Add ( UnicodeStringDuplicate ( namespaceComponent ) ) ;
|
|
}
|
|
}
|
|
|
|
return status ;
|
|
}
|
|
|
|
void WbemNamespacePath :: PushBack ()
|
|
{
|
|
pushedBack = TRUE ;
|
|
}
|
|
|
|
WbemLexicon *WbemNamespacePath :: Get ()
|
|
{
|
|
if ( pushedBack )
|
|
{
|
|
pushedBack = FALSE ;
|
|
}
|
|
else
|
|
{
|
|
delete pushBack ;
|
|
pushBack = analyser.Get () ;
|
|
}
|
|
|
|
return pushBack ;
|
|
}
|
|
|
|
WbemLexicon *WbemNamespacePath :: Match ( WbemLexicon :: LexiconToken tokenType )
|
|
{
|
|
WbemLexicon *lexicon = Get () ;
|
|
status = ( lexicon->GetToken () == tokenType ) ;
|
|
return status ? lexicon : NULL ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: SetNamespacePath ( wchar_t *tokenStream )
|
|
{
|
|
CleanUp () ;
|
|
SetUp () ;
|
|
|
|
analyser.Set ( tokenStream ) ;
|
|
|
|
status = TRUE ;
|
|
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: DOT_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceRel () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: TOKEN_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceRel () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
BackSlashFactoredServerNamespace () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
break ;
|
|
}
|
|
|
|
Match ( WbemLexicon :: EOF_ID ) ;
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: BackSlashFactoredServerNamespace ()
|
|
{
|
|
if ( Match ( WbemLexicon :: BACKSLASH_ID ) )
|
|
{
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
BackSlashFactoredServerSpec () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: DOT_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceRel () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: TOKEN_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceRel () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
}
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: BackSlashFactoredServerSpec ()
|
|
{
|
|
if ( Match ( WbemLexicon :: BACKSLASH_ID ) )
|
|
{
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: DOT_ID:
|
|
{
|
|
PushBack () ;
|
|
WbemLexicon *token ;
|
|
if ( token = Match ( WbemLexicon :: DOT_ID ) )
|
|
{
|
|
SetServer ( L"." ) ;
|
|
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceAbs () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: EOF_ID:
|
|
{
|
|
PushBack () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: TOKEN_ID:
|
|
{
|
|
PushBack () ;
|
|
WbemLexicon *token ;
|
|
if ( token = Match ( WbemLexicon :: TOKEN_ID ) )
|
|
{
|
|
SetServer ( token->GetValue ()->token ) ;
|
|
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
NameSpaceAbs () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: EOF_ID:
|
|
{
|
|
PushBack () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: NameSpaceName ()
|
|
{
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: TOKEN_ID:
|
|
{
|
|
PushBack () ;
|
|
WbemLexicon *token ;
|
|
if ( token = Match ( WbemLexicon :: TOKEN_ID ) )
|
|
{
|
|
wchar_t *namespaceValue = token->GetValue ()->token ;
|
|
|
|
if ( namespaceValue )
|
|
{
|
|
DWORD t_TextLength = wcslen ( namespaceValue ) + 1 ;
|
|
wchar_t *copy = new wchar_t [ t_TextLength ] ;
|
|
StringCchCopyW ( copy , t_TextLength , namespaceValue ) ;
|
|
|
|
Add ( copy ) ;
|
|
}
|
|
else
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: DOT_ID:
|
|
{
|
|
PushBack () ;
|
|
WbemLexicon *token ;
|
|
if ( token = Match ( WbemLexicon :: DOT_ID ) )
|
|
{
|
|
DWORD t_TextLength = wcslen ( L"." ) + 1 ;
|
|
wchar_t *copy = new wchar_t [ t_TextLength ] ;
|
|
StringCchCopyW ( copy , t_TextLength , L"." ) ;
|
|
|
|
Add ( copy ) ;
|
|
}
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
break ;
|
|
}
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: NameSpaceRel ()
|
|
{
|
|
relative = TRUE ;
|
|
|
|
NameSpaceName () &&
|
|
RecursiveNameSpaceRel () ;
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: RecursiveNameSpaceRel ()
|
|
{
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
Match ( WbemLexicon :: BACKSLASH_ID ) &&
|
|
NameSpaceRel () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: EOF_ID:
|
|
{
|
|
PushBack () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
|
|
return status ;
|
|
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: NameSpaceAbs ()
|
|
{
|
|
Match ( WbemLexicon :: BACKSLASH_ID ) &&
|
|
NameSpaceName () &&
|
|
RecursiveNameSpaceAbs () ;
|
|
|
|
return status ;
|
|
}
|
|
|
|
BOOL WbemNamespacePath :: RecursiveNameSpaceAbs ()
|
|
{
|
|
WbemLexicon *lookAhead = Get () ;
|
|
switch ( lookAhead->GetToken () )
|
|
{
|
|
case WbemLexicon :: BACKSLASH_ID:
|
|
{
|
|
PushBack () ;
|
|
|
|
Match ( WbemLexicon :: BACKSLASH_ID ) &&
|
|
NameSpaceName () &&
|
|
RecursiveNameSpaceAbs () ;
|
|
}
|
|
break ;
|
|
|
|
case WbemLexicon :: EOF_ID:
|
|
{
|
|
PushBack () ;
|
|
}
|
|
break ;
|
|
|
|
default:
|
|
{
|
|
status = FALSE ;
|
|
}
|
|
}
|
|
|
|
return status ;
|
|
}
|
|
|