mirror of https://github.com/lianthony/NT4.0
1139 lines
36 KiB
1139 lines
36 KiB
/*++
|
|
|
|
Copyright (c) 1993 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
profile.c
|
|
|
|
Abstract:
|
|
|
|
Profile APIs.
|
|
|
|
Author:
|
|
|
|
Vladimir Z. Vulovic (vladimv) 19 - November - 1993
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "local.h"
|
|
#include "rpldb.h"
|
|
#include "db.h"
|
|
#include "dblib.h"
|
|
#include "config.h"
|
|
#include "wksta.h"
|
|
#define RPLPROFILE_ALLOCATE
|
|
#include "profile.h"
|
|
#undef RPLPROFILE_ALLOCATE
|
|
|
|
#define PROFILE_FLAGS_DISK_PRESENT_TRUE ((DWORD)0x00000001)
|
|
#define PROFILE_FLAGS_DISK_PRESENT_FALSE ((DWORD)0x00000002)
|
|
#define PROFILE_FLAGS_MASK_DISK_PRESENT \
|
|
( PROFILE_FLAGS_DISK_PRESENT_FALSE | \
|
|
PROFILE_FLAGS_DISK_PRESENT_TRUE )
|
|
|
|
|
|
|
|
DWORD ProfileGetField(
|
|
IN PRPL_SESSION pSession,
|
|
IN DWORD FieldIndex,
|
|
OUT LPVOID * pData,
|
|
IN OUT LPINT pSpaceLeft
|
|
)
|
|
{
|
|
BYTE LocalBuffer[ 300];
|
|
PBYTE Buffer;
|
|
DWORD DataSize;
|
|
DWORD BufferSize;
|
|
JET_ERR JetError;
|
|
|
|
switch( FieldIndex) {
|
|
case PROFILE_Flags:
|
|
Buffer = (PBYTE)pData;
|
|
BufferSize = sizeof( DWORD);
|
|
break;
|
|
default:
|
|
Buffer = LocalBuffer;
|
|
BufferSize = sizeof( LocalBuffer);
|
|
break;
|
|
}
|
|
JetError = JetRetrieveColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ FieldIndex].ColumnId, Buffer,
|
|
BufferSize, &DataSize, 0, NULL);
|
|
if ( JetError < 0) {
|
|
RplDump( ++RG_Assert, ( "JetError=%d", JetError));
|
|
return( NERR_RplProfileInfoCorrupted);
|
|
}
|
|
if ( Buffer != LocalBuffer) {
|
|
if ( BufferSize == DataSize) {
|
|
return( NO_ERROR);
|
|
} else {
|
|
RplDump( ++RG_Assert, ("Bad DataSize=0x%x", DataSize));
|
|
return( NERR_RplProfileInfoCorrupted);
|
|
}
|
|
}
|
|
//
|
|
// We have done with fixed data. From here on we deal with unicode
|
|
// strings only.
|
|
//
|
|
if ( DataSize > sizeof( LocalBuffer)) {
|
|
RplDump( ++RG_Assert, ( "Too big DataSize=0x%x", DataSize));
|
|
return( NERR_RplProfileInfoCorrupted);
|
|
}
|
|
if ( DataSize == 0) {
|
|
if ( JetError != JET_wrnColumnNull) {
|
|
RplDump( ++RG_Assert, ( "JetError=%d", JetError));
|
|
return( NERR_RplProfileInfoCorrupted);
|
|
} else {
|
|
*pData = NULL; // so RPC rpcrt4!_tree_size_ndr() does not bomb here
|
|
return( NO_ERROR);
|
|
}
|
|
}
|
|
if ( DataSize & 1 != 0 || wcslen((PWCHAR)LocalBuffer) + 1 != DataSize/2) {
|
|
RplDump( ++RG_Assert, ("LocalBuffer=0x%x, DataSize=0x%x", LocalBuffer, DataSize));
|
|
return( NERR_RplProfileInfoCorrupted);
|
|
}
|
|
*pData = MIDL_user_allocate( DataSize);
|
|
if ( *pData == NULL) {
|
|
RplDump( ++RG_Assert, ( "Error=%d", GetLastError()));
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
memcpy( *pData, LocalBuffer, DataSize);
|
|
*pSpaceLeft -= DataSize;
|
|
return( NO_ERROR);
|
|
}
|
|
|
|
|
|
DWORD ProfileGetInfo(
|
|
IN PRPL_SESSION pSession,
|
|
IN LPWSTR ProfileName,
|
|
IN DWORD Level,
|
|
OUT LPVOID Buffer,
|
|
OUT PINT pSpaceLeft
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPRPL_PROFILE_INFO_2 Info = Buffer;
|
|
|
|
switch( Level) {
|
|
case 2:
|
|
Error = ProfileGetField( pSession, PROFILE_FitPersonal, &Info->FitPersonal, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
Error = ProfileGetField( pSession, PROFILE_FitShared, &Info->FitShared, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
Error = ProfileGetField( pSession, PROFILE_BootName, &Info->BootName, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
Error = ProfileGetField( pSession, PROFILE_ConfigName, &Info->ConfigName, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
NOTHING; // fall through
|
|
case 1:
|
|
Error = ProfileGetField( pSession, PROFILE_Flags, (LPVOID *)&Info->Flags, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
NOTHING; // fall through
|
|
case 0:
|
|
Error = ProfileGetField( pSession, PROFILE_ProfileComment, &Info->ProfileComment, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
if ( ProfileName == NULL) {
|
|
Error = ProfileGetField( pSession, PROFILE_ProfileName, &Info->ProfileName, pSpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
return( Error);
|
|
}
|
|
} else {
|
|
DWORD DataSize = (wcslen( ProfileName) + 1) * sizeof(WCHAR);
|
|
Info->ProfileName = MIDL_user_allocate( DataSize);
|
|
if ( Info->ProfileName == NULL) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
RplDump( RG_DebugLevel & RPL_DEBUG_PROFILE, ( "ProfileName=0x%x", Info->ProfileName));
|
|
memcpy( Info->ProfileName, ProfileName, DataSize);
|
|
*pSpaceLeft -= DataSize;
|
|
}
|
|
break;
|
|
default:
|
|
return( ERROR_INVALID_LEVEL);
|
|
break;
|
|
}
|
|
return( NO_ERROR);
|
|
}
|
|
|
|
|
|
|
|
VOID ProfileGetInfoCleanup(
|
|
IN DWORD Level,
|
|
IN OUT LPVOID Buffer
|
|
)
|
|
{
|
|
LPRPL_PROFILE_INFO_2 Info = Buffer;
|
|
|
|
if ( Info == NULL) {
|
|
return;
|
|
}
|
|
switch( Level) {
|
|
case 2:
|
|
if ( Info->FitPersonal != NULL) {
|
|
MIDL_user_free( Info->FitPersonal);
|
|
}
|
|
if ( Info->FitShared != NULL) {
|
|
MIDL_user_free( Info->FitShared);
|
|
}
|
|
if ( Info->BootName != NULL) {
|
|
MIDL_user_free( Info->BootName);
|
|
}
|
|
if ( Info->ConfigName != NULL) {
|
|
MIDL_user_free( Info->ConfigName);
|
|
}
|
|
NOTHING; // fall through
|
|
case 1:
|
|
NOTHING; // fall through
|
|
case 0:
|
|
if ( Info->ProfileComment != NULL) {
|
|
MIDL_user_free( Info->ProfileComment);
|
|
}
|
|
if ( Info->ProfileName != NULL) {
|
|
MIDL_user_free( Info->ProfileName);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileEnum(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN LPWSTR AdapterName,
|
|
IN OUT LPRPL_PROFILE_ENUM ProfileEnum,
|
|
IN DWORD PrefMaxLength,
|
|
OUT LPDWORD TotalEntries,
|
|
IN OUT LPDWORD pResumeHandle OPTIONAL
|
|
)
|
|
/*++
|
|
For more extensive comments see related code in NetrConfigEnum.
|
|
--*/
|
|
{
|
|
LPBYTE Buffer;
|
|
DWORD TypicalSize;
|
|
DWORD CoreSize;
|
|
DWORD Error;
|
|
INT SpaceLeft;
|
|
DWORD ArrayLength;
|
|
DWORD EntriesRead;
|
|
BOOL InfoError;
|
|
BOOL TableEnd;
|
|
RPL_FILTER Filter;
|
|
PRPL_FILTER pFilter;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
switch( ProfileEnum->Level) {
|
|
case 2:
|
|
TypicalSize = CoreSize = sizeof( RPL_PROFILE_INFO_2);
|
|
TypicalSize += 20 * sizeof( WCHAR); // typical size of FitPersonal
|
|
TypicalSize += 20 * sizeof( WCHAR); // typical size of FitShared
|
|
TypicalSize += 8 * sizeof( WCHAR); // typical size of BootName
|
|
TypicalSize += 8 * sizeof( WCHAR); // typical size of ConfigName
|
|
NOTHING; // fall through
|
|
case 1:
|
|
if ( ProfileEnum->Level == 1) {
|
|
TypicalSize = CoreSize = sizeof( RPL_PROFILE_INFO_1);
|
|
}
|
|
NOTHING; // fall through
|
|
case 0:
|
|
if ( ProfileEnum->Level == 0) {
|
|
TypicalSize = CoreSize = sizeof( RPL_PROFILE_INFO_0);
|
|
}
|
|
TypicalSize += 20 * sizeof( WCHAR); // typical size of ProfileComment
|
|
TypicalSize += 8 * sizeof( WCHAR); // typical size of ProfileName
|
|
break;
|
|
default:
|
|
return( ERROR_INVALID_LEVEL);
|
|
break;
|
|
}
|
|
|
|
if ( AdapterName != NULL) {
|
|
pFilter = &Filter;
|
|
if ( !ValidHexName( AdapterName, RPL_ADAPTER_NAME_LENGTH, TRUE)) {
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
AdapterName[ 6] = 0; // truncate all but first 6 digits
|
|
pFilter->VendorId = wcstoul( AdapterName, NULL, 16);
|
|
pFilter->FindFirst = TRUE;
|
|
} else {
|
|
pFilter = NULL;
|
|
}
|
|
|
|
if ( PrefMaxLength == -1) {
|
|
SpaceLeft = DEFAULT_BUFFER_SIZE;
|
|
} else {
|
|
SpaceLeft = PrefMaxLength;
|
|
}
|
|
|
|
ArrayLength = SpaceLeft / TypicalSize;
|
|
if ( ArrayLength == 0) {
|
|
ArrayLength = 1; // try to return at least one element
|
|
}
|
|
|
|
Buffer = MIDL_user_allocate( ArrayLength * CoreSize);
|
|
if ( Buffer == NULL) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
RplDump( RG_DebugLevel & RPL_DEBUG_PROFILE, (
|
|
"ProfileEnum: Buffer=0x%x, ArrayLength=0x%x", Buffer, ArrayLength));
|
|
|
|
ProfileEnum->ProfileInfo.Level0->Buffer = (LPRPL_PROFILE_INFO_0)Buffer;
|
|
|
|
EntriesRead = 0;
|
|
InfoError = FALSE;
|
|
Error = NO_ERROR;
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( !RplFilterFirst( pSession, PROFILE_TABLE_TAG, pFilter, pResumeHandle, &TableEnd)) {
|
|
Error = NERR_RplCannotEnum;
|
|
goto cleanup;
|
|
}
|
|
if ( TableEnd == TRUE) {
|
|
goto cleanup;
|
|
}
|
|
for ( ; ; ) {
|
|
memset( Buffer, 0, CoreSize); // for cleanup to work properly
|
|
Error = ProfileGetInfo( pSession, NULL, ProfileEnum->Level, Buffer, &SpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
InfoError = TRUE; // clean things up without holding crit sec
|
|
break;
|
|
}
|
|
EntriesRead++;
|
|
Buffer += CoreSize;
|
|
SpaceLeft -= CoreSize;
|
|
if ( !RplFilterNext( pSession, pSession->ProfileTableId, pFilter, &TableEnd)) {
|
|
Error = NERR_RplCannotEnum;
|
|
goto cleanup;
|
|
}
|
|
if ( TableEnd == TRUE) {
|
|
goto cleanup;
|
|
}
|
|
if ( SpaceLeft <= 0) {
|
|
Error = ERROR_MORE_DATA;
|
|
break;
|
|
}
|
|
if ( EntriesRead >= ArrayLength) {
|
|
Error = ERROR_MORE_DATA;
|
|
break;
|
|
}
|
|
}
|
|
cleanup:
|
|
Call( JetCommitTransaction( pSession->SesId, 0));
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
if ( InfoError == TRUE) {
|
|
ProfileGetInfoCleanup( ProfileEnum->Level, Buffer);
|
|
}
|
|
if ( Error == NO_ERROR) {
|
|
*TotalEntries = EntriesRead;
|
|
} else if ( Error == ERROR_MORE_DATA) {
|
|
*TotalEntries = EntriesRead * 2; // we cheat here
|
|
} else {
|
|
//
|
|
// Cleanup in case of "bad" errors.
|
|
//
|
|
while ( EntriesRead > 0) {
|
|
EntriesRead--;
|
|
Buffer -= CoreSize;
|
|
ProfileGetInfoCleanup( ProfileEnum->Level, Buffer);
|
|
}
|
|
MIDL_user_free( Buffer);
|
|
}
|
|
|
|
RplDump( RG_DebugLevel & RPL_DEBUG_PROFILE, ("ProfileEnum: EntriesRead = 0x%x", EntriesRead));
|
|
|
|
ProfileEnum->ProfileInfo.Level0->EntriesRead = EntriesRead;
|
|
if ( EntriesRead == 0) {
|
|
ProfileEnum->ProfileInfo.Level0->Buffer = NULL;
|
|
}
|
|
|
|
if ( ARGUMENT_PRESENT( pResumeHandle)) {
|
|
if ( Error == ERROR_MORE_DATA && EntriesRead > 0) {
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
RplFilterSave( pSession, (DWORD)ServerHandle, pFilter,
|
|
((LPRPL_PROFILE_INFO_0)(Buffer-CoreSize))->ProfileName,
|
|
pResumeHandle);
|
|
Call( JetCommitTransaction( pSession->SesId, 0));
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
} else {
|
|
*pResumeHandle = 0; // resume from beginning
|
|
}
|
|
}
|
|
|
|
return( Error);
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileGetInfo(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN LPWSTR ProfileName,
|
|
IN DWORD Level,
|
|
OUT LPRPL_PROFILE_INFO_STRUCT ProfileInfoStruct
|
|
)
|
|
{
|
|
DWORD Error;
|
|
LPBYTE Buffer;
|
|
INT SpaceLeft;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
_wcsupr( ProfileName);
|
|
|
|
switch( Level) {
|
|
case 0:
|
|
Buffer = MIDL_user_allocate( sizeof( RPL_PROFILE_INFO_0));
|
|
if ( Buffer == NULL) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
memset( Buffer, 0, sizeof( RPL_PROFILE_INFO_0));
|
|
ProfileInfoStruct->ProfileInfo0 = (LPRPL_PROFILE_INFO_0)Buffer;
|
|
break;
|
|
case 1:
|
|
Buffer = MIDL_user_allocate( sizeof( RPL_PROFILE_INFO_1));
|
|
if ( Buffer == NULL) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
memset( Buffer, 0, sizeof( RPL_PROFILE_INFO_1));
|
|
ProfileInfoStruct->ProfileInfo1 = (LPRPL_PROFILE_INFO_1)Buffer;
|
|
break;
|
|
case 2:
|
|
Buffer = MIDL_user_allocate( sizeof( RPL_PROFILE_INFO_2));
|
|
if ( Buffer == NULL) {
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
memset( Buffer, 0, sizeof( RPL_PROFILE_INFO_2));
|
|
ProfileInfoStruct->ProfileInfo2 = (LPRPL_PROFILE_INFO_2)Buffer;
|
|
break;
|
|
default:
|
|
return( ERROR_INVALID_LEVEL);
|
|
break;
|
|
}
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, ProfileName)) {
|
|
Error = NERR_RplProfileNotFound;
|
|
} else {
|
|
Error = ProfileGetInfo( pSession, ProfileName, Level, Buffer, &SpaceLeft);
|
|
}
|
|
|
|
Call( JetCommitTransaction( pSession->SesId, 0));
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
|
|
if ( Error != NO_ERROR) {
|
|
ProfileGetInfoCleanup( Level, Buffer);
|
|
switch( Level) {
|
|
case 0:
|
|
MIDL_user_free( Buffer);
|
|
ProfileInfoStruct->ProfileInfo0 = NULL;
|
|
break;
|
|
case 1:
|
|
MIDL_user_free( Buffer);
|
|
ProfileInfoStruct->ProfileInfo1 = NULL;
|
|
break;
|
|
}
|
|
}
|
|
return( Error);
|
|
}
|
|
|
|
|
|
DWORD ProfileSetField(
|
|
IN PRPL_SESSION pSession,
|
|
IN DWORD FieldIndex,
|
|
IN LPVOID Data,
|
|
IN DWORD DataSize
|
|
)
|
|
{
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ FieldIndex].ColumnId, Data, DataSize, 0, NULL));
|
|
return( NO_ERROR);
|
|
}
|
|
|
|
|
|
DWORD ProfileSetInfo(
|
|
IN PRPL_SESSION pSession,
|
|
IN DWORD Level,
|
|
OUT LPVOID Buffer,
|
|
OUT LPDWORD pErrorParameter
|
|
)
|
|
{
|
|
LPRPL_PROFILE_INFO_2 Info = Buffer;
|
|
switch( Level) {
|
|
case 2:
|
|
if ( Info->FitPersonal != NULL) {
|
|
*pErrorParameter = PROFILE_FitPersonal;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_FitPersonal].ColumnId,
|
|
Info->FitPersonal,
|
|
( wcslen( Info->FitPersonal) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
if ( Info->FitShared != NULL) {
|
|
*pErrorParameter = PROFILE_FitShared;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_FitShared].ColumnId,
|
|
Info->FitShared,
|
|
( wcslen( Info->FitShared) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
if ( Info->BootName != NULL) {
|
|
*pErrorParameter = PROFILE_BootName;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_BootName].ColumnId,
|
|
Info->BootName,
|
|
( wcslen( Info->BootName) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
if ( Info->ConfigName != NULL) {
|
|
*pErrorParameter = PROFILE_ConfigName;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_ConfigName].ColumnId,
|
|
Info->ConfigName,
|
|
( wcslen( Info->ConfigName) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
NOTHING; // fall through
|
|
case 1:
|
|
if ( Info->Flags != 0) {
|
|
*pErrorParameter = PROFILE_Flags;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_Flags].ColumnId,
|
|
&Info->Flags, sizeof( Info->Flags), 0, NULL));
|
|
}
|
|
NOTHING; // fall through
|
|
case 0:
|
|
if ( Info->ProfileComment != NULL) {
|
|
*pErrorParameter = PROFILE_ProfileComment;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_ProfileComment].ColumnId,
|
|
Info->ProfileComment,
|
|
( wcslen( Info->ProfileComment) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
if ( Info->ProfileName != NULL) {
|
|
*pErrorParameter = PROFILE_ProfileName;
|
|
CallM( JetSetColumn( pSession->SesId, pSession->ProfileTableId,
|
|
ProfileTable[ PROFILE_ProfileName].ColumnId,
|
|
Info->ProfileName,
|
|
( wcslen( Info->ProfileName) + 1) * sizeof(WCHAR),
|
|
0, NULL));
|
|
}
|
|
break;
|
|
}
|
|
return( NO_ERROR);
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileSetInfo(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN LPWSTR ProfileName,
|
|
IN DWORD Level,
|
|
IN LPRPL_PROFILE_INFO_STRUCT ProfileInfoStruct,
|
|
OUT LPDWORD pErrorParameter OPTIONAL
|
|
)
|
|
/*++
|
|
If parameter pointer is NULL, then we do not change such parameters.
|
|
If parameter non-pointer has a special value, then we do not change
|
|
such parameters.
|
|
|
|
Some parameters cannot be changed for now. If caller deos not specify
|
|
a no-change value for such a parameter, we print a warning message &
|
|
pretend we received a no change value.
|
|
--*/
|
|
{
|
|
DWORD Error;
|
|
DWORD SpaceLeft;
|
|
DWORD ErrorParameter;
|
|
LPVOID Buffer;
|
|
LPRPL_PROFILE_INFO_2 Info;
|
|
PWCHAR ConfigName;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
ErrorParameter = INVALID_ERROR_PARAMETER;
|
|
ConfigName = NULL;
|
|
_wcsupr( ProfileName);
|
|
|
|
Info = Buffer = ProfileInfoStruct->ProfileInfo2;
|
|
switch( Level) {
|
|
case 2:
|
|
if ( !ValidName( Info->FitPersonal, RPL_MAX_STRING_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_FitPersonal;
|
|
break;
|
|
}
|
|
if ( !ValidName( Info->FitShared, RPL_MAX_STRING_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_FitShared;
|
|
break;
|
|
}
|
|
if ( !ValidName( Info->BootName, RPL_MAX_BOOT_NAME_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_BootName;
|
|
break;
|
|
}
|
|
if ( Info->BootName != NULL) {
|
|
_wcsupr( Info->BootName);
|
|
}
|
|
if ( !ValidName( Info->ConfigName, RPL_MAX_CONFIG_NAME_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_ConfigName;
|
|
break;
|
|
}
|
|
if ( Info->ConfigName != NULL) {
|
|
_wcsupr( Info->ConfigName);
|
|
}
|
|
NOTHING; // fall through
|
|
case 1:
|
|
switch( Info->Flags) {
|
|
case PROFILE_FLAGS_DISK_PRESENT_TRUE:
|
|
case PROFILE_FLAGS_DISK_PRESENT_FALSE:
|
|
Info->Flags = 0;
|
|
NOTHING; // fall through
|
|
case 0:
|
|
break;
|
|
default:
|
|
ErrorParameter = PROFILE_Flags;
|
|
break;
|
|
}
|
|
if ( ErrorParameter != INVALID_ERROR_PARAMETER) {
|
|
break;
|
|
}
|
|
NOTHING; // fall through
|
|
case 0:
|
|
if ( RPL_STRING_TOO_LONG( Info->ProfileComment)) {
|
|
ErrorParameter = PROFILE_ProfileComment;
|
|
break;
|
|
}
|
|
if ( Info->ProfileName != NULL) {
|
|
_wcsupr( Info->ProfileName);
|
|
if ( wcscmp( Info->ProfileName, ProfileName)) {
|
|
RplDump( ++RG_Assert, ("Change of ProfileName not supported yet."));
|
|
ErrorParameter = PROFILE_ProfileName;
|
|
break;
|
|
}
|
|
MIDL_user_free( Info->ProfileName);
|
|
Info->ProfileName = NULL;
|
|
}
|
|
break;
|
|
default:
|
|
return( ERROR_INVALID_LEVEL);
|
|
break;
|
|
}
|
|
|
|
if ( ErrorParameter != INVALID_ERROR_PARAMETER) {
|
|
if ( ARGUMENT_PRESENT( pErrorParameter)) {
|
|
*pErrorParameter = ErrorParameter;
|
|
}
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
ErrorParameter = 0;
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, ProfileName)) {
|
|
Error = NERR_RplProfileNotFound;
|
|
goto cleanup;
|
|
}
|
|
|
|
if ( Info->ConfigName != NULL) {
|
|
Error = ProfileGetField( pSession, PROFILE_ConfigName, &ConfigName, &SpaceLeft);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
if ( wcscmp( Info->ConfigName, ConfigName)) {
|
|
RplDump( ++RG_Assert, ("Change of ConfigName not supported yet."));
|
|
ErrorParameter = PROFILE_ConfigName;
|
|
Error = ERROR_INVALID_PARAMETER;
|
|
goto cleanup;
|
|
}
|
|
MIDL_user_free( Info->ConfigName);
|
|
Info->ConfigName = NULL;
|
|
}
|
|
|
|
CallJ( JetPrepareUpdate( pSession->SesId, pSession->ProfileTableId, JET_prepReplace));
|
|
|
|
Error = ProfileSetInfo( pSession, Level, Buffer, &ErrorParameter);
|
|
if ( Error != ERROR_SUCCESS) {
|
|
goto cleanup;
|
|
}
|
|
|
|
ErrorParameter = 0;
|
|
CallJ( JetUpdate( pSession->SesId, pSession->ProfileTableId, NULL, 0, NULL));
|
|
|
|
cleanup:
|
|
if ( Error == NO_ERROR) {
|
|
Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
|
|
} else {
|
|
Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
|
|
}
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
|
|
if ( ConfigName != NULL) {
|
|
MIDL_user_free( ConfigName);
|
|
}
|
|
if ( Error != ERROR_SUCCESS) {
|
|
if ( ARGUMENT_PRESENT( pErrorParameter)) {
|
|
*pErrorParameter = ErrorParameter;
|
|
}
|
|
}
|
|
return( Error);
|
|
}
|
|
|
|
|
|
DWORD AddFileExtension(
|
|
IN PWCHAR * pFilePath,
|
|
IN PWCHAR FileExtension,
|
|
IN BOOLEAN ExtensionOK
|
|
)
|
|
{
|
|
#define DOT_CHAR L'.'
|
|
#define BACK_SLASH_CHAR L'\\'
|
|
PWCHAR FilePathEx;
|
|
PWCHAR pDot;
|
|
DWORD Length;
|
|
|
|
if ( *pFilePath == NULL) {
|
|
RPL_RETURN( NERR_RplConfigInfoCorrupted);
|
|
}
|
|
|
|
pDot = wcsrchr( *pFilePath, DOT_CHAR);
|
|
if ( pDot != NULL) {
|
|
//
|
|
// Found a DOT. FilePath may have an extension.
|
|
//
|
|
if ( wcschr( pDot, BACK_SLASH_CHAR) == NULL) {
|
|
//
|
|
// There is no backslash after the DOT. FilePath has an
|
|
// extension. Return error if caller insists that file
|
|
// should have no extension.
|
|
//
|
|
if ( !ExtensionOK) {
|
|
RPL_RETURN( NERR_RplConfigInfoCorrupted);
|
|
}
|
|
return( NO_ERROR);
|
|
}
|
|
}
|
|
Length = wcslen( *pFilePath) + wcslen( FileExtension);
|
|
FilePathEx = MIDL_user_allocate( (Length + 1) * sizeof(WCHAR));
|
|
if ( FilePathEx == NULL) {
|
|
RplDump( ++RG_Assert, ( "Error=%d", GetLastError()));
|
|
return( ERROR_NOT_ENOUGH_MEMORY);
|
|
}
|
|
wcscpy( FilePathEx, *pFilePath);
|
|
wcscat( FilePathEx, FileExtension);
|
|
MIDL_user_free( *pFilePath);
|
|
*pFilePath = FilePathEx;
|
|
return( NO_ERROR);
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileAdd(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN DWORD Level,
|
|
OUT LPRPL_PROFILE_INFO_STRUCT ProfileInfoStruct,
|
|
OUT LPDWORD pErrorParameter OPTIONAL
|
|
)
|
|
{
|
|
LPRPL_PROFILE_INFO_2 Info;
|
|
LPVOID Buffer;
|
|
DWORD Error;
|
|
DWORD ErrorParameter;
|
|
DWORD DataSize;
|
|
BOOL FreeBootName = FALSE;
|
|
BOOL FreeFitShared = FALSE;
|
|
BOOL FreeFitPersonal = FALSE;
|
|
PWCHAR DirName = NULL;
|
|
PWCHAR DirName2 = NULL;
|
|
PWCHAR DirName3 = NULL;
|
|
PWCHAR DirName4 = NULL;
|
|
JET_ERR JetError;
|
|
BOOL DiskDelete = FALSE;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
ErrorParameter = INVALID_ERROR_PARAMETER;
|
|
Buffer = Info = ProfileInfoStruct->ProfileInfo2;
|
|
switch( Level) {
|
|
case 2:
|
|
if ( !ValidName( Info->FitPersonal, RPL_MAX_STRING_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_FitPersonal;
|
|
break;
|
|
}
|
|
if ( !ValidName( Info->FitShared, RPL_MAX_STRING_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_FitShared;
|
|
break;
|
|
}
|
|
if ( !ValidName( Info->BootName, RPL_MAX_BOOT_NAME_LENGTH, FALSE)) {
|
|
ErrorParameter = PROFILE_BootName;
|
|
break;
|
|
}
|
|
if ( Info->BootName != NULL) {
|
|
_wcsupr( Info->BootName);
|
|
}
|
|
if ( !ValidName( Info->ConfigName, RPL_MAX_CONFIG_NAME_LENGTH, TRUE)) {
|
|
ErrorParameter = PROFILE_ConfigName;
|
|
break;
|
|
}
|
|
_wcsupr( Info->ConfigName);
|
|
if ( Info->Flags != 0) {
|
|
ErrorParameter = PROFILE_Flags;
|
|
break;
|
|
}
|
|
if ( RPL_STRING_TOO_LONG( Info->ProfileComment)) {
|
|
ErrorParameter = PROFILE_ProfileComment;
|
|
break;
|
|
}
|
|
if ( !ValidName( Info->ProfileName, RPL_MAX_PROFILE_NAME_LENGTH, TRUE)) {
|
|
ErrorParameter = PROFILE_ProfileName;
|
|
break;
|
|
}
|
|
_wcsupr( Info->ProfileName);
|
|
break;
|
|
default:
|
|
return( ERROR_INVALID_LEVEL);
|
|
break;
|
|
}
|
|
|
|
if ( ErrorParameter != INVALID_ERROR_PARAMETER) {
|
|
if ( ARGUMENT_PRESENT( pErrorParameter)) {
|
|
*pErrorParameter = ErrorParameter;
|
|
}
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( !RplFind( pSession, CONFIG_TABLE_TAG, Info->ConfigName)) {
|
|
Error = NERR_RplConfigNotFound;
|
|
goto cleanup;
|
|
}
|
|
// BUGBUG Should make sure CONFIG is enabled
|
|
if ( Info->BootName == NULL) {
|
|
Error = ConfigGetField( pSession, CONFIG_BootName, &Info->BootName, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
FreeBootName = TRUE;
|
|
}
|
|
if ( Info->FitShared == NULL) {
|
|
Error = ConfigGetField( pSession, CONFIG_FitShared, &Info->FitShared, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
FreeFitShared = TRUE;
|
|
Error = AddFileExtension( &Info->FitShared, L".FIT", TRUE);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
if ( Info->FitPersonal == NULL) {
|
|
Error = ConfigGetField( pSession, CONFIG_FitPersonal, &Info->FitPersonal, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
FreeFitPersonal = TRUE;
|
|
Error = AddFileExtension( &Info->FitPersonal, L".FIT", TRUE);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
}
|
|
Error = ConfigGetField( pSession, CONFIG_DirName, &DirName, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
Error = ConfigGetField( pSession, CONFIG_DirName2, &DirName2, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
Error = ConfigGetField( pSession, CONFIG_DirName3, &DirName3, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
Error = ConfigGetField( pSession, CONFIG_DirName4, &DirName4, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
//
|
|
// The call to ProfileSetInfo() will add PROFILE record to the database.
|
|
// The call may succeed but we may still fail to do the treecopy
|
|
// operations below. We can detect this situation any time later on
|
|
// by the value of the Flags bit.
|
|
//
|
|
Info->Flags = PROFILE_FLAGS_DISK_PRESENT_FALSE;
|
|
|
|
CallJ( JetPrepareUpdate( pSession->SesId, pSession->ProfileTableId, JET_prepInsert));
|
|
|
|
Error = ProfileSetInfo( pSession, 2, Buffer, &ErrorParameter);
|
|
if ( Error != ERROR_SUCCESS) {
|
|
goto cleanup;
|
|
}
|
|
ErrorParameter = 0;
|
|
JetError = JetUpdate( pSession->SesId, pSession->ProfileTableId, NULL, 0, NULL);
|
|
if ( JetError < 0) {
|
|
if ( JetError == JET_errKeyDuplicate) {
|
|
Error = NERR_RplProfileNameUnavailable;
|
|
} else {
|
|
RplDump( ++RG_Assert, ("JetError=%d", JetError));
|
|
Error = NERR_RplInternal;
|
|
}
|
|
goto cleanup;
|
|
}
|
|
|
|
DiskDelete = TRUE; // just in case we fail before we are done
|
|
Error = ProfileDiskAdd( TRUE, Info->ProfileName, DirName, DirName2,
|
|
DirName3, DirName4);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, Info->ProfileName)) {
|
|
Error = NERR_RplInternal;
|
|
goto cleanup;
|
|
}
|
|
CallJ( JetPrepareUpdate( pSession->SesId, pSession->ProfileTableId, JET_prepReplace));
|
|
Info->Flags = PROFILE_FLAGS_DISK_PRESENT_TRUE;
|
|
Error = ProfileSetField( pSession, PROFILE_Flags, &Info->Flags, sizeof(Info->Flags));
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
JetError = JetUpdate( pSession->SesId, pSession->ProfileTableId, NULL, 0, NULL);
|
|
if ( JetError < 0) {
|
|
RplDump( ++RG_Assert, ("JetError=%d", JetError));
|
|
Error = NERR_RplInternal;
|
|
goto cleanup;
|
|
}
|
|
DiskDelete = FALSE; // success, make sure we do not delete disk data
|
|
|
|
cleanup:
|
|
if ( DiskDelete == TRUE) {
|
|
//
|
|
// ProfileDiskAdd deletion code does not care about DirName*
|
|
//
|
|
ProfileDiskAdd( FALSE, Info->ProfileName, NULL, NULL, NULL, NULL);
|
|
}
|
|
if ( Error == NO_ERROR) {
|
|
Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
|
|
} else {
|
|
Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
|
|
}
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
|
|
if ( FreeBootName == TRUE) {
|
|
MIDL_user_free( Info->BootName);
|
|
Info->BootName = NULL;
|
|
}
|
|
if ( FreeFitShared == TRUE) {
|
|
MIDL_user_free( Info->FitShared);
|
|
Info->FitShared = NULL;
|
|
}
|
|
if ( FreeFitPersonal == TRUE) {
|
|
MIDL_user_free( Info->FitPersonal);
|
|
Info->FitPersonal = NULL;
|
|
}
|
|
if ( DirName != NULL) {
|
|
MIDL_user_free( DirName);
|
|
}
|
|
if ( DirName2 != NULL) {
|
|
MIDL_user_free( DirName2);
|
|
}
|
|
if ( DirName3 != NULL) {
|
|
MIDL_user_free( DirName3);
|
|
}
|
|
if ( DirName4 != NULL) {
|
|
MIDL_user_free( DirName4);
|
|
}
|
|
if ( Error != ERROR_SUCCESS) {
|
|
if ( ARGUMENT_PRESENT( pErrorParameter)) {
|
|
*pErrorParameter = ErrorParameter;
|
|
}
|
|
}
|
|
return( Error);
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileDel(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN LPWSTR ProfileName
|
|
)
|
|
{
|
|
DWORD Error;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
_wcsupr( ProfileName);
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( RplFindByField( pSession, WKSTA_TABLE_TAG,
|
|
WKSTA_INDEX_ProfileNameWkstaName, ProfileName)) {
|
|
//
|
|
// We found a WKSTA record which uses this PROFILE.
|
|
//
|
|
Error = NERR_RplProfileNotEmpty;
|
|
goto cleanup;
|
|
}
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, ProfileName)) {
|
|
Error = NERR_RplProfileNotFound;
|
|
goto cleanup;
|
|
}
|
|
CallJ( JetDelete( pSession->SesId, pSession->ProfileTableId));
|
|
ProfileDiskAdd( FALSE, ProfileName, NULL, NULL, NULL, NULL);
|
|
Error = NO_ERROR;
|
|
|
|
cleanup:
|
|
if ( Error == NO_ERROR) {
|
|
Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
|
|
} else {
|
|
Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
|
|
}
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
return( Error);
|
|
}
|
|
|
|
|
|
NET_API_STATUS NET_API_FUNCTION
|
|
NetrRplProfileClone(
|
|
IN RPL_HANDLE ServerHandle,
|
|
IN LPWSTR SourceProfileName,
|
|
IN LPWSTR TargetProfileName,
|
|
IN LPWSTR TargetProfileComment
|
|
)
|
|
{
|
|
RPL_PROFILE_INFO_2 Info;
|
|
DWORD Error;
|
|
DWORD ErrorParameter;
|
|
DWORD DataSize;
|
|
PWCHAR SaveProfileName;
|
|
PWCHAR SaveProfileComment;
|
|
JET_ERR JetError;
|
|
BOOL DiskDelete = FALSE;
|
|
PRPL_SESSION pSession = &RG_ApiSession;
|
|
|
|
if ( !ValidName( SourceProfileName, RPL_MAX_PROFILE_NAME_LENGTH, TRUE)) {
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
_wcsupr( SourceProfileName);
|
|
if ( !ValidName( TargetProfileName, RPL_MAX_PROFILE_NAME_LENGTH, TRUE)) {
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
_wcsupr( TargetProfileName);
|
|
if ( RPL_STRING_TOO_LONG( TargetProfileComment)) {
|
|
return( ERROR_INVALID_PARAMETER);
|
|
}
|
|
|
|
//
|
|
// Zero all the pointers so we can safely call ProfileGetInfoCleanup().
|
|
// in all the cases.
|
|
//
|
|
memset( &Info, 0, sizeof( Info));
|
|
|
|
EnterCriticalSection( &RG_ProtectDatabase);
|
|
Call( JetBeginTransaction( pSession->SesId));
|
|
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, SourceProfileName)) {
|
|
Error = NERR_RplProfileNotFound;
|
|
goto cleanup;
|
|
}
|
|
Error = ProfileGetInfo( pSession, SourceProfileName, 2, &Info, &DataSize);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
//
|
|
// Save source data, then overload target data.
|
|
//
|
|
SaveProfileName = Info.ProfileName;
|
|
SaveProfileComment = Info.ProfileComment;
|
|
Info.ProfileName = TargetProfileName;
|
|
Info.ProfileComment = TargetProfileComment;
|
|
|
|
//
|
|
// The call to ProfileSetInfo() will add PROFILE record to the database.
|
|
// The call may succeed but we may still fail to do the treecopy
|
|
// operations below. We can detect this situation any time later on
|
|
// by the value of the Flags bit.
|
|
//
|
|
Info.Flags = PROFILE_FLAGS_DISK_PRESENT_FALSE;
|
|
|
|
CallJ( JetPrepareUpdate( pSession->SesId, pSession->ProfileTableId, JET_prepInsert));
|
|
|
|
Error = ProfileSetInfo( pSession, 2, &Info, &ErrorParameter);
|
|
if ( Error != ERROR_SUCCESS) {
|
|
goto cleanup;
|
|
}
|
|
ErrorParameter = 0;
|
|
JetError = JetUpdate( pSession->SesId, pSession->ProfileTableId, NULL, 0, NULL);
|
|
if ( JetError < 0) {
|
|
if ( JetError == JET_errKeyDuplicate) {
|
|
Error = NERR_RplProfileNameUnavailable;
|
|
} else {
|
|
RplDump( ++RG_Assert, ("JetError=%d", JetError));
|
|
Error = NERR_RplInternal;
|
|
}
|
|
goto cleanup;
|
|
}
|
|
|
|
DiskDelete = TRUE; // just in case we fail before we are done
|
|
Error = ProfileDiskClone( TRUE, SourceProfileName, TargetProfileName);
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
if ( !RplFind( pSession, PROFILE_TABLE_TAG, TargetProfileName)) {
|
|
Error = NERR_RplInternal;
|
|
goto cleanup;
|
|
}
|
|
CallJ( JetPrepareUpdate( pSession->SesId, pSession->ProfileTableId, JET_prepReplace));
|
|
Info.Flags = PROFILE_FLAGS_DISK_PRESENT_TRUE;
|
|
Error = ProfileSetField( pSession, PROFILE_Flags, &Info.Flags, sizeof(Info.Flags));
|
|
if ( Error != NO_ERROR) {
|
|
goto cleanup;
|
|
}
|
|
JetError = JetUpdate( pSession->SesId, pSession->ProfileTableId, NULL, 0, NULL);
|
|
if ( JetError < 0) {
|
|
RplDump( ++RG_Assert, ("JetError=%d", JetError));
|
|
Error = NERR_RplInternal;
|
|
goto cleanup;
|
|
}
|
|
DiskDelete = FALSE; // success, make sure we do not delete disk data
|
|
|
|
cleanup:
|
|
if ( DiskDelete == TRUE) {
|
|
//
|
|
// Delete new tree. We do not need to delete the new record
|
|
// since we are going to rollback the transaction.
|
|
//
|
|
ProfileDiskClone( FALSE, NULL, TargetProfileName);
|
|
}
|
|
if ( Error == NO_ERROR) {
|
|
Call( JetCommitTransaction( pSession->SesId, JET_bitCommitFlush));
|
|
} else {
|
|
Call( JetRollback( pSession->SesId, JET_bitRollbackAll));
|
|
}
|
|
LeaveCriticalSection( &RG_ProtectDatabase);
|
|
|
|
//
|
|
// Restore source data, then release it.
|
|
//
|
|
Info.ProfileName = SaveProfileName;
|
|
Info.ProfileComment = SaveProfileComment;
|
|
ProfileGetInfoCleanup( 2, &Info);
|
|
return( Error);
|
|
}
|
|
|
|
|