/**********************************************************************
prototype:
BOOL
DslhVarroIsValidMacAddList
(
PCHAR pAddList
);
description:
This function is called check if it's a valid MacAddress List;
argument: PCHAR pAddList
The MacAddress List string seperated by ',';
return: TRUE or FALSE
**********************************************************************/
BOOL
DslhVarroIsValidMacAddList
(
PCHAR pAddList
)
{
PANSC_TOKEN_CHAIN pAddrListTokenChain = (PANSC_TOKEN_CHAIN )NULL;
PANSC_STRING_TOKEN pAddrStringToken = (PANSC_STRING_TOKEN )NULL;
BOOL bIsValid = TRUE;
ULONG i = 0;
if( !pAddList || AnscSizeOfString(pAddList) == 0)
{
return bIsValid;
}
if ( DslhVarroDelSpaceInCommaSeparator((PCHAR)pAddList) )
{
if ( pAddrListTokenChain = AnscTcAllocate( pAddList, "," ) )
{
while ( pAddrStringToken = AnscTcUnlinkToken(pAddrListTokenChain) )
{
if( ! DslhVarroIsValidMacAddress((PCHAR)pAddrStringToken->Name))
{
bIsValid = FALSE;
AnscFreeMemory(pAddrStringToken);
goto EXIT;
}
AnscFreeMemory(pAddrStringToken);
}
}
else
{
return bIsValid = FALSE;
}
}
else
{
return bIsValid = FALSE;
}
EXIT:
if ( pAddrListTokenChain )
{
AnscTcFree((ANSC_HANDLE)pAddrListTokenChain);
}
return bIsValid;
}
BOOL
DslhVarroIsValidMaskString
(
PCHAR pStringValue
)
{
PANSC_TOKEN_CHAIN pAddrListTokenChain = (PANSC_TOKEN_CHAIN )NULL;
PANSC_STRING_TOKEN pAddrStringToken = (PANSC_STRING_TOKEN )NULL;
ULONG ulMaskValue = 0;
ULONG i = 0;
BOOL bIsValid = FALSE;
if ( !pStringValue || (AnscSizeOfString(pStringValue) == 0) )
{
return TRUE;
}
if ( pAddrListTokenChain = AnscTcAllocate(pStringValue, ".") )
{
if (pAddrListTokenChain->TokensQueue.Depth != 0x4)
{
goto EXIT;
}
while ( pAddrStringToken = AnscTcUnlinkToken(pAddrListTokenChain) )
{
ulMaskValue = (ulMaskValue<<0x8) + AnscGetStringUlong(pAddrStringToken->Name);
AnscFreeMemory(pAddrStringToken);
}
if ( ! ulMaskValue )
{
bIsValid = TRUE;
goto EXIT;
}
for ( i = 0; !(ulMaskValue & 0x1); i++)
{
ulMaskValue >>= 0x1;
}
/* Subnet mask shorter than 8 bits is rejected */
if ( i > 24)
{
goto EXIT;
}
else if ( (!i && !(~(0x0 ^ ulMaskValue))) /* 255.255.255.255 */
||
! (~( ( (~0x0<<(32-i))) ^ ulMaskValue )) /* Other subnet masks */
)
{
bIsValid = TRUE;
goto EXIT;
}
}
EXIT:
if ( pAddrListTokenChain )
{
AnscTcFree((ANSC_HANDLE)pAddrListTokenChain);
}
return bIsValid;
}
/**********************************************************************
prototype:
BOOL
DslhVarroIsValidIpAddRangeList
(
PCHAR pAddRangeList
);
description:
This function is called check if it's a valid IpAddress
range List;
argument: PCHAR pAddList
The IpAddress List string seperated by ',';
return: TRUE or FALSE
**********************************************************************/
BOOL
DslhVarroIsValidIpAddRangeList
(
PCHAR pAddRangeList
)
{
PANSC_TOKEN_CHAIN pAddrRangeTokenChain = (PANSC_TOKEN_CHAIN )NULL;
PANSC_TOKEN_CHAIN pAddrTokenChain = (PANSC_TOKEN_CHAIN )NULL;
PANSC_STRING_TOKEN pAddrStringToken = (PANSC_STRING_TOKEN )NULL;
PANSC_STRING_TOKEN pAddrStringToken1 = (PANSC_STRING_TOKEN )NULL;
PANSC_STRING_TOKEN pAddrStringToken2 = (PANSC_STRING_TOKEN )NULL;
BOOL bIsValid = TRUE;
ULONG i = 0;
if( !pAddRangeList || AnscSizeOfString(pAddRangeList) == 0)
{
return bIsValid;
}
if ( DslhVarroDelSpaceInCommaSeparator((PCHAR)pAddRangeList) )
{
if ( (AnscSizeOfString(pAddRangeList) != 0) && (pAddrRangeTokenChain = AnscTcAllocate( pAddRangeList, "," )) )
{
while ( pAddrStringToken = AnscTcUnlinkToken(pAddrRangeTokenChain) )
{
if ( pAddrTokenChain = AnscTcAllocate(pAddrStringToken->Name, "-") )
{
pAddrStringToken1 = AnscTcUnlinkToken(pAddrTokenChain);
if( ! AnscIsValidIpString((PCHAR)pAddrStringToken1->Name))
{
bIsValid = FALSE;
goto EXIT2;
}
pAddrStringToken2 = AnscTcUnlinkToken(pAddrTokenChain);
if( !pAddrStringToken2 || ! AnscIsValidIpString((PCHAR)pAddrStringToken2->Name))
{
bIsValid = FALSE;
goto EXIT3;
}
if ( _ansc_inet_addr(pAddrStringToken1->Name) > _ansc_inet_addr(pAddrStringToken2->Name) )
{
bIsValid = FALSE;
goto EXIT3;
}
AnscFreeMemory(pAddrStringToken2);
AnscFreeMemory(pAddrStringToken1);
AnscFreeMemory(pAddrStringToken);
AnscTcFree((ANSC_HANDLE)pAddrTokenChain);
}
else
{
bIsValid = FALSE;
goto EXIT1;
}
}
goto EXIT;
}
else
{
return bIsValid = FALSE;
}
}
else
{
return bIsValid = FALSE;
}
EXIT3:
if ( pAddrStringToken2 )
{
AnscFreeMemory(pAddrStringToken2);
}
EXIT2:
if ( pAddrStringToken1 )
{
AnscFreeMemory(pAddrStringToken1);
}
if ( pAddrStringToken )
{
AnscFreeMemory(pAddrStringToken);
}
EXIT1:
if ( pAddrTokenChain )
{
AnscTcFree((ANSC_HANDLE)pAddrTokenChain);
}
EXIT:
if ( pAddrRangeTokenChain )
{
AnscTcFree((ANSC_HANDLE)pAddrRangeTokenChain);
}
return bIsValid;
}
ANSC_STATUS
SysRdoDelRecord
(
ANSC_HANDLE hThisObject,
char* pRecordName
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PSYS_REPOSITORY_DRIVER_OBJECT pMyObject = (PSYS_REPOSITORY_DRIVER_OBJECT )hThisObject;
PSYS_REPOSITORY_DRIVER_PROPERTY pProperty = (PSYS_REPOSITORY_DRIVER_PROPERTY)&pMyObject->Property;
PSYS_REPOSITORY_FOLDER_OBJECT pRootFolder = (PSYS_REPOSITORY_FOLDER_OBJECT )pMyObject->hRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pThisFolder = pRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pNextFolder = NULL;
PSYS_REPOSITORY_RECORD_OBJECT pThisRecord = NULL;
PANSC_TOKEN_CHAIN pTokenChain = NULL;
PANSC_STRING_TOKEN pTokenEntry = NULL;
pTokenChain =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
pRecordName,
SYS_RDO_PATH_SEPARATORS
);
if ( !pTokenChain )
{
returnStatus = ANSC_STATUS_BAD_NAME;
goto EXIT1;
}
else if ( AnscTcGetTokenCount(pTokenChain) == 0 )
{
returnStatus = ANSC_STATUS_BAD_NAME;
goto EXIT2;
}
pThisFolder->AcquireAccess((ANSC_HANDLE)pThisFolder);
while ( pTokenEntry = AnscTcUnlinkToken(pTokenChain) )
{
pNextFolder =
pThisFolder->GetFolderByName
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name
);
if ( pNextFolder )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
AnscFreeMemory(pTokenEntry);
}
else
{
AnscTcPrefixToken(pTokenChain, pTokenEntry);
break;
}
pThisFolder = pNextFolder;
}
if ( !pTokenEntry )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
returnStatus = ANSC_STATUS_BAD_NAME;
goto EXIT2;
}
else if ( !pThisFolder )
{
returnStatus = ANSC_STATUS_BAD_NAME;
goto EXIT2;
}
else if ( AnscTcGetTokenCount(pTokenChain) != 1 )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
returnStatus = ANSC_STATUS_BAD_NAME;
goto EXIT2;
}
else if ( (pThisFolder->GetPermission((ANSC_HANDLE)pThisFolder) & SYS_RFO_PERMISSION_RECORD_DELETE) == 0 )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
returnStatus = ANSC_STATUS_ACCESS_DENIED;
goto EXIT2;
}
else
{
pTokenEntry = AnscTcUnlinkToken(pTokenChain);
}
returnStatus =
pThisFolder->DelRecord
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name
);
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
AnscFreeMemory(pTokenEntry);
/******************************************************************
GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS
******************************************************************/
EXIT2:
AnscTcFree((ANSC_HANDLE)pTokenChain);
EXIT1:
return returnStatus;
}
/**********************************************************************
prototype:
BOOL
DslhVarroIsValidIp6AddList
(
PCHAR pAddList
);
description:
This function is called check if it's a valid Ip6Address List;
argument: PCHAR pAddList
The MacAddress List string seperated by ',';
return: TRUE or FALSE
**********************************************************************/
BOOL
DslhVarroIsValidIp6AddList
(
PCHAR pAddList
)
{
PANSC_TOKEN_CHAIN pAddrListTokenChain = (PANSC_TOKEN_CHAIN )NULL;
PANSC_STRING_TOKEN pAddrStringToken = (PANSC_STRING_TOKEN )NULL;
BOOL bIsValid = TRUE;
ULONG uLength = 0;
ULONG i = 0;
if( !pAddList || AnscSizeOfString(pAddList) == 0)
{
return bIsValid;
}
uLength = AnscSizeOfString(pAddList);
/* cannot start or end with ',' */
if( pAddList[0] == ',' || pAddList[uLength-1] == ',' )
{
return FALSE;
}
/* cannot have empty address in the middle */
if( _ansc_strstr(pAddList, ",,") != NULL)
{
return FALSE;
}
if ( DslhVarroDelSpaceInCommaSeparator((PCHAR)pAddList) )
{
if ( pAddrListTokenChain = AnscTcAllocate( pAddList, "," ) )
{
while ( pAddrStringToken = AnscTcUnlinkToken(pAddrListTokenChain) )
{
if( ! AnscIsValidIp6String((PCHAR)pAddrStringToken->Name))
{
bIsValid = FALSE;
AnscFreeMemory(pAddrStringToken);
goto EXIT;
}
AnscFreeMemory(pAddrStringToken);
}
}
else
{
return FALSE;
}
}
else
{
return FALSE;
}
EXIT:
if ( pAddrListTokenChain )
{
AnscTcFree((ANSC_HANDLE)pAddrListTokenChain);
}
return bIsValid;
}
ANSC_HANDLE
SysRdoGetFolder2
(
ANSC_HANDLE hThisObject,
ANSC_HANDLE hCurFolder,
char* pSubFolderName
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PSYS_REPOSITORY_DRIVER_OBJECT pMyObject = (PSYS_REPOSITORY_DRIVER_OBJECT )hThisObject;
PSYS_REPOSITORY_DRIVER_PROPERTY pProperty = (PSYS_REPOSITORY_DRIVER_PROPERTY)&pMyObject->Property;
PSYS_REPOSITORY_FOLDER_OBJECT pRootFolder = (PSYS_REPOSITORY_FOLDER_OBJECT )pMyObject->hRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pThisFolder = (hCurFolder != NULL)? (PSYS_REPOSITORY_FOLDER_OBJECT)hCurFolder : pRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pNextFolder = NULL;
PANSC_TOKEN_CHAIN pTokenChain = NULL;
PANSC_STRING_TOKEN pTokenEntry = NULL;
pTokenChain =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
pSubFolderName,
SYS_RDO_PATH_SEPARATORS
);
if ( !pTokenChain )
{
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
goto EXIT1;
}
else if ( AnscTcGetTokenCount(pTokenChain) == 0 )
{
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
goto EXIT2;
}
pThisFolder->AcquireAccess((ANSC_HANDLE)pThisFolder);
while ( pTokenEntry = AnscTcUnlinkToken(pTokenChain) )
{
pNextFolder =
pThisFolder->GetFolderByName
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name
);
if ( pNextFolder )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
AnscFreeMemory(pTokenEntry);
}
else
{
AnscTcPrefixToken(pTokenChain, pTokenEntry);
break;
}
pThisFolder = pNextFolder;
}
if ( pTokenEntry )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
}
/******************************************************************
GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS
******************************************************************/
EXIT2:
AnscTcFree((ANSC_HANDLE)pTokenChain);
EXIT1:
return (ANSC_HANDLE)pThisFolder;
}
ANSC_HANDLE
SysRdoAddFolder2
(
ANSC_HANDLE hThisObject,
ANSC_HANDLE hCurFolder,
char* pSubFolderName,
ULONG ulPermission,
ULONG ulFolderType,
ANSC_HANDLE hRenderAttr,
ANSC_HANDLE hReserved
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PSYS_REPOSITORY_DRIVER_OBJECT pMyObject = (PSYS_REPOSITORY_DRIVER_OBJECT )hThisObject;
PSYS_REPOSITORY_DRIVER_PROPERTY pProperty = (PSYS_REPOSITORY_DRIVER_PROPERTY)&pMyObject->Property;
PSYS_REPOSITORY_FOLDER_OBJECT pRootFolder = (PSYS_REPOSITORY_FOLDER_OBJECT )pMyObject->hRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pThisFolder = (hCurFolder != NULL)? (PSYS_REPOSITORY_FOLDER_OBJECT)hCurFolder : pRootFolder;
PSYS_REPOSITORY_FOLDER_OBJECT pNextFolder = NULL;
PANSC_TOKEN_CHAIN pTokenChain = NULL;
PANSC_STRING_TOKEN pTokenEntry = NULL;
pTokenChain =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
pSubFolderName,
SYS_RDO_PATH_SEPARATORS
);
if ( !pTokenChain )
{
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
goto EXIT1;
}
else if ( AnscTcGetTokenCount(pTokenChain) == 0 )
{
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
goto EXIT2;
}
/*
* The specified folder name is the absolute path where the new folder should be created in the
* repository tree. We first try to go as far as we can using specified folder name as the path
* into tree, then creates a new branch based on the rest of the token chain.
*/
pThisFolder->AcquireAccess((ANSC_HANDLE)pThisFolder);
while ( pTokenEntry = AnscTcUnlinkToken(pTokenChain) )
{
pNextFolder =
pThisFolder->GetFolderByName
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name
);
if ( pNextFolder )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
AnscFreeMemory(pTokenEntry);
}
else
{
AnscTcPrefixToken(pTokenChain, pTokenEntry);
break;
}
pThisFolder = pNextFolder;
}
if ( !pTokenEntry )
{
if ( !pThisFolder )
{
goto EXIT2;
}
else if ( (pThisFolder->GetPermission((ANSC_HANDLE)pThisFolder) != ulPermission) ||
(pThisFolder->GetFolderType((ANSC_HANDLE)pThisFolder) != ulFolderType) )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
}
goto EXIT2;
}
/*
* We have found the Repository Folder Object whose name is the longest match for the specified
* folder name. For each path segment that is left in the specified path name, we create a sub-
* folder under each previously-created folder object starting with the current folder object.
* While this approach has the benefit of saving other components from having to follow strict
* layering rule by creating a folder every step along the way, it does introduce an ambiguous
* situation: what folder-permission and folder-type shall we assign to the folders that are
* created for the middle segments of the specified path? As you shall see below, we assign the
* default permission and type to all the unspecified folders.
*/
while ( pTokenEntry = AnscTcUnlinkToken(pTokenChain) )
{
if ( AnscTcGetTokenCount(pTokenChain) > 0 )
{
pNextFolder =
pThisFolder->AddFolder
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name,
SYS_RFO_PERMISSION_ALL,
SYS_REP_FOLDER_TYPE_STORAGE,
(ANSC_HANDLE)NULL,
(ANSC_HANDLE)NULL
);
}
else
{
pNextFolder =
pThisFolder->AddFolder
(
(ANSC_HANDLE)pThisFolder,
pTokenEntry->Name,
ulPermission,
ulFolderType,
hRenderAttr,
hReserved
);
}
if ( pNextFolder )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
AnscFreeMemory(pTokenEntry);
}
else
{
AnscTcPrefixToken(pTokenChain, pTokenEntry);
break;
}
pThisFolder = pNextFolder;
}
if ( pTokenEntry )
{
pThisFolder->ReleaseAccess((ANSC_HANDLE)pThisFolder);
pThisFolder = (PSYS_REPOSITORY_FOLDER_OBJECT)NULL;
}
/******************************************************************
GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS
******************************************************************/
EXIT2:
AnscTcFree((ANSC_HANDLE)pTokenChain);
EXIT1:
return (ANSC_HANDLE)pThisFolder;
}
ANSC_HANDLE
Bmc2EnvcoGetCommandProperty
(
ANSC_HANDLE hThisObject,
char* pCommandName,
char* pDomainName
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PBMC2_ENV_CONTROLLER_OBJECT pMyObject = (PBMC2_ENV_CONTROLLER_OBJECT )hThisObject;
PBMC2_ENV_CONTROLLER_PROPERTY pProperty = (PBMC2_ENV_CONTROLLER_PROPERTY)&pMyObject->Property;
PBMC2_COMMAND_PROPERTY pBmc2CommandProperty = (PBMC2_COMMAND_PROPERTY )NULL;
PSINGLE_LINK_ENTRY pSLinkEntry = (PSINGLE_LINK_ENTRY )NULL;
ULONG ulHashIndex = AnscHashString(pCommandName, AnscSizeOfString(pCommandName), BMC2_ENVCO_COMPO_TABLE_SIZE);
AnscAcquireLock(&pMyObject->CompoTableLock);
pSLinkEntry = AnscQueueGetFirstEntry(&pMyObject->CompoTable[ulHashIndex]);
while ( pSLinkEntry )
{
pBmc2CommandProperty = ACCESS_BMC2_COMMAND_PROPERTY(pSLinkEntry);
pSLinkEntry = AnscQueueGetNextEntry(pSLinkEntry);
if ( AnscEqualString
(
pBmc2CommandProperty->CommandName,
pCommandName,
FALSE
) )
{
BOOL bDomainMatched = FALSE;
/* check if the specified domain matches pattern defined in command property */
if ( !pBmc2CommandProperty->DomainNamePattern ||
AnscEqualString(pBmc2CommandProperty->DomainNamePattern, "*", TRUE) )
{
bDomainMatched = TRUE;
}
else
{
char* pStar = _ansc_strstr(pBmc2CommandProperty->DomainNamePattern, "*");
if ( !pStar )
{
bDomainMatched =
AnscEqualString
(
pBmc2CommandProperty->DomainNamePattern,
pDomainName,
FALSE
);
}
else
{
PANSC_TOKEN_CHAIN pTokenChain = (PANSC_TOKEN_CHAIN)NULL;
PANSC_STRING_TOKEN pStringToken = (PANSC_STRING_TOKEN)NULL;
ULONG ulCurPos = 0;
char* pCurDomain = pDomainName;
char* pSubStr = NULL;
bDomainMatched = TRUE;
pTokenChain =
AnscTcAllocate3
(
pBmc2CommandProperty->DomainNamePattern,
"*"
);
if(pTokenChain) /*RDKB-5887 , CID-24415, null check before use*/
{
while ( pStringToken = AnscTcUnlinkToken(pTokenChain) )
{
pSubStr = Bmc2EnvcoFindSubStrNoCase(pCurDomain, pStringToken->Name);
if ( !pSubStr )
{
bDomainMatched = FALSE;
}
else if ( pCurDomain == pDomainName && *pBmc2CommandProperty->DomainNamePattern != '*' )
{
if ( pSubStr != pCurDomain )
{
bDomainMatched = FALSE;
}
}
if ( pSubStr )
{
pCurDomain = pSubStr + AnscSizeOfString(pStringToken->Name); /* move to next part */
}
AnscFreeMemory(pStringToken);
if ( !bDomainMatched )
{
break;
}
}
AnscTcFree((ANSC_HANDLE)pTokenChain);
}
}
}
if ( !bDomainMatched )
{
continue;
}
AnscReleaseLock(&pMyObject->CompoTableLock);
return (ANSC_HANDLE)pBmc2CommandProperty;
}
}
AnscReleaseLock(&pMyObject->CompoTableLock);
return (ANSC_HANDLE)NULL;
}
ANSC_STATUS
SlapOeoResolveCallDescrR
(
ANSC_HANDLE hThisObject,
char* call_description,
SLAP_VARIABLE* return_var
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PSLAP_OBJ_ENTITY_OBJECT pMyObject = (PSLAP_OBJ_ENTITY_OBJECT)hThisObject;
PSLAP_BSS_INTERFACE pSlapBssIf = (PSLAP_BSS_INTERFACE )pMyObject->hSlapBssIf;
PSLAP_VAR_MAPPER_OBJECT pSlapVarMapper = (PSLAP_VAR_MAPPER_OBJECT)pSlapBssIf->GetVarMapper(pSlapBssIf->hOwnerContext);
PANSC_TOKEN_CHAIN pTokenChainParamDesp = NULL;
PANSC_STRING_TOKEN pTokenSyntax = NULL;
PANSC_STRING_TOKEN pTokenContentType = NULL;
if ( !pSlapVarMapper )
{
return ANSC_STATUS_INTERNAL_ERROR;
}
else
{
SlapCleanVariable(return_var);
SlapInitVariable (return_var);
}
pTokenChainParamDesp =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
call_description,
SLAP_CALL_PARAMETER_SEPARATORS
);
if ( !pTokenChainParamDesp )
{
return ANSC_STATUS_UNAPPLICABLE;
}
else
{
pTokenSyntax = (PANSC_STRING_TOKEN)AnscTcPopToken((ANSC_HANDLE)pTokenChainParamDesp);
pTokenContentType = (PANSC_STRING_TOKEN)AnscTcPopToken((ANSC_HANDLE)pTokenChainParamDesp);
AnscTcFree(pTokenChainParamDesp);
}
if ( !pTokenSyntax )
{
return ANSC_STATUS_UNAPPLICABLE;
}
else
{
return_var->Name = NULL;
return_var->ContentType = SLAP_CONTENT_TYPE_UNSPECIFIED;
return_var->UsageType = 0;
return_var->Syntax =
pSlapVarMapper->GetVarSyntax
(
(ANSC_HANDLE)pSlapVarMapper,
pTokenSyntax->Name
);
AnscFreeMemory(pTokenSyntax);
}
if ( pTokenContentType )
{
return_var->ContentType =
pSlapVarMapper->GetVarContentType
(
(ANSC_HANDLE)pSlapVarMapper,
pTokenContentType->Name
);
AnscFreeMemory(pTokenContentType);
}
return ANSC_STATUS_SUCCESS;
}
ANSC_STATUS
SlapOeoResolveCallDescrI
(
ANSC_HANDLE hThisObject,
char* call_description,
SLAP_PARAMETER_LIST* param_list
)
{
ANSC_STATUS returnStatus = ANSC_STATUS_SUCCESS;
PSLAP_OBJ_ENTITY_OBJECT pMyObject = (PSLAP_OBJ_ENTITY_OBJECT)hThisObject;
PSLAP_BSS_INTERFACE pSlapBssIf = (PSLAP_BSS_INTERFACE )pMyObject->hSlapBssIf;
PSLAP_VAR_MAPPER_OBJECT pSlapVarMapper = (PSLAP_VAR_MAPPER_OBJECT)pSlapBssIf->GetVarMapper(pSlapBssIf->hOwnerContext);
PANSC_TOKEN_CHAIN pTokenChainParamList = NULL;
PANSC_TOKEN_CHAIN pTokenChainParamDesp = NULL;
PANSC_STRING_TOKEN pTokenParamDesp = NULL;
PANSC_STRING_TOKEN pTokenSyntax = NULL;
PANSC_STRING_TOKEN pTokenContentType = NULL;
ULONG ulParamCount = 0;
if ( !pSlapVarMapper )
{
return ANSC_STATUS_INTERNAL_ERROR;
}
else
{
SlapCleanParamList(param_list);
SlapInitParamList (param_list);
}
pTokenChainParamList =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
call_description,
SLAP_CALL_PARAMETER_LIST_SEPARATORS
);
if ( !pTokenChainParamList )
{
returnStatus = ANSC_STATUS_UNAPPLICABLE;
goto EXIT1;
}
while ( pTokenParamDesp = (PANSC_STRING_TOKEN)AnscTcPopToken((ANSC_HANDLE)pTokenChainParamList) )
{
pTokenChainParamDesp =
(PANSC_TOKEN_CHAIN)AnscTcAllocate
(
pTokenParamDesp->Name,
SLAP_CALL_PARAMETER_SEPARATORS
);
if ( !pTokenChainParamDesp )
{
AnscFreeMemory(pTokenParamDesp);
returnStatus = ANSC_STATUS_UNAPPLICABLE;
goto EXIT2;
}
else
{
AnscFreeMemory(pTokenParamDesp);
pTokenSyntax = (PANSC_STRING_TOKEN)AnscTcPopToken((ANSC_HANDLE)pTokenChainParamDesp);
pTokenContentType = (PANSC_STRING_TOKEN)AnscTcPopToken((ANSC_HANDLE)pTokenChainParamDesp);
AnscTcFree(pTokenChainParamDesp);
}
if ( !pTokenSyntax )
{
returnStatus = ANSC_STATUS_UNAPPLICABLE;
goto EXIT2;
}
else
{
param_list->ParamArray[ulParamCount].Name = NULL;
param_list->ParamArray[ulParamCount].ContentType = SLAP_CONTENT_TYPE_UNSPECIFIED;
param_list->ParamArray[ulParamCount].UsageType = 0;
param_list->ParamArray[ulParamCount].Syntax =
pSlapVarMapper->GetVarSyntax
(
(ANSC_HANDLE)pSlapVarMapper,
pTokenSyntax->Name
);
AnscFreeMemory(pTokenSyntax);
}
if ( pTokenContentType )
{
param_list->ParamArray[ulParamCount].ContentType =
pSlapVarMapper->GetVarContentType
(
(ANSC_HANDLE)pSlapVarMapper,
pTokenContentType->Name
);
AnscFreeMemory(pTokenContentType);
}
ulParamCount++;
}
param_list->ParamCount = ulParamCount;
returnStatus = ANSC_STATUS_SUCCESS;
/******************************************************************
GRACEFUL ROLLBACK PROCEDURES AND EXIT DOORS
******************************************************************/
EXIT2:
AnscTcFree((ANSC_HANDLE)pTokenChainParamList);
EXIT1:
return returnStatus;
}
