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.
1515 lines
40 KiB
1515 lines
40 KiB
/*++
|
|
|
|
Copyright (c) 1989 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ea.c
|
|
|
|
Abstract:
|
|
|
|
This module contains various support routines for extended attributes.
|
|
|
|
Author:
|
|
|
|
David Treadwell (davidtr) 5-Apr-1990
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#include "ea.tmh"
|
|
#pragma hdrstop
|
|
|
|
#define BugCheckFileId SRV_FILE_EA
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text( PAGE, SrvAreEasNeeded )
|
|
#pragma alloc_text( PAGE, SrvGetOs2FeaOffsetOfError )
|
|
#pragma alloc_text( PAGE, SrvGetOs2GeaOffsetOfError )
|
|
#pragma alloc_text( PAGE, SrvOs2FeaListToNt )
|
|
#pragma alloc_text( PAGE, SrvOs2FeaListSizeToNt )
|
|
#pragma alloc_text( PAGE, SrvOs2FeaToNt )
|
|
#pragma alloc_text( PAGE, SrvOs2GeaListToNt )
|
|
#pragma alloc_text( PAGE, SrvOs2GeaListSizeToNt )
|
|
#pragma alloc_text( PAGE, SrvOs2GeaToNt )
|
|
#pragma alloc_text( PAGE, SrvNtFullEaToOs2 )
|
|
#pragma alloc_text( PAGE, SrvGetNumberOfEasInList )
|
|
#pragma alloc_text( PAGE, SrvQueryOs2FeaList )
|
|
#pragma alloc_text( PAGE, SrvSetOs2FeaList )
|
|
#pragma alloc_text( PAGE, SrvConstructNullOs2FeaList )
|
|
#endif
|
|
|
|
|
|
BOOLEAN
|
|
SrvAreEasNeeded (
|
|
IN PFILE_FULL_EA_INFORMATION NtFullEa
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine checks whether any of the full EAs in the list have the
|
|
FILE_NEED_EA bit set in the flags field.
|
|
|
|
Arguments:
|
|
|
|
NtFullEa - a pointer to a pointer to where the NT-style full EA list
|
|
is stored.
|
|
|
|
Return Value:
|
|
|
|
BOOLEAN - TRUE if any EA has FILE_NEED_EA set, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PFILE_FULL_EA_INFORMATION lastEa;
|
|
|
|
PAGED_CODE( );
|
|
|
|
do {
|
|
|
|
if ( NtFullEa->Flags & FILE_NEED_EA ) {
|
|
return TRUE;
|
|
}
|
|
|
|
lastEa = NtFullEa;
|
|
NtFullEa = (PFILE_FULL_EA_INFORMATION)(
|
|
(PCHAR)NtFullEa + NtFullEa->NextEntryOffset );
|
|
|
|
} while ( lastEa->NextEntryOffset != 0 );
|
|
|
|
return FALSE;
|
|
|
|
} // SrvAreEasNeeded
|
|
|
|
|
|
USHORT
|
|
SrvGetOs2FeaOffsetOfError (
|
|
IN ULONG NtErrorOffset,
|
|
IN PFILE_FULL_EA_INFORMATION NtFullEa,
|
|
IN PFEALIST FeaList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds the offset in a FEALIST that corresponds to an offset into
|
|
a list of FILE_FULL_EA_INFORMATION structures. This is used when
|
|
NtSetEaFile returns an offset to an EA that caused an error, and we
|
|
need to return the offset into the list of EAs given to us by the
|
|
client.
|
|
|
|
Arguments:
|
|
|
|
NtErrorOffset - offset of the EA in the NT full EA list that caused
|
|
the error.
|
|
|
|
NtFullEa - a pointer to a pointer to where the NT-style full EA list
|
|
is stored. A buffer is allocated and pointer to by *NtFullEa.
|
|
|
|
FeaList - pointer to the OS/2 1.2 FEALIST.
|
|
|
|
Return Value:
|
|
|
|
USHORT - offset into the FEALIST.
|
|
|
|
--*/
|
|
|
|
{
|
|
PFEA fea = FeaList->list;
|
|
PFEA lastFeaStartLocation;
|
|
PFILE_FULL_EA_INFORMATION offsetLocation;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// If the NT error offset is zero, return 0 for the FEA error offset.
|
|
//
|
|
// !!! this shouldn't be necessary if the loop below is written
|
|
// correctly.
|
|
|
|
//if ( NtErrorOffset == 0 ) {
|
|
// return 0;
|
|
//}
|
|
|
|
//
|
|
// Find where in the NT full EA list the error occurred and the
|
|
// last possible start location for an FEA in the FEALIST.
|
|
//
|
|
|
|
offsetLocation = (PFILE_FULL_EA_INFORMATION)(
|
|
(PCHAR)NtFullEa + NtErrorOffset);
|
|
lastFeaStartLocation = (PFEA)( (PCHAR)FeaList +
|
|
SmbGetUlong( &FeaList->cbList ) -
|
|
sizeof(FEA) - 1 );
|
|
|
|
//
|
|
// Walk through both lists simultaneously until one of three conditions
|
|
// is true:
|
|
// - we reach or pass the offset in the NT full EA list
|
|
// - we reach the end of the NT full EA list
|
|
// - we reach the end of the FEALIST.
|
|
//
|
|
|
|
while ( NtFullEa < offsetLocation &&
|
|
NtFullEa->NextEntryOffset != 0 &&
|
|
fea <= lastFeaStartLocation ) {
|
|
|
|
NtFullEa = (PFILE_FULL_EA_INFORMATION)(
|
|
(PCHAR)NtFullEa + NtFullEa->NextEntryOffset );
|
|
fea = (PFEA)( (PCHAR)fea + sizeof(FEA) + fea->cbName + 1 +
|
|
SmbGetUshort( &fea->cbValue ) );
|
|
}
|
|
|
|
//
|
|
// If NtFullEa is not equal to the offset location we calculated,
|
|
// somebody messed up.
|
|
//
|
|
|
|
//ASSERT( NtFullEa == offsetLocation );
|
|
|
|
return PTR_DIFF_SHORT(fea, FeaList );
|
|
|
|
} // SrvGetOs2FeaOffsetOfError
|
|
|
|
|
|
USHORT
|
|
SrvGetOs2GeaOffsetOfError (
|
|
IN ULONG NtErrorOffset,
|
|
IN PFILE_GET_EA_INFORMATION NtGetEa,
|
|
IN PGEALIST GeaList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds the offset in a GEALIST that corresponds to an offset into
|
|
a list of FILE_GET_EA_INFORMATION structures. This is used when
|
|
NtQueryEaFile returns an offset to an EA that caused an error, and we
|
|
need to return the offset into the list of EAs given to us by the
|
|
client.
|
|
|
|
Arguments:
|
|
|
|
NtErrorOffset - offset of the EA in the NT get EA list that caused
|
|
the error.
|
|
|
|
NtGetEa - a pointer to a pointer to where the NT-style get EA list
|
|
is stored. A buffer is allocated and pointer to by *NtGetEa.
|
|
|
|
GeaList - pointer to the OS/2 1.2 GEALIST.
|
|
|
|
Return Value:
|
|
|
|
USHORT - offset into the GEALIST.
|
|
|
|
--*/
|
|
|
|
{
|
|
PGEA gea = GeaList->list;
|
|
PGEA lastGeaStartLocation;
|
|
PFILE_GET_EA_INFORMATION offsetLocation;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Find where in the NT get EA list the error occurred and the
|
|
// last possible start location for an GEA in the GEALIST.
|
|
//
|
|
|
|
offsetLocation = (PFILE_GET_EA_INFORMATION)((PCHAR)NtGetEa + NtErrorOffset);
|
|
lastGeaStartLocation = (PGEA)( (PCHAR)GeaList +
|
|
SmbGetUlong( &GeaList->cbList ) - sizeof(GEA) );
|
|
|
|
|
|
//
|
|
// Walk through both lists simultaneously until one of three conditions
|
|
// is true:
|
|
// - we reach or pass the offset in the NT full EA list
|
|
// - we reach the end of the NT get EA list
|
|
// - we reach the end of the GEALIST.
|
|
//
|
|
|
|
while ( NtGetEa < offsetLocation &&
|
|
NtGetEa->NextEntryOffset != 0 &&
|
|
gea <= lastGeaStartLocation ) {
|
|
|
|
NtGetEa = (PFILE_GET_EA_INFORMATION)(
|
|
(PCHAR)NtGetEa + NtGetEa->NextEntryOffset );
|
|
gea = (PGEA)( (PCHAR)gea + sizeof(GEA) + gea->cbName );
|
|
}
|
|
|
|
//
|
|
// If NtGetEa is not equal to the offset location we calculated,
|
|
// somebody messed up.
|
|
//
|
|
|
|
// ASSERT( NtGetEa == offsetLocation );
|
|
|
|
return PTR_DIFF_SHORT(gea, GeaList);
|
|
|
|
} // SrvGetOs2GeaOffsetOfError
|
|
|
|
|
|
NTSTATUS
|
|
SrvOs2FeaListToNt (
|
|
IN PFEALIST FeaList,
|
|
OUT PFILE_FULL_EA_INFORMATION *NtFullEa,
|
|
OUT PULONG BufferLength,
|
|
OUT PUSHORT EaErrorOffset
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a list of OS/2 1.2 FEAs to NT style. Memory is allocated from
|
|
non-paged pool to hold the NT full EA list. The calling routine is
|
|
responsible for deallocating this memory when it is done with it.
|
|
|
|
WARNING! It is the responsibility of the calling routine to ensure
|
|
that the value in FeaList->cbList will fit within the buffer allocated
|
|
to FeaList. This prevents malicious redirectors from causing an
|
|
access violation in the server.
|
|
|
|
Arguments:
|
|
|
|
FeaList - pointer to the OS/2 1.2 FEALIST to convert.
|
|
|
|
NtFullEa - a pointer to a pointer to where the NT-style full EA list
|
|
is stored. A buffer is allocated and pointer to by *NtFullEa.
|
|
|
|
BufferLength - length of the allocated buffer.
|
|
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - STATUS_SUCCESS or STATUS_INSUFF_SERVER_RESOURCES.
|
|
|
|
--*/
|
|
|
|
{
|
|
PFEA lastFeaStartLocation;
|
|
PFEA fea = NULL;
|
|
PFEA lastFea = NULL;
|
|
PFILE_FULL_EA_INFORMATION ntFullEa = NULL;
|
|
PFILE_FULL_EA_INFORMATION lastNtFullEa = NULL;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Find out how large the OS/2 1.2 FEALIST will be after it is
|
|
// converted to NT format. This is necessary in order to
|
|
// determine how large a buffer to allocate to receive the NT
|
|
// EAs.
|
|
//
|
|
|
|
*BufferLength = SrvOs2FeaListSizeToNt( FeaList );
|
|
|
|
//
|
|
// It is possible for SrvOs2FeaListSizeToNt to return 0 in the event
|
|
// that the very first FEA in the list is corrupt. Return an error
|
|
// if this is the case with an appropriate EaErrorOffset value.
|
|
//
|
|
|
|
if (*BufferLength == 0) {
|
|
*EaErrorOffset = 0;
|
|
return STATUS_OS2_EA_LIST_INCONSISTENT;
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer to hold the NT list. This is allocated from
|
|
// non-paged pool so that it may be used in IRP-based IO requests.
|
|
//
|
|
|
|
*NtFullEa = ALLOCATE_NONPAGED_POOL( *BufferLength, BlockTypeDataBuffer );
|
|
|
|
if ( *NtFullEa == NULL ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"SrvOs2FeaListToNt: Unable to allocate %d bytes from nonpaged "
|
|
"pool.",
|
|
*BufferLength,
|
|
NULL
|
|
);
|
|
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Find the last location at which an FEA can start. The -1 is to
|
|
// account for the zero terminator on the name field of the FEA.
|
|
//
|
|
|
|
lastFeaStartLocation = (PFEA)( (PCHAR)FeaList +
|
|
SmbGetUlong( &FeaList->cbList ) -
|
|
sizeof(FEA) - 1 );
|
|
|
|
//
|
|
// Go through the FEA list, converting from OS/2 1.2 format to NT
|
|
// until we pass the last possible location in which an FEA can start.
|
|
//
|
|
|
|
for ( fea = FeaList->list, ntFullEa = *NtFullEa, lastNtFullEa = ntFullEa;
|
|
fea <= lastFeaStartLocation;
|
|
fea = (PFEA)( (PCHAR)fea + sizeof(FEA) +
|
|
fea->cbName + 1 + SmbGetUshort( &fea->cbValue ) ) ) {
|
|
|
|
//
|
|
// Check for an invalid flag bit. If set, return an error.
|
|
//
|
|
|
|
if ( (fea->fEA & ~FEA_NEEDEA) != 0 ) {
|
|
*EaErrorOffset = PTR_DIFF_SHORT(fea, FeaList);
|
|
DEALLOCATE_NONPAGED_POOL( *NtFullEa );
|
|
return STATUS_INVALID_PARAMETER;
|
|
}
|
|
|
|
lastNtFullEa = ntFullEa;
|
|
lastFea = fea;
|
|
ntFullEa = SrvOs2FeaToNt( ntFullEa, fea );
|
|
}
|
|
|
|
//
|
|
// Make sure that the FEALIST size parameter was correct. If we ended
|
|
// on an EA that was not the first location after the end of the
|
|
// last FEA, then the size parameter was wrong. Return an offset to
|
|
// the EA that caused the error.
|
|
//
|
|
|
|
if ( (PCHAR)fea != (PCHAR)FeaList + SmbGetUlong( &FeaList->cbList ) ) {
|
|
*EaErrorOffset = PTR_DIFF_SHORT(lastFea, FeaList);
|
|
DEALLOCATE_NONPAGED_POOL( *NtFullEa );
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Set the NextEntryOffset field of the last full EA to 0 to indicate
|
|
// the end of the list.
|
|
//
|
|
|
|
lastNtFullEa->NextEntryOffset = 0;
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // SrvOs2FeaListToNt
|
|
|
|
|
|
ULONG
|
|
SrvOs2FeaListSizeToNt (
|
|
IN PFEALIST FeaList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get the number of bytes that would be required to represent the
|
|
FEALIST in NT format.
|
|
|
|
WARNING: This routine makes no checks on the size of the FEALIST
|
|
buffer. It is assumed that FeaList->cbList is a legitimate value.
|
|
|
|
WARNING: The value returned by this routine may be as much as three
|
|
higher than the actual size needed to hold the FEAs in NT format.
|
|
See comments below.
|
|
|
|
Arguments:
|
|
|
|
Fea - a pointer to the list of FEAs.
|
|
|
|
Return Value:
|
|
|
|
ULONG - number of bytes required to hold the EAs in NT format.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG size = 0;
|
|
|
|
PCHAR lastValidLocation;
|
|
PCHAR variableBuffer;
|
|
PFEA fea;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Find the last valid location in the FEA buffer.
|
|
//
|
|
|
|
lastValidLocation = (PCHAR)FeaList + SmbGetUlong( &FeaList->cbList );
|
|
|
|
//
|
|
// Go through the FEA list until we pass the last location
|
|
// indicated in the buffer.
|
|
//
|
|
|
|
for ( fea = FeaList->list;
|
|
fea < (PFEA)lastValidLocation;
|
|
fea = (PFEA)( (PCHAR)fea + sizeof(FEA) +
|
|
fea->cbName + 1 + SmbGetUshort( &fea->cbValue ) ) ) {
|
|
|
|
//
|
|
// Be very careful accessing the embedded FEA since there are so many possibly
|
|
// conflicting sizes running around here. The first part of the conditional
|
|
// below makes sure that the cbName and cbValue fields of the FEA buffer can
|
|
// actually be dereferenced. The second part verifies that they contain
|
|
// reasonable values.
|
|
//
|
|
|
|
variableBuffer = (PCHAR)fea + sizeof(FEA);
|
|
|
|
if (variableBuffer >= lastValidLocation ||
|
|
(variableBuffer + fea->cbName + 1 + SmbGetUshort(&fea->cbValue)) > lastValidLocation) {
|
|
|
|
//
|
|
// The values in this part of the buffer indicate a range outside the
|
|
// buffer. Don't calculate a size, and shrink the cbList value to
|
|
// include only the prior FEA.
|
|
//
|
|
|
|
SmbPutUshort( &FeaList->cbList, PTR_DIFF_SHORT(fea, FeaList) );
|
|
break;
|
|
|
|
}
|
|
|
|
//
|
|
// SmbGetNtSizeOfFea returns the number of bytes needed to hold
|
|
// a single FEA in NT format, including any padding needed for
|
|
// longword-alignment. Since the size of the buffer needed to
|
|
// hold the NT EA list does not include any padding after the
|
|
// last EA, the value returned by this routine may be as much as
|
|
// three higher than the size actually needed.
|
|
//
|
|
|
|
size += SmbGetNtSizeOfFea( fea );
|
|
}
|
|
|
|
return size;
|
|
|
|
} // SrvOs2FeaListSizeToNt
|
|
|
|
|
|
PVOID
|
|
SrvOs2FeaToNt (
|
|
OUT PFILE_FULL_EA_INFORMATION NtFullEa,
|
|
IN PFEA Fea
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a single OS/2 FEA to NT full EA style. The FEA need not have
|
|
any particular alignment. This routine makes no checks on buffer
|
|
overrunning--this is the responsibility of the calling routine.
|
|
|
|
Arguments:
|
|
|
|
NtFullEa - a pointer to where the NT full EA is to be written.
|
|
|
|
Fea - pointer to the OS/2 1.2 FEA to convert.
|
|
|
|
Return Value:
|
|
|
|
A pointer to the location after the last byte written.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR ptr;
|
|
|
|
PAGED_CODE( );
|
|
|
|
NtFullEa->Flags = Fea->fEA;
|
|
NtFullEa->EaNameLength = Fea->cbName;
|
|
NtFullEa->EaValueLength = SmbGetUshort( &Fea->cbValue );
|
|
|
|
ptr = NtFullEa->EaName;
|
|
RtlMoveMemory( ptr, (PVOID)(Fea+1), Fea->cbName );
|
|
|
|
ptr += NtFullEa->EaNameLength;
|
|
*ptr++ = '\0';
|
|
|
|
//
|
|
// Copy the EA value to the NT full EA.
|
|
//
|
|
|
|
RtlMoveMemory(
|
|
ptr,
|
|
(PCHAR)(Fea+1) + NtFullEa->EaNameLength + 1,
|
|
NtFullEa->EaValueLength
|
|
);
|
|
|
|
ptr += NtFullEa->EaValueLength;
|
|
|
|
//
|
|
// Longword-align ptr to determine the offset to the next location
|
|
// for an NT full EA.
|
|
//
|
|
|
|
ptr = (PCHAR)( ((ULONG_PTR)ptr + 3) & ~3 );
|
|
NtFullEa->NextEntryOffset = (ULONG)( ptr - (PCHAR)NtFullEa );
|
|
|
|
return ptr;
|
|
|
|
} // SrvOs2FeaToNt
|
|
|
|
|
|
NTSTATUS
|
|
SrvOs2GeaListToNt (
|
|
IN PGEALIST GeaList,
|
|
OUT PFILE_GET_EA_INFORMATION *NtGetEa,
|
|
OUT PULONG BufferLength,
|
|
OUT PUSHORT EaErrorOffset
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a list of OS/2 1.2 GEAs to NT style. Memory is allocated from
|
|
non-paged pool to hold the NT get EA list. The calling routine is
|
|
responsible for deallocating this memory when it is done with it.
|
|
|
|
WARNING! It is the responsibility of the calling routine to ensure
|
|
that the value in GeaList->cbList will fit within the buffer allocated
|
|
to GeaList. This prevents malicious redirectors from causing an
|
|
access violation in the server.
|
|
|
|
Arguments:
|
|
|
|
GeaList - pointer to the OS/2 1.2 GEALIST to convert.
|
|
|
|
NtGetEa - a pointer to a pointer to where the NT-style get EA list
|
|
is stored. A buffer is allocated and pointer to by *NtGetEa.
|
|
|
|
BufferLength - length of the allocated buffer.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - STATUS_SUCCESS or STATUS_INSUFF_SERVER_RESOURCES.
|
|
|
|
--*/
|
|
|
|
{
|
|
PGEA lastGeaStartLocation;
|
|
PGEA gea = NULL;
|
|
PGEA lastGea = NULL;
|
|
PFILE_GET_EA_INFORMATION ntGetEa = NULL;
|
|
PFILE_GET_EA_INFORMATION lastNtGetEa = NULL;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Find out how large the OS/2 1.2 GEALIST will be after it is
|
|
// converted to NT format. This is necessary in order to
|
|
// determine how large a buffer to allocate to receive the NT
|
|
// EAs.
|
|
//
|
|
|
|
*BufferLength = SrvOs2GeaListSizeToNt( GeaList );
|
|
|
|
if ( *BufferLength == 0 ) {
|
|
*EaErrorOffset = 0;
|
|
return STATUS_OS2_EA_LIST_INCONSISTENT;
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer to hold the NT list. This is allocated from
|
|
// non-paged pool so that it may be used in IRP-based IO requests.
|
|
//
|
|
|
|
*NtGetEa = ALLOCATE_NONPAGED_POOL( *BufferLength, BlockTypeDataBuffer );
|
|
|
|
if ( *NtGetEa == NULL ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"SrvOs2GeaListToNt: Unable to allocate %d bytes from nonpaged "
|
|
"pool.",
|
|
*BufferLength,
|
|
NULL
|
|
);
|
|
|
|
return STATUS_INSUFF_SERVER_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Find the last location at which a GEA can start. The zero
|
|
// terminator on the name field of the GEA is accounted for by the
|
|
// szName[0] field in the GEA structure.
|
|
//
|
|
|
|
lastGeaStartLocation = (PGEA)( (PCHAR)GeaList +
|
|
SmbGetUlong( &GeaList->cbList ) - sizeof(GEA) );
|
|
|
|
//
|
|
// Go through the GEA list, converting from OS/2 1.2 format to NT
|
|
// until we pass the last possible location in which an GEA can start.
|
|
//
|
|
|
|
for ( gea = GeaList->list, ntGetEa = *NtGetEa, lastNtGetEa = ntGetEa;
|
|
gea <= lastGeaStartLocation;
|
|
gea = (PGEA)( (PCHAR)gea + sizeof(GEA) + gea->cbName ) ) {
|
|
|
|
lastNtGetEa = ntGetEa;
|
|
lastGea = gea;
|
|
ntGetEa = SrvOs2GeaToNt( ntGetEa, gea );
|
|
}
|
|
|
|
//
|
|
// Make sure that the GEALIST size parameter was correct. If we ended
|
|
// on an EA that was not the first location after the end of the
|
|
// last GEA, then the size parameter was wrong. Return an offset to
|
|
// the EA that caused the error.
|
|
//
|
|
|
|
if ( (PCHAR)gea != (PCHAR)GeaList + SmbGetUlong( &GeaList->cbList ) ) {
|
|
DEALLOCATE_NONPAGED_POOL(*NtGetEa);
|
|
*EaErrorOffset = PTR_DIFF_SHORT(lastGea, GeaList);
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
|
|
//
|
|
// Set the NextEntryOffset field of the last get EA to 0 to indicate
|
|
// the end of the list.
|
|
//
|
|
|
|
lastNtGetEa->NextEntryOffset = 0;
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // SrvOs2GeaListToNt
|
|
|
|
|
|
ULONG
|
|
SrvOs2GeaListSizeToNt (
|
|
IN PGEALIST GeaList
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Get the number of bytes that would be required to represent the
|
|
GEALIST in NT format.
|
|
|
|
WARNING: This routine makes no checks on the size of the GEALIST
|
|
buffer. It is assumed that GeaList->cbList is a legitimate value.
|
|
|
|
WARNING: The value returned by this routine may be as much as three
|
|
higher than the actual size needed to hold the GEAs in NT format.
|
|
See comments below.
|
|
|
|
Arguments:
|
|
|
|
Gea - a pointer to the list of GEAs.
|
|
|
|
Size - number of bytes required to hold the EAs in NT format.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - STATUS_SUCCESS or STATUS_BUFFER_OVERFLOW if the GEA list was
|
|
larger than it's buffer.
|
|
|
|
--*/
|
|
|
|
{
|
|
ULONG size = 0;
|
|
|
|
PCHAR lastValidLocation;
|
|
PCHAR variableBuffer;
|
|
PGEA gea;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Find the last location in the GEA buffer.
|
|
//
|
|
|
|
lastValidLocation = (PCHAR)GeaList + SmbGetUlong( &GeaList->cbList );
|
|
|
|
|
|
//
|
|
// Go through the GEA list until we pass the last possible location
|
|
// in which an GEA can start.
|
|
//
|
|
|
|
for ( gea = GeaList->list;
|
|
gea < (PGEA)lastValidLocation;
|
|
gea = (PGEA)( (PCHAR)gea + sizeof(GEA) + gea->cbName ) ) {
|
|
|
|
//
|
|
// Be very careful accessing the embedded GEA. The first part of the conditional
|
|
// below makes sure that the cbName field of the GEA buffer can
|
|
// actually be dereferenced. The second part verifies that it contains
|
|
// reasonable values.
|
|
//
|
|
|
|
variableBuffer = (PCHAR)gea + sizeof(GEA);
|
|
|
|
if ( variableBuffer >= lastValidLocation ||
|
|
variableBuffer + gea->cbName > lastValidLocation ) {
|
|
|
|
//
|
|
// If there's a bogus value in the buffer stop processing the size
|
|
// and reset the cbList value to only enclose the previous GEA.
|
|
//
|
|
|
|
SmbPutUshort(&GeaList->cbList, PTR_DIFF_SHORT(gea, GeaList));
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// SmbGetNtSizeOfGea returns the number of bytes needed to hold
|
|
// a single GEA in NT format. This includes any padding needed
|
|
// for longword-alignment. Since the size of the buffer needed
|
|
// to hold the NT EA list does not include any padding after the
|
|
// last EA, the value returned by this routine may be as much as
|
|
// three higher than the size actually needed.
|
|
//
|
|
|
|
size += SmbGetNtSizeOfGea( gea );
|
|
}
|
|
|
|
return size;
|
|
|
|
} // SrvOs2GeaListSizeToNt
|
|
|
|
|
|
PVOID
|
|
SrvOs2GeaToNt (
|
|
OUT PFILE_GET_EA_INFORMATION NtGetEa,
|
|
IN PGEA Gea
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a single OS/2 GEA to NT get EA style. The GEA need not have
|
|
any particular alignment. This routine makes no checks on buffer
|
|
overrunning--this is the responsibility of the calling routine.
|
|
|
|
Arguments:
|
|
|
|
NtGetEa - a pointer to where the NT get EA is to be written.
|
|
|
|
Gea - pointer to the OS/2 1.2 GEA to convert.
|
|
|
|
Return Value:
|
|
|
|
A pointer to the location after the last byte written.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR ptr;
|
|
|
|
PAGED_CODE( );
|
|
|
|
NtGetEa->EaNameLength = Gea->cbName;
|
|
|
|
ptr = NtGetEa->EaName;
|
|
RtlMoveMemory( ptr, Gea->szName, Gea->cbName );
|
|
|
|
ptr += NtGetEa->EaNameLength;
|
|
*ptr++ = '\0';
|
|
|
|
//
|
|
// Longword-align ptr to determine the offset to the next location
|
|
// for an NT full EA.
|
|
//
|
|
|
|
ptr = (PCHAR)( ((ULONG_PTR)ptr + 3) & ~3 );
|
|
NtGetEa->NextEntryOffset = (ULONG)( ptr - (PCHAR)NtGetEa );
|
|
|
|
return ptr;
|
|
|
|
} // SrvOs2GeaToNt
|
|
|
|
|
|
PVOID
|
|
SrvNtFullEaToOs2 (
|
|
OUT PFEA Fea,
|
|
IN PFILE_FULL_EA_INFORMATION NtFullEa
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a single NT full EA to OS/2 FEA style. The FEA need not have
|
|
any particular alignment. This routine makes no checks on buffer
|
|
overrunning--this is the responsibility of the calling routine.
|
|
|
|
Arguments:
|
|
|
|
Fea - a pointer to the location where the OS/2 FEA is to be written.
|
|
|
|
NtFullEa - a pointer to the NT full EA.
|
|
|
|
Return Value:
|
|
|
|
A pointer to the location after the last byte written.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR ptr;
|
|
ULONG i;
|
|
|
|
PAGED_CODE( );
|
|
|
|
Fea->fEA = (UCHAR)NtFullEa->Flags;
|
|
Fea->cbName = NtFullEa->EaNameLength;
|
|
SmbPutUshort( &Fea->cbValue, NtFullEa->EaValueLength );
|
|
|
|
//
|
|
// Copy the attribute name.
|
|
//
|
|
|
|
for ( i = 0, ptr = (PCHAR) (Fea + 1);
|
|
i < (ULONG) NtFullEa->EaNameLength;
|
|
i++, ptr++) {
|
|
|
|
*ptr = RtlUpperChar( NtFullEa->EaName[i] );
|
|
|
|
}
|
|
|
|
*ptr++ = '\0';
|
|
|
|
RtlMoveMemory(
|
|
ptr,
|
|
NtFullEa->EaName + NtFullEa->EaNameLength + 1,
|
|
NtFullEa->EaValueLength
|
|
);
|
|
|
|
return (ptr + NtFullEa->EaValueLength);
|
|
|
|
} // SrvNtFullEaToOs2
|
|
|
|
|
|
CLONG
|
|
SrvGetNumberOfEasInList (
|
|
IN PVOID List
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds the number of EAs in an NT get or full EA list. The list
|
|
should have already been verified to be legitimate to prevent access
|
|
violations.
|
|
|
|
Arguments:
|
|
|
|
List - a pointer to the NT get or full EA list.
|
|
|
|
Return Value:
|
|
|
|
CLONG - the number of EAs in the list.
|
|
|
|
--*/
|
|
|
|
{
|
|
CLONG count = 1;
|
|
PULONG ea;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Walk through the list. The first longword of each EA is the offset
|
|
// to the next EA.
|
|
//
|
|
|
|
for ( ea = List; *ea != 0; ea = (PULONG)( (PCHAR)ea + *ea ) ) {
|
|
count++;
|
|
}
|
|
|
|
return count;
|
|
|
|
} // SrvGetNumberOfEasInList
|
|
|
|
|
|
NTSTATUS
|
|
SrvQueryOs2FeaList (
|
|
IN HANDLE FileHandle,
|
|
IN PGEALIST GeaList OPTIONAL,
|
|
IN PFILE_GET_EA_INFORMATION NtGetEaList OPTIONAL,
|
|
IN ULONG GeaListLength OPTIONAL,
|
|
IN PFEALIST FeaList,
|
|
IN ULONG BufferLength,
|
|
OUT PUSHORT EaErrorOffset
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a single NT full EA list to OS/2 FEALIST style. The FEALIST
|
|
need not have any particular alignment.
|
|
|
|
Arguments:
|
|
|
|
FileHandle - handle to a file open with FILE_READ_EA access.
|
|
|
|
GeaList - if non-NULL, an OS/2 1.2 style GEALIST used to get only
|
|
a subset of the files EAs rather than all the EAs. Only the
|
|
EAs listed in GEALIST are returned.
|
|
|
|
NtGetEaList - if non-NULL, an NT style get EA list used to get only
|
|
a subset of the files EAs rather than all the EAs. Only the
|
|
EAs listed in GEALIST are returned.
|
|
|
|
GeaListLength - the maximum possible length of the GeaList (used to
|
|
prevent access violations) or the actual size of the NtGetEaList.
|
|
|
|
FeaList - where to write the OS/2 1.2 style FEALIST for the file.
|
|
|
|
BufferLength - length of Buffer.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - STATUS_SUCCESS, STATUS_BUFFER_OVERFLOW if the EAs wouldn't
|
|
fit in Buffer, or a value returned by NtQuery{Information,Ea}File.
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PFEA fea = FeaList->list;
|
|
PFILE_FULL_EA_INFORMATION ntFullEa;
|
|
|
|
PFILE_GET_EA_INFORMATION ntGetEa = NULL;
|
|
ULONG ntGetEaBufferLength = 0;
|
|
|
|
FILE_EA_INFORMATION eaInfo;
|
|
IO_STATUS_BLOCK ioStatusBlock;
|
|
|
|
PSRV_EA_INFORMATION eaInformation = NULL;
|
|
ULONG eaBufferSize;
|
|
ULONG errorOffset;
|
|
|
|
BOOLEAN isFirstCall = TRUE;
|
|
|
|
PAGED_CODE( );
|
|
|
|
*EaErrorOffset = 0;
|
|
|
|
//
|
|
// Find out how big a buffer we need to get the EAs.
|
|
//
|
|
|
|
status = NtQueryInformationFile(
|
|
FileHandle,
|
|
&ioStatusBlock,
|
|
&eaInfo,
|
|
sizeof(FILE_EA_INFORMATION),
|
|
FileEaInformation
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_UNEXPECTED,
|
|
"SrvQueryOs2FeaList: NtQueryInformationFile(ea information) "
|
|
"returned %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
SrvLogServiceFailure( SRV_SVC_NT_QUERY_INFO_FILE, status );
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If the file has no EAs, return an FEA size = 4 (that's what OS/2
|
|
// does--it accounts for the size of the cbList field of an
|
|
// FEALIST). Also, store the NT EA size in case there is a buffer
|
|
// overflow and we need to return the total EA size to the client.
|
|
//
|
|
|
|
if ( eaInfo.EaSize == 0 ) {
|
|
SmbPutUlong( &FeaList->cbList, 4 );
|
|
} else {
|
|
SmbPutUlong( &FeaList->cbList, eaInfo.EaSize );
|
|
}
|
|
|
|
if ( eaInfo.EaSize == 0 && GeaList == NULL && NtGetEaList == NULL ) {
|
|
status = STATUS_SUCCESS;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// If a GEALIST was specified, convert it to NT style.
|
|
//
|
|
|
|
if ( ARGUMENT_PRESENT(GeaList) ) {
|
|
|
|
//
|
|
// Make sure that the value in GeaList->cbList is legitimate
|
|
// (allows the GEALIST to fit within its buffer).
|
|
//
|
|
|
|
if ( GeaListLength < sizeof(GEALIST) ||
|
|
SmbGetUlong( &GeaList->cbList ) < sizeof(GEALIST) ||
|
|
SmbGetUlong( &GeaList->cbList ) > GeaListLength ) {
|
|
status = STATUS_OS2_EA_LIST_INCONSISTENT;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Convert the GEALIST to NT style. SrvOs2GeaListToNt allocates
|
|
// space to hold the NT get EA list, so remember to deallocate
|
|
// this before exiting this routine.
|
|
//
|
|
|
|
status = SrvOs2GeaListToNt(
|
|
GeaList,
|
|
&ntGetEa,
|
|
&ntGetEaBufferLength,
|
|
EaErrorOffset
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
return status;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If an NT-style get EA list was specified, use it.
|
|
//
|
|
|
|
if ( ARGUMENT_PRESENT(NtGetEaList) ) {
|
|
ntGetEa = NtGetEaList;
|
|
ntGetEaBufferLength = GeaListLength;
|
|
}
|
|
|
|
//
|
|
// HACKHACK: eaInfo.EaSize is the size needed by OS/2. For NT,
|
|
// the system has no way of telling us how big a buffer we need.
|
|
// According to BrianAn, this should not be bigger than twice
|
|
// what OS/2 needs.
|
|
//
|
|
|
|
eaBufferSize = eaInfo.EaSize * EA_SIZE_FUDGE_FACTOR;
|
|
|
|
//
|
|
// If a get EA list was specified, a larger buffer is needed to hold
|
|
// all the EAs. This is because some or all of the specified EAs
|
|
// may not exist, yet they will still be returned by the file system
|
|
// with value length = 0. Add to the EA size the amount of space the
|
|
// get EA list would use if it were converted to a full EA list.
|
|
//
|
|
|
|
if ( ntGetEa != NULL ) {
|
|
eaBufferSize += ntGetEaBufferLength +
|
|
( SrvGetNumberOfEasInList( ntGetEa ) *
|
|
( sizeof(FILE_FULL_EA_INFORMATION) -
|
|
sizeof(FILE_GET_EA_INFORMATION) ));
|
|
}
|
|
|
|
//
|
|
// Allocate a buffer to receive the EAs. If the total EA size is
|
|
// small enough to get it all in one call to NtQueryEaFile, allocate
|
|
// a buffer that large. If The EAs are large, use a buffer size that
|
|
// is the smallest size guaranteed to hold at least one EA.
|
|
//
|
|
// The buffer must be allocated from non-paged pool for the IRP
|
|
// request built below.
|
|
//
|
|
|
|
eaBufferSize = MIN( MAX_SIZE_OF_SINGLE_EA, eaBufferSize ) +
|
|
sizeof(SRV_EA_INFORMATION);
|
|
|
|
eaInformation = ALLOCATE_NONPAGED_POOL( eaBufferSize, BlockTypeDataBuffer );
|
|
|
|
if ( eaInformation == NULL ) {
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"SrvQueryOs2FeaList: Unable to allocate %d bytes from nonpaged "
|
|
"pool.",
|
|
eaBufferSize,
|
|
NULL
|
|
);
|
|
|
|
status = STATUS_INSUFF_SERVER_RESOURCES;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Get the EAs.
|
|
//
|
|
|
|
while(1) {
|
|
|
|
ULONG feaSize;
|
|
|
|
status = SrvQueryEaFile(
|
|
isFirstCall,
|
|
FileHandle,
|
|
ntGetEa,
|
|
ntGetEaBufferLength,
|
|
eaInformation,
|
|
eaBufferSize,
|
|
&errorOffset
|
|
);
|
|
|
|
if ( status == STATUS_NO_MORE_EAS ) {
|
|
break;
|
|
}
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
if ( ARGUMENT_PRESENT(GeaList) ) {
|
|
*EaErrorOffset = SrvGetOs2GeaOffsetOfError(
|
|
errorOffset,
|
|
ntGetEa,
|
|
GeaList
|
|
);
|
|
//
|
|
// SrvQueryEaFile has already logged the error. Do not
|
|
// create another log entry here.
|
|
//
|
|
|
|
IF_DEBUG(SMB_ERRORS) {
|
|
PGEA errorGea = (PGEA)( (PCHAR)GeaList + *EaErrorOffset );
|
|
SrvPrint1( "EA error offset in GEALIST: 0x%lx\n", *EaErrorOffset );
|
|
SrvPrint1( "name: %s\n", errorGea->szName );
|
|
}
|
|
}
|
|
|
|
goto exit;
|
|
}
|
|
|
|
isFirstCall = FALSE;
|
|
ntFullEa = eaInformation->CurrentEntry;
|
|
|
|
//
|
|
// See if there is enough room to hold the EA in the user buffer.
|
|
//
|
|
// *** STATUS_BUFFER_OVERFLOW is a special status code for the
|
|
// find2 logic. See that code before making changes here.
|
|
|
|
feaSize = SmbGetOs2SizeOfNtFullEa( ntFullEa );
|
|
if ( feaSize > (ULONG)( (PCHAR)FeaList + BufferLength - (PCHAR)fea ) ) {
|
|
status = STATUS_BUFFER_OVERFLOW;
|
|
goto exit;
|
|
}
|
|
|
|
//
|
|
// Copy the NT format EA to OS/2 1.2 format and set the fea
|
|
// pointer for the next iteration.
|
|
//
|
|
|
|
fea = SrvNtFullEaToOs2( fea, ntFullEa );
|
|
|
|
ASSERT( (ULONG_PTR)fea <= (ULONG_PTR)FeaList + BufferLength );
|
|
}
|
|
|
|
//
|
|
// Set the number of bytes in the FEALIST.
|
|
//
|
|
|
|
SmbPutUlong(
|
|
&FeaList->cbList,
|
|
PTR_DIFF(fea, FeaList)
|
|
);
|
|
|
|
status = STATUS_SUCCESS;
|
|
|
|
exit:
|
|
//
|
|
// Deallocate the buffers used to hold the NT get and full EA lists.
|
|
//
|
|
|
|
if ( ntGetEa != NULL && ARGUMENT_PRESENT(GeaList) ) {
|
|
DEALLOCATE_NONPAGED_POOL( ntGetEa );
|
|
}
|
|
|
|
if ( eaInformation != NULL ) {
|
|
DEALLOCATE_NONPAGED_POOL( eaInformation );
|
|
}
|
|
|
|
return status;
|
|
|
|
} // SrvQueryOs2FeaList
|
|
|
|
|
|
NTSTATUS
|
|
SrvSetOs2FeaList (
|
|
IN HANDLE FileHandle,
|
|
IN PFEALIST FeaList,
|
|
IN ULONG BufferLength,
|
|
OUT PUSHORT EaErrorOffset
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Sets the EAs on a file given an OS/2 1.2 representation of the EAs.
|
|
|
|
Arguments:
|
|
|
|
FileHandle - handle to a file open with FILE_WRITE_EA access whose
|
|
EAs are to be set.
|
|
|
|
FeaList - a pointer to the location where the OS/2 FEALIST is stored.
|
|
|
|
BufferLength - maximum size of the buffer the FEALIST structure can
|
|
have. This is used to prevent a malicious redirector from causing
|
|
an access violation in the server.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - what happened
|
|
|
|
--*/
|
|
|
|
{
|
|
NTSTATUS status;
|
|
|
|
PFILE_FULL_EA_INFORMATION ntFullEa;
|
|
ULONG ntFullEaBufferLength;
|
|
ULONG errorOffset;
|
|
|
|
PAGED_CODE( );
|
|
|
|
*EaErrorOffset = 0;
|
|
|
|
//
|
|
// Special case for too-small FEALIST: don't set anything.
|
|
// sizeof(FEALIST) will cover the buffer size and one FEA structure.
|
|
// Without at least this much info there isn't anything to do here.
|
|
//
|
|
// NOTE: If there is space for at least one FEA in the list, but the
|
|
// FEA is corrupt, we'll return an error below, i.e. insufficient
|
|
// information is not an error condition while corrupt info is.
|
|
//
|
|
|
|
if ( BufferLength <= sizeof(FEALIST) ||
|
|
SmbGetUlong( &FeaList->cbList ) <= sizeof(FEALIST)) {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Make sure that the value in Fealist->cbList is legitimate.
|
|
//
|
|
|
|
if ( SmbGetUlong( &FeaList->cbList ) > BufferLength ) {
|
|
DEBUG SrvPrint2(
|
|
"SrvSetOs2FeaList: EA list size is inconsistent. Actual size"
|
|
"is %d, expected maximum size is %d",
|
|
SmbGetUlong( &FeaList->cbList ),
|
|
BufferLength
|
|
);
|
|
return STATUS_OS2_EA_LIST_INCONSISTENT;
|
|
}
|
|
|
|
//
|
|
// Convert the FEALIST to NT style.
|
|
//
|
|
|
|
status = SrvOs2FeaListToNt(
|
|
FeaList,
|
|
&ntFullEa,
|
|
&ntFullEaBufferLength,
|
|
EaErrorOffset
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
//
|
|
// SrvOs2FeaListToNt has already logged the error. Do not
|
|
// create another log entry here.
|
|
//
|
|
|
|
return status;
|
|
|
|
}
|
|
|
|
//
|
|
// Set the file's EAs with a directly-built IRP. Doing this rather
|
|
// than calling the NtSetEaFile system service prevents a copy of
|
|
// the input data from occurring.
|
|
//
|
|
// *** The operation is performed synchronously.
|
|
//
|
|
|
|
status = SrvIssueSetEaRequest(
|
|
FileHandle,
|
|
ntFullEa,
|
|
ntFullEaBufferLength,
|
|
&errorOffset
|
|
);
|
|
|
|
if ( !NT_SUCCESS(status) ) {
|
|
|
|
//
|
|
// An error occurred. Find the offset into the EA list of the
|
|
// error.
|
|
//
|
|
|
|
*EaErrorOffset = SrvGetOs2FeaOffsetOfError(
|
|
errorOffset,
|
|
ntFullEa,
|
|
FeaList
|
|
);
|
|
|
|
INTERNAL_ERROR(
|
|
ERROR_LEVEL_EXPECTED,
|
|
"SrvSetOs2FeaList: SrvIssueSetEaRequest returned %X",
|
|
status,
|
|
NULL
|
|
);
|
|
|
|
/*
|
|
This logging can potentially crash the server on a bad packet. Removed.
|
|
IF_DEBUG(ERRORS) {
|
|
PFEA errorFea = (PFEA)( (PCHAR)FeaList + *EaErrorOffset );
|
|
SrvPrint1( "EA error offset in FEALIST: 0x%lx\n", *EaErrorOffset );
|
|
SrvPrint3( "name: %s, value len: %ld, value: %s", (PCHAR)(errorFea+1),
|
|
SmbGetUshort( &errorFea->cbValue ),
|
|
(PCHAR)(errorFea+1) + errorFea->cbName + 1 );
|
|
}
|
|
*/
|
|
}
|
|
|
|
//
|
|
// Deallocate the buffer used to hold the NT full EA list.
|
|
//
|
|
|
|
DEALLOCATE_NONPAGED_POOL( ntFullEa );
|
|
|
|
return status;
|
|
|
|
} // SrvSetOs2FeaList
|
|
|
|
|
|
NTSTATUS
|
|
SrvConstructNullOs2FeaList (
|
|
IN PFILE_GET_EA_INFORMATION NtGeaList,
|
|
OUT PFEALIST FeaList,
|
|
IN ULONG BufferLength
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Converts a single NT full EA list to OS/2 FEALIST style for files
|
|
with no eas. When a file has no eas but a GEAlist was supplied,
|
|
we need to return an ealist that has all the attributes specified
|
|
in the GEAlist present but with CbValues of 0. This routine was
|
|
specifically written for the files . and .. but can be used to get
|
|
the FEAlist of a no ea file given the NT Gea list.
|
|
|
|
Arguments:
|
|
|
|
NtGetEaList - if non-NULL, an NT style get EA list used to get only
|
|
a subset of the files EAs rather than all the EAs. Only the
|
|
EAs listed in GEALIST are returned.
|
|
|
|
FeaList - where to write the OS/2 1.2 style FEALIST for the file.
|
|
|
|
BufferLength - length of Buffer.
|
|
|
|
Return Value:
|
|
|
|
NTSTATUS - STATUS_SUCCESS, STATUS_BUFFER_OVERFLOW if the EAs wouldn't
|
|
fit in Buffer, or a value returned by NtQuery{Information,Ea}File.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PCHAR ptr;
|
|
PFEA fea = FeaList->list;
|
|
PFILE_GET_EA_INFORMATION currentGea = NtGeaList;
|
|
LONG remainingBytes = BufferLength;
|
|
ULONG i;
|
|
|
|
PAGED_CODE( );
|
|
|
|
//
|
|
// Get the EAs.
|
|
//
|
|
|
|
for ( ; ; ) {
|
|
|
|
//
|
|
// Is our buffer big enough?
|
|
//
|
|
|
|
remainingBytes -= ( sizeof( FEA ) + currentGea->EaNameLength + 1 );
|
|
|
|
if ( remainingBytes < 0 ) {
|
|
|
|
return STATUS_BUFFER_OVERFLOW;
|
|
|
|
}
|
|
|
|
//
|
|
// We know what these are.
|
|
//
|
|
|
|
fea->fEA = 0;
|
|
fea->cbName = currentGea->EaNameLength;
|
|
SmbPutUshort( &fea->cbValue, 0);
|
|
|
|
//
|
|
// Copy the attribute name.
|
|
//
|
|
|
|
for ( i = 0, ptr = (PCHAR) (fea + 1);
|
|
i < (ULONG) currentGea->EaNameLength;
|
|
i++, ptr++) {
|
|
|
|
*ptr = RtlUpperChar( currentGea->EaName[i] );
|
|
|
|
}
|
|
|
|
*ptr++ = '\0';
|
|
|
|
fea = (PFEA) ptr;
|
|
|
|
//
|
|
// Is this the last one?
|
|
//
|
|
|
|
if ( currentGea->NextEntryOffset == 0 ) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Move to the next attribute
|
|
//
|
|
|
|
currentGea = (PFILE_GET_EA_INFORMATION)
|
|
((PCHAR) currentGea + currentGea->NextEntryOffset);
|
|
|
|
}
|
|
|
|
//
|
|
// Set the number of bytes in the FEALIST.
|
|
//
|
|
|
|
SmbPutUlong(
|
|
&FeaList->cbList,
|
|
(ULONG)((ULONG_PTR)fea - (ULONG_PTR)FeaList)
|
|
);
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} // SrvConstructNullOs2FeaList
|