/*++

Copyright (c) 1996 Microsoft Corporation

Module Name:

    scemm.cpp

Abstract:

    Shared memory management APIs

Author:

    Jin Huang

Revision History:

    jinhuang        23-Jan-1998   merged from multiple modules

--*/
#include "headers.h"
#include "scesvc.h"


PVOID
MIDL_user_allocate (
    size_t  NumBytes
    )

/*++

Routine Description:

    Allocates storage for RPC server transactions.  The RPC stubs will
    either call MIDL_user_allocate when it needs to un-marshall data into a
    buffer that the user must free.  RPC servers will use MIDL_user_allocate to
    allocate storage that the RPC server stub will free after marshalling
    the data.

Arguments:

    NumBytes - The number of bytes to allocate.

Return Value:

    none

Note:


--*/

{
    PVOID Buffer = (PVOID) ScepAlloc(LMEM_FIXED,(DWORD)NumBytes);

    if (Buffer != NULL) {

        RtlZeroMemory( Buffer, NumBytes );
    }

    return( Buffer );
}


VOID
MIDL_user_free (
    void    *MemPointer
    )

/*++

Routine Description:

    Frees storage used in RPC transactions.  The RPC client can call this
    function to free buffer space that was allocated by the RPC client
    stub when un-marshalling data that is to be returned to the client.
    The Client calls MIDL_user_free when it is finished with the data and
    desires to free up the storage.
    The RPC server stub calls MIDL_user_free when it has completed
    marshalling server data that is to be passed back to the client.

Arguments:

    MemPointer - This points to the memory block that is to be released.

Return Value:

    none.

Note:


--*/

{
    ScepFree(MemPointer);
}


SCESTATUS
ScepFreeNameList(
   IN PSCE_NAME_LIST pName
   )
/* ++
Routine Description:

   This routine frees memory associated with PSCE_NAME_LIST pName

Arguments:

   pName - a NAME_LIST

Return value:

   SCESTATUS_SUCCESS

-- */
{
    PSCE_NAME_LIST pCurName;
    PSCE_NAME_LIST pTempName;
    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( pName == NULL )
        return(rc);

    //
    // free the Name component first then free the node
    //
    pCurName = pName;
    while ( pCurName != NULL ) {
        if ( pCurName->Name != NULL )
            __try {
                ScepFree( pCurName->Name );
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                rc = SCESTATUS_INVALID_PARAMETER;
            }

        pTempName = pCurName;
        pCurName = pCurName->Next;

        __try {
            ScepFree( pTempName );
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            rc = SCESTATUS_INVALID_PARAMETER;
        }

    }
    return(rc);
}


HLOCAL
ScepAlloc(
    IN UINT uFlags,
    IN UINT uBytes
    )
/*
memory allocation routine, which calls LocalAlloc.
*/
{
    HLOCAL       pTemp=NULL;

    pTemp = LocalAlloc(uFlags, uBytes);

#ifdef SCE_DBG
    if ( pTemp != NULL ) {
        TotalBytes += uBytes;
        printf("Allocate %d bytes at 0x%x. Total bytes = %d\n", uBytes, pTemp, TotalBytes);
    }
#endif
    return(pTemp);
}


VOID
ScepFree(
    HLOCAL pToFree
    )
/*
memory free routine, which calls LocalFree.
*/
{   HLOCAL pTemp;

    if (pToFree != NULL) {
        pTemp = LocalFree( pToFree );

#ifdef SCE_DBG
        if ( pTemp == NULL )
            printf("0x%x is freed\n", pToFree);
        else
            printf("Unable to free 0x%x. Error code=%d\n", pToFree, GetLastError());
#endif

    }

}


SCESTATUS
ScepFreeErrorLog(
    IN PSCE_ERROR_LOG_INFO Errlog
    )
/* ++
Routine Description:

   This routine frees memory associated with SCE_ERROR_LOG_INFO list

Arguments

   Errlog - Head of the error log

Return value:

   SCESTATUS

-- */
{
    PSCE_ERROR_LOG_INFO  pErr;
    PSCE_ERROR_LOG_INFO  pTemp;

    if ( Errlog != NULL ) {

        pErr = Errlog;
        while ( pErr != NULL ) {
            if ( pErr->buffer != NULL )
                ScepFree( pErr->buffer );

            pTemp = pErr;
            pErr = pErr->next;
            ScepFree( pTemp );
        }

    }
    return(SCESTATUS_SUCCESS);
}


SCESTATUS
ScepFreeRegistryValues(
    IN PSCE_REGISTRY_VALUE_INFO *ppRegValues,
    IN DWORD Count
    )
/*
free memory allocated for the array of SCE_REGISTRY_VALUE_INFO

*/
{
    if ( ppRegValues && *ppRegValues ) {

        for ( DWORD i=0; i<Count; i++ ) {
            //
            // free value name buffer within each element
            //
            if ( (*ppRegValues)[i].FullValueName ) {
                ScepFree((*ppRegValues)[i].FullValueName);
            }

            __try {
                if ( (*ppRegValues)[i].Value ) {
                    //
                    // this is a pointer of PWSTR
                    //
                    ScepFree((*ppRegValues)[i].Value);
                }
            } __except (EXCEPTION_EXECUTE_HANDLER) {
            }
        }
        //
        // free the array buffer
        //
        ScepFree(*ppRegValues);
        *ppRegValues = NULL;
    }

    return(SCESTATUS_SUCCESS);
}


SCESTATUS
WINAPI
SceFreeMemory(
   IN PVOID sceInfo,
   IN DWORD Category
   )
/* ++
Routine Description:

    This routine frees memory associated with  SceInfo in the specified area.
    The Type field in SceInfo indicates the type of the structure.

Arguments:

    SceInfo  - The memory buffer to free. It could be type
                    SCE_ENGINE_SCP
                    SCE_ENGINE_SAP
                    SCE_ENGINE_SMP
                    SCE_STRUCT_PROFILE
                    SCE_STRUCT_USER

    Area    - The security area to free. This argument is only used for
                SCE_ENGINE_SCP, SCE_ENGINE_SAP, and SCE_ENGINE_SMP types.


Return value:

   None

-- */
{
    SCETYPE                        sceType;
    AREA_INFORMATION              Area;
    PSCE_PROFILE_INFO              pProfileInfo=NULL;
    PSCE_USER_PROFILE              pProfile;
    PSCE_LOGON_HOUR                pTempLogon;
    PSCE_USER_SETTING              pPerUser;
    PSCE_OBJECT_SECURITY           pos;

    SCESTATUS                      rc=SCESTATUS_SUCCESS;

    if ( sceInfo == NULL )
        return(SCESTATUS_SUCCESS);

    if ( Category >= 300 ) {
        //
        // memory associated with list
        //
        __try {

            switch ( Category ) {
            case SCE_STRUCT_NAME_LIST:
                ScepFreeNameList((PSCE_NAME_LIST)sceInfo);
                break;

            case SCE_STRUCT_NAME_STATUS_LIST:
                ScepFreeNameStatusList( (PSCE_NAME_STATUS_LIST)sceInfo );
                break;

            case SCE_STRUCT_PRIVILEGE_VALUE_LIST:
                ScepFreePrivilegeValueList( (PSCE_PRIVILEGE_VALUE_LIST)sceInfo );
                break;

            case SCE_STRUCT_PRIVILEGE:
                ScepFreePrivilege( (PSCE_PRIVILEGE_ASSIGNMENT)sceInfo );
                break;

            case SCE_STRUCT_GROUP:
                ScepFreeGroupMembership( (PSCE_GROUP_MEMBERSHIP)sceInfo );
                break;

            case SCE_STRUCT_OBJECT_LIST:
                ScepFreeObjectList( (PSCE_OBJECT_LIST)sceInfo );
                break;

            case SCE_STRUCT_OBJECT_CHILDREN:
                ScepFreeObjectChildren( (PSCE_OBJECT_CHILDREN)sceInfo );
                break;

            case SCE_STRUCT_OBJECT_SECURITY:
                pos = (PSCE_OBJECT_SECURITY)sceInfo;
                if ( pos ) {
                    if ( pos->Name != NULL )
                        ScepFree( pos->Name );

                    if ( pos->pSecurityDescriptor != NULL )
                        ScepFree(pos->pSecurityDescriptor);

                    ScepFree( pos );
                }
                break;
            case SCE_STRUCT_OBJECT_ARRAY:
                ScepFreeObjectSecurity( (PSCE_OBJECT_ARRAY)sceInfo );
                break;

            case SCE_STRUCT_PROFILE:
            case SCE_STRUCT_USER:
                SceFreeMemory( sceInfo, 0 );  // type is embedded
                break;

            case SCE_STRUCT_ERROR_LOG_INFO:
                ScepFreeErrorLog( (PSCE_ERROR_LOG_INFO)sceInfo );
                break;

            case SCE_STRUCT_SERVICES:
                SceFreePSCE_SERVICES((PSCE_SERVICES)sceInfo);
                break;

            default:
                rc = SCESTATUS_INVALID_PARAMETER;
            }
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            ASSERT(FALSE);
            rc = SCESTATUS_INVALID_PARAMETER;
        }

    } else {

        sceType = *((SCETYPE *)sceInfo);
        Area = (AREA_INFORMATION)Category;

        switch ( sceType ) {
        case SCE_ENGINE_SCP:
        case SCE_ENGINE_SAP:
        case SCE_ENGINE_SMP:
        case SCE_ENGINE_SCP_INTERNAL:
        case SCE_ENGINE_SMP_INTERNAL:
        case SCE_STRUCT_INF:
            pProfileInfo = (PSCE_PROFILE_INFO)sceInfo;
#if 0
            if ( Area & AREA_DS_OBJECTS ) {
                //
                // free ds list
                //
                if ( sceType == SCE_STRUCT_INF ) {
                    ScepFreeObjectSecurity(pProfileInfo->pDsObjects.pAllNodes);
                    pProfileInfo->pDsObjects.pAllNodes = NULL;

                } else {

                    ScepFreeObjectList(pProfileInfo->pDsObjects.pOneLevel);
                    pProfileInfo->pDsObjects.pOneLevel = NULL;

                }
            }
#endif
            if ( Area & AREA_FILE_SECURITY ) {
                //
                // free file list and auditing list
                //
                __try {
                    if ( sceType == SCE_STRUCT_INF ) {
                        ScepFreeObjectSecurity(pProfileInfo->pFiles.pAllNodes);
                        pProfileInfo->pFiles.pAllNodes = NULL;

                    } else {

                        ScepFreeObjectList(pProfileInfo->pFiles.pOneLevel);
                        pProfileInfo->pFiles.pOneLevel = NULL;

                    }

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }


            if ( Area & AREA_REGISTRY_SECURITY ) {
                //
                // free registry keys list and auditing list
                //
                __try {
                    if ( sceType == SCE_STRUCT_INF ) {
                        ScepFreeObjectSecurity(pProfileInfo->pRegistryKeys.pAllNodes);
                        pProfileInfo->pRegistryKeys.pAllNodes = NULL;

                    } else {
                        ScepFreeObjectList(pProfileInfo->pRegistryKeys.pOneLevel);
                        pProfileInfo->pRegistryKeys.pOneLevel = NULL;

                    }

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }

            if ( Area & AREA_GROUP_MEMBERSHIP ) {

                __try {
                    ScepFreeGroupMembership(pProfileInfo->pGroupMembership);
                    pProfileInfo->pGroupMembership = NULL;

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }


            if ( Area & AREA_PRIVILEGES ) {

                __try {

                    switch ( sceType ) {
                    case SCE_ENGINE_SCP_INTERNAL:
                    case SCE_ENGINE_SMP_INTERNAL:
                        //
                        // SCP type Privilege Rights
                        //
                        ScepFreePrivilegeValueList(pProfileInfo->OtherInfo.scp.u.pPrivilegeAssignedTo);
                        pProfileInfo->OtherInfo.scp.u.pPrivilegeAssignedTo = NULL;
                        break;
                    case SCE_STRUCT_INF:
                        ScepFreePrivilege(pProfileInfo->OtherInfo.scp.u.pInfPrivilegeAssignedTo);
                        pProfileInfo->OtherInfo.scp.u.pInfPrivilegeAssignedTo = NULL;
                        break;
                    case SCE_ENGINE_SMP:
                    case SCE_ENGINE_SCP:
                        //
                        // SMP type Privilege Rights
                        //
                        ScepFreePrivilege(pProfileInfo->OtherInfo.smp.pPrivilegeAssignedTo);
                        pProfileInfo->OtherInfo.smp.pPrivilegeAssignedTo = NULL;
                        break;

                    default: // SAP
                        ScepFreePrivilege(pProfileInfo->OtherInfo.sap.pPrivilegeAssignedTo);
                        pProfileInfo->OtherInfo.sap.pPrivilegeAssignedTo=NULL;
                        break;
                    }

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }

            if ( Area & AREA_USER_SETTINGS ) {

                __try {

                    switch ( sceType ) {
                    case SCE_ENGINE_SCP_INTERNAL:
                    case SCE_ENGINE_SMP_INTERNAL:
                    case SCE_STRUCT_INF:
                        //
                        // Account Profiles
                        //
                        ScepFreeNameList(pProfileInfo->OtherInfo.scp.pAccountProfiles);
                        pProfileInfo->OtherInfo.scp.pAccountProfiles = NULL;
                        break;

                    case SCE_ENGINE_SAP:
                        //
                        // SAP type
                        //
                        ScepFreeNameList(pProfileInfo->OtherInfo.sap.pUserList);
                        pProfileInfo->OtherInfo.sap.pUserList = NULL;
                        break;

                    default: // SMP or SCP
                        ScepFreeNameList(pProfileInfo->OtherInfo.smp.pUserList);
                        pProfileInfo->OtherInfo.smp.pUserList = NULL;
                        break;
                    }
                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }

            if ( Area & AREA_SECURITY_POLICY ) {

                __try {

                    if (pProfileInfo->NewAdministratorName != NULL ) {
                        ScepFree( pProfileInfo->NewAdministratorName );
                        pProfileInfo->NewAdministratorName = NULL;
                    }

                    if (pProfileInfo->NewGuestName != NULL ) {
                        ScepFree( pProfileInfo->NewGuestName );
                        pProfileInfo->NewGuestName = NULL;
                    }

                    if ( pProfileInfo->pKerberosInfo ) {
                        ScepFree(pProfileInfo->pKerberosInfo);
                        pProfileInfo->pKerberosInfo = NULL;
                    }
                    if ( pProfileInfo->RegValueCount && pProfileInfo->aRegValues ) {

                        ScepFreeRegistryValues(&pProfileInfo->aRegValues,
                                               pProfileInfo->RegValueCount);
                    }
                    pProfileInfo->RegValueCount = 0;
                    pProfileInfo->aRegValues = NULL;

                    ScepResetSecurityPolicyArea(pProfileInfo);

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }
            break;

        case SCE_STRUCT_PROFILE:

            pProfile = (PSCE_USER_PROFILE)sceInfo;

            if ( pProfile != NULL ) {

                __try {

                    if (pProfile->UserProfile != NULL )
                        ScepFree(pProfile->UserProfile);
                    pProfile->UserProfile = NULL;

                    if (pProfile->LogonScript != NULL )
                        ScepFree(pProfile->LogonScript);
                    pProfile->LogonScript = NULL;

                    if (pProfile->HomeDir != NULL )
                        ScepFree(pProfile->HomeDir);
                    pProfile->HomeDir = NULL;

                    //
                    // Logon hours
                    //

                    while (pProfile->pLogonHours != NULL ) {
                        pTempLogon = pProfile->pLogonHours;
                        pProfile->pLogonHours = pProfile->pLogonHours->Next;

                        ScepFree(pTempLogon);
                    }
                    pProfile->pLogonHours = NULL;

                    //
                    // free Workstation name list
                    //

                    if ( pProfile->pWorkstations.Buffer != NULL )
                        ScepFree(pProfile->pWorkstations.Buffer);
                    pProfile->pWorkstations.Buffer = NULL;
                    pProfile->pWorkstations.MaximumLength = 0;
                    pProfile->pWorkstations.Length = 0;

                    //
                    // free Groups name list
                    //

                    ScepFreeNameList(pProfile->pGroupsBelongsTo);
                    pProfile->pGroupsBelongsTo = NULL;

                    //
                    // free AssignToUsers name list
                    //

                    ScepFreeNameList(pProfile->pAssignToUsers);
                    pProfile->pAssignToUsers = NULL;

                    //
                    // free SDs
                    //
                    if (pProfile->pHomeDirSecurity != NULL )
                        ScepFree(pProfile->pHomeDirSecurity);
                    pProfile->pHomeDirSecurity = NULL;

                    if (pProfile->pTempDirSecurity != NULL )
                        ScepFree(pProfile->pTempDirSecurity);
                    pProfile->pTempDirSecurity = NULL;

                    ScepFree(pProfile);

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }
            break;

        case SCE_STRUCT_USER:

            pPerUser = (PSCE_USER_SETTING)sceInfo;

            if ( pPerUser != NULL ) {

                __try {

                    ScepFreeNameList( pPerUser->pGroupsBelongsTo);
                    pPerUser->pGroupsBelongsTo = NULL;

                    if (pPerUser->UserProfile != NULL)
                        ScepFree(pPerUser->UserProfile);
                    pPerUser->UserProfile = NULL;

                    if (pPerUser->pProfileSecurity != NULL)
                        ScepFree(pPerUser->pProfileSecurity);
                    pPerUser->pProfileSecurity = NULL;

                    if (pPerUser->LogonScript != NULL)
                        ScepFree(pPerUser->LogonScript);
                    pPerUser->LogonScript = NULL;

                    if (pPerUser->pLogonScriptSecurity != NULL)
                        ScepFree(pPerUser->pLogonScriptSecurity);
                    pPerUser->pLogonScriptSecurity = NULL;

                    if (pPerUser->HomeDir != NULL)
                        ScepFree(pPerUser->HomeDir);
                    pPerUser->HomeDir = NULL;

                    if (pPerUser->pHomeDirSecurity != NULL)
                        ScepFree(pPerUser->pHomeDirSecurity);
                    pPerUser->pHomeDirSecurity = NULL;

                    if (pPerUser->TempDir != NULL)
                        ScepFree(pPerUser->TempDir);
                    pPerUser->TempDir = NULL;

                    if (pPerUser->pTempDirSecurity != NULL)
                        ScepFree(pPerUser->pTempDirSecurity);
                    pPerUser->pTempDirSecurity = NULL;

                    while (pPerUser->pLogonHours != NULL ) {
                        pTempLogon = pPerUser->pLogonHours;
                        pPerUser->pLogonHours = pPerUser->pLogonHours->Next;

                        ScepFree(pTempLogon);
                    }
                    pPerUser->pLogonHours = NULL;

                    if ( pPerUser->pWorkstations.Buffer != NULL )
                        ScepFree( pPerUser->pWorkstations.Buffer );
                    pPerUser->pWorkstations.Buffer = NULL;
                    pPerUser->pWorkstations.MaximumLength = 0;
                    pPerUser->pWorkstations.Length = 0;

                    ScepFreeNameStatusList(pPerUser->pPrivilegesHeld);
                    pPerUser->pPrivilegesHeld = NULL;

                    ScepFree(pPerUser);

                } __except (EXCEPTION_EXECUTE_HANDLER) {
                    ASSERT(FALSE);
                    rc = SCESTATUS_INVALID_PARAMETER;
                }
            }
            break;

        default:
            return(SCESTATUS_INVALID_PARAMETER);
        }
    }

    return(rc);

}


SCESTATUS
ScepResetSecurityPolicyArea(
    IN PSCE_PROFILE_INFO pProfileInfo
    )
{
    INT i;

    if ( pProfileInfo != NULL ) {

        pProfileInfo->MinimumPasswordAge = SCE_NO_VALUE;
        pProfileInfo->MaximumPasswordAge = SCE_NO_VALUE;
        pProfileInfo->MinimumPasswordLength = SCE_NO_VALUE;
        pProfileInfo->PasswordComplexity = SCE_NO_VALUE;
        pProfileInfo->PasswordHistorySize = SCE_NO_VALUE;
        pProfileInfo->LockoutBadCount = SCE_NO_VALUE;
        pProfileInfo->ResetLockoutCount = SCE_NO_VALUE;
        pProfileInfo->LockoutDuration = SCE_NO_VALUE;
        pProfileInfo->RequireLogonToChangePassword = SCE_NO_VALUE;
        pProfileInfo->ForceLogoffWhenHourExpire = SCE_NO_VALUE;
        pProfileInfo->SecureSystemPartition = SCE_NO_VALUE;
        pProfileInfo->ClearTextPassword = SCE_NO_VALUE;
        pProfileInfo->LSAAnonymousNameLookup = SCE_NO_VALUE;

        for ( i=0; i<3; i++ ) {
            pProfileInfo->MaximumLogSize[i] = SCE_NO_VALUE;
            pProfileInfo->AuditLogRetentionPeriod[i] = SCE_NO_VALUE;
            pProfileInfo->RetentionDays[i] = SCE_NO_VALUE;
            pProfileInfo->RestrictGuestAccess[i] = SCE_NO_VALUE;
        }

        pProfileInfo->AuditSystemEvents = SCE_NO_VALUE;
        pProfileInfo->AuditLogonEvents = SCE_NO_VALUE;
        pProfileInfo->AuditObjectAccess = SCE_NO_VALUE;
        pProfileInfo->AuditPrivilegeUse = SCE_NO_VALUE;
        pProfileInfo->AuditPolicyChange = SCE_NO_VALUE;
        pProfileInfo->AuditAccountManage = SCE_NO_VALUE;
        pProfileInfo->AuditProcessTracking = SCE_NO_VALUE;
        pProfileInfo->AuditDSAccess = SCE_NO_VALUE;
        pProfileInfo->AuditAccountLogon = SCE_NO_VALUE;
        pProfileInfo->CrashOnAuditFull = SCE_NO_VALUE;

        if ( pProfileInfo->pKerberosInfo ) {
            pProfileInfo->pKerberosInfo->MaxTicketAge = SCE_NO_VALUE;
            pProfileInfo->pKerberosInfo->MaxRenewAge = SCE_NO_VALUE;
            pProfileInfo->pKerberosInfo->MaxServiceAge = SCE_NO_VALUE;
            pProfileInfo->pKerberosInfo->MaxClockSkew = SCE_NO_VALUE;
            pProfileInfo->pKerberosInfo->TicketValidateClient = SCE_NO_VALUE;
        }

        if ( pProfileInfo->RegValueCount && pProfileInfo->aRegValues ) {

            ScepFreeRegistryValues(&pProfileInfo->aRegValues,
                                   pProfileInfo->RegValueCount);
        }
        pProfileInfo->RegValueCount = 0;
        pProfileInfo->aRegValues = NULL;

        pProfileInfo->EnableAdminAccount = SCE_NO_VALUE;
        pProfileInfo->EnableGuestAccount = SCE_NO_VALUE;

        return(SCESTATUS_SUCCESS);

    } else {
        return(SCESTATUS_INVALID_PARAMETER);
    }

}



SCESTATUS
WINAPI
SceFreeProfileMemory(
    PSCE_PROFILE_INFO pProfile
    )
{
    if ( pProfile == NULL )
        return(SCESTATUS_SUCCESS);

    switch ( pProfile->Type ) {
    case SCE_ENGINE_SCP:
    case SCE_ENGINE_SAP:
    case SCE_ENGINE_SMP:
    case SCE_ENGINE_SCP_INTERNAL:
    case SCE_ENGINE_SMP_INTERNAL:
    case SCE_STRUCT_INF:

        SceFreeMemory((PVOID)pProfile, AREA_ALL);
        ScepFree(pProfile);

        break;
    default:
        return(SCESTATUS_INVALID_PARAMETER);
    }

    return(SCESTATUS_SUCCESS);
}



SCESTATUS
ScepFreePrivilege(
    IN PSCE_PRIVILEGE_ASSIGNMENT pRights
    )
{
    PSCE_PRIVILEGE_ASSIGNMENT  pTempRight;

    while ( pRights != NULL ) {

        if ( pRights->Name != NULL )
            ScepFree(pRights->Name);

        ScepFreeNameList(pRights->AssignedTo);

        pTempRight = pRights;
        pRights = pRights->Next;

        ScepFree( pTempRight );

    }
    return(SCESTATUS_SUCCESS);
}



SCESTATUS
ScepFreeObjectSecurity(
   IN PSCE_OBJECT_ARRAY pObject
   )
/* ++
Routine Description:

   This routine frees memory associated with ppObject.

Arguments:

   ppObject - buffer for object security

Return value:

   SCESTATUS_SUCCESS

-- */
{
    PSCE_OBJECT_SECURITY pCurObject;
    DWORD               i;

    if ( pObject == NULL )
        return(SCESTATUS_SUCCESS);

    for ( i=0; i<pObject->Count; i++ ) {
        pCurObject = pObject->pObjectArray[i];
        if ( pCurObject != NULL ) {

            if ( pCurObject->Name != NULL )
                ScepFree( pCurObject->Name );

            if ( pCurObject->pSecurityDescriptor != NULL )
                ScepFree(pCurObject->pSecurityDescriptor);

//            if ( pCurObject->SDspec != NULL )
//                ScepFree( pCurObject->SDspec );

            ScepFree( pCurObject );
        }
    }

    ScepFree(pObject);

    return(SCESTATUS_SUCCESS);
}

VOID
SceFreePSCE_SERVICES(
    IN PSCE_SERVICES pServiceList
    )
/*
Routine Description:

    Free memory allocated in PSCE_SERVICES structure

Arguments:

    pServiceList - the list of services node

Return Value:

    none
*/
{
    PSCE_SERVICES pTemp=pServiceList, pTemp2;

    while ( pTemp != NULL ) {
        //
        // ServiceName
        //
        if ( NULL != pTemp->ServiceName ) {
            LocalFree(pTemp->ServiceName);
        }
        //
        // display name
        //
        if ( NULL != pTemp->DisplayName ) {
            LocalFree(pTemp->DisplayName);
        }
        //
        // pSecurityDescriptor or ServiceEngineName
        // in same address
        //
        if ( NULL != pTemp->General.pSecurityDescriptor ) {
            LocalFree(pTemp->General.pSecurityDescriptor);
        }

        pTemp2 = pTemp;
        pTemp = pTemp->Next;

        // free the service node
        LocalFree(pTemp2);

    }

    return;
}



SCESTATUS
ScepFreePrivilegeValueList(
    IN PSCE_PRIVILEGE_VALUE_LIST pPrivValueList
    )
/* ++
Routine Description:

   This routine frees memory associated with PSCE_PRIVILEGE_VALUE_LIST list

Arguments:

   pPrivValueList - a PRIVILEGE_VALUE_LIST

Return value:

   SCESTATUS_SUCCESS

-- */
{
    PSCE_PRIVILEGE_VALUE_LIST pCurName;
    PSCE_PRIVILEGE_VALUE_LIST pTempName;
    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( pPrivValueList == NULL )
        return(rc);

    pCurName = pPrivValueList;
    while ( pCurName != NULL ) {
        if ( pCurName->Name != NULL )
            __try {
                ScepFree( pCurName->Name );
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                ASSERT(FALSE);
                rc = SCESTATUS_INVALID_PARAMETER;
            }

        pTempName = pCurName;
        pCurName = pCurName->Next;

        __try {
            ScepFree( pTempName );
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            ASSERT(FALSE);
            rc = SCESTATUS_INVALID_PARAMETER;
        }

    }
    return(rc);
}


SCESTATUS
ScepFreeNameStatusList(
    IN PSCE_NAME_STATUS_LIST pNameList
    )
/* ++
Routine Description:

   This routine frees memory associated with PSCE_NAME_STATUS_LIST pNameList

Arguments:

   pNameList - a NAME_STATUS_LIST

Return value:

   SCESTATUS_SUCCESS

-- */
{
    PSCE_NAME_STATUS_LIST pCurName;
    PSCE_NAME_STATUS_LIST pTempName;
    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( pNameList == NULL )
        return(rc);

    pCurName = pNameList;
    while ( pCurName != NULL ) {
        if ( pCurName->Name != NULL )
            __try {
                ScepFree( pCurName->Name );
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                ASSERT(FALSE);
                rc = SCESTATUS_INVALID_PARAMETER;
            }

        pTempName = pCurName;
        pCurName = pCurName->Next;

        __try {
            ScepFree( pTempName );
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            ASSERT(FALSE);
            rc = SCESTATUS_INVALID_PARAMETER;
        }

    }
    return(rc);
}


SCESTATUS
ScepFreeGroupMembership(
    IN PSCE_GROUP_MEMBERSHIP pGroup
    )
{
    PSCE_GROUP_MEMBERSHIP  pTempGroup;

    while ( pGroup != NULL ) {

        if (pGroup->GroupName != NULL)
            ScepFree(pGroup->GroupName);

        //
        // free group members name list
        //

        ScepFreeNameList(pGroup->pMembers);
        ScepFreeNameList(pGroup->pMemberOf);

        ScepFreeNameStatusList(pGroup->pPrivilegesHeld);

        pTempGroup = pGroup;
        pGroup = pGroup->Next;

        ScepFree( pTempGroup );
    }
    return(SCESTATUS_SUCCESS);

}



SCESTATUS
ScepFreeObjectList(
    IN PSCE_OBJECT_LIST pNameList
    )
/* ++
Routine Description:

   This routine frees memory associated with PSCE_OBJECT_LIST pNameList

Arguments:

   pNameList - a OBJEcT_LIST

Return value:

   SCESTATUS_SUCCESS

-- */
{
    PSCE_OBJECT_LIST pCurName;
    PSCE_OBJECT_LIST pTempName;
    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( pNameList == NULL )
        return(rc);

    pCurName = pNameList;
    while ( pCurName != NULL ) {
        if ( pCurName->Name != NULL )
            __try {
                ScepFree( pCurName->Name );
            } __except (EXCEPTION_EXECUTE_HANDLER) {
                ASSERT(FALSE);
                rc = SCESTATUS_INVALID_PARAMETER;
            }

        pTempName = pCurName;
        pCurName = pCurName->Next;

        __try {
            ScepFree( pTempName );
        } __except (EXCEPTION_EXECUTE_HANDLER) {
            ASSERT(FALSE);
            rc = SCESTATUS_INVALID_PARAMETER;
        }

    }
    return(rc);
}


SCESTATUS
ScepFreeObjectChildren(
    IN PSCE_OBJECT_CHILDREN pNameArray
    )
/* ++
Routine Description:

   This routine frees memory associated with PSCE_OBJECT_LIST pNameList

Arguments:

   pNameList - a OBJEcT_LIST

Return value:

   SCESTATUS_SUCCESS

-- */
{

    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( pNameArray == NULL )
        return(rc);

    rc = ScepFreeObjectChildrenNode(pNameArray->nCount,
                                    &(pNameArray->arrObject));

    ScepFree(pNameArray);

    return(rc);
}


SCESTATUS
ScepFreeObjectChildrenNode(
    IN DWORD Count,
    IN PSCE_OBJECT_CHILDREN_NODE *pArrObject
    )
{

    SCESTATUS      rc=SCESTATUS_SUCCESS;

    if ( NULL == pArrObject ) {
        return(rc);
    }

    DWORD          i;

    for ( i=0; i<Count;i++) {

        if ( pArrObject[i] ) {
            if ( pArrObject[i]->Name ) {

                ScepFree( pArrObject[i]->Name );
            }

            ScepFree(pArrObject[i]);
        }
    }

    return(rc);
}


SCESTATUS
SceSvcpFreeMemory(
    IN PVOID pvServiceInfo
    )
{
    //
    // since PSCESVC_CONFIGURATION_INFO and PSCESVC_ANALYSIS_INFO contains
    // the same bytes, we just cast ServiceInfo to one type and free it.
    //


    if ( pvServiceInfo != NULL ) {

        __try {

            for ( DWORD i=0; i<*((DWORD *)pvServiceInfo); i++ ) {

                if ( ((PSCESVC_ANALYSIS_INFO)pvServiceInfo)->Lines[i].Key ) {
                    ScepFree(((PSCESVC_ANALYSIS_INFO)pvServiceInfo)->Lines[i].Key);
                }
                if ( ((PSCESVC_ANALYSIS_INFO)pvServiceInfo)->Lines[i].Value ) {
                    ScepFree(((PSCESVC_ANALYSIS_INFO)pvServiceInfo)->Lines[i].Value);
                }

            }
            ScepFree(((PSCESVC_ANALYSIS_INFO)pvServiceInfo)->Lines);

            ScepFree(pvServiceInfo);

        } __except(EXCEPTION_EXECUTE_HANDLER) {

            ASSERT(FALSE);
            return(SCESTATUS_INVALID_PARAMETER);
        }

    }

    return(SCESTATUS_SUCCESS);

}