ea.c File Reference

#include "fatprocs.h"

Include dependency graph for ea.c:

Go to the source code of this file.

Macros
#define	Dbg   (DEBUG_TRACE_EA)

Functions
IO_STATUS_BLOCK	FatQueryEaUserEaList (IN PIRP_CONTEXT IrpContext, OUT PCCB Ccb, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, OUT PUCHAR UserBuffer, IN ULONG UserBufferLength, IN PUCHAR UserEaList, IN ULONG UserEaListLength, IN BOOLEAN ReturnSingleEntry)
IO_STATUS_BLOCK	FatQueryEaIndexSpecified (IN PIRP_CONTEXT IrpContext, OUT PCCB Ccb, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, OUT PUCHAR UserBuffer, IN ULONG UserBufferLength, IN ULONG UserEaIndex, IN BOOLEAN ReturnSingleEntry)
IO_STATUS_BLOCK	FatQueryEaSimpleScan (IN PIRP_CONTEXT IrpContext, OUT PCCB Ccb, IN PPACKED_EA FirstPackedEa, IN ULONG PackedEasLength, OUT PUCHAR UserBuffer, IN ULONG UserBufferLength, IN BOOLEAN ReturnSingleEntry, ULONG StartOffset)
BOOLEAN	FatIsDuplicateEaName (IN PIRP_CONTEXT IrpContext, IN PFILE_GET_EA_INFORMATION GetEa, IN PUCHAR UserBuffer)
	_Function_class_ (IRP_MJ_QUERY_EA)
	_Function_class_ (IRP_MJ_SET_EA)
NTSTATUS	FatCommonQueryEa (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)
NTSTATUS	FatCommonSetEa (IN PIRP_CONTEXT IrpContext, IN PIRP Irp)

Macro Definition Documentation

Dbg

#define Dbg   (DEBUG_TRACE_EA)

Definition at line 23 of file ea.c.

Function Documentation

_Function_class_() [1/2]

_Function_class_

(

IRP_MJ_QUERY_EA

)

Definition at line 87 of file ea.c.

{
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatFsdQueryEa\n", 0);
 
    //
    //  Call the common query routine, with blocking allowed if synchronous
    //
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    _SEH2_TRY {
 
        IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
 
        Status = FatCommonQueryEa( IrpContext, Irp );
 
    } _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
        //
        //  We had some trouble trying to perform the requested
        //  operation, so we'll abort the I/O request with
        //  the error status that we get back from the
        //  execption code
        //
 
        Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    if (TopLevel) { IoSetTopLevelIrp( NULL ); }
 
    FsRtlExitFileSystem();
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatFsdQueryEa -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

_Function_class_() [2/2]

_Function_class_

(

IRP_MJ_SET_EA

)

Definition at line 168 of file ea.c.

{
    NTSTATUS Status;
    PIRP_CONTEXT IrpContext = NULL;
 
    BOOLEAN TopLevel;
 
    PAGED_CODE();
 
    DebugTrace(+1, Dbg, "FatFsdSetEa\n", 0);
 
    //
    //  Call the common set routine, with blocking allowed if synchronous
    //
 
    FsRtlEnterFileSystem();
 
    TopLevel = FatIsIrpTopLevel( Irp );
 
    _SEH2_TRY {
 
        IrpContext = FatCreateIrpContext( Irp, CanFsdWait( Irp ) );
 
        Status = FatCommonSetEa( IrpContext, Irp );
 
    } _SEH2_EXCEPT(FatExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {
 
        //
        //  We had some trouble trying to perform the requested
        //  operation, so we'll abort the I/O request with
        //  the error status that we get back from the
        //  execption code
        //
 
        Status = FatProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
    } _SEH2_END;
 
    if (TopLevel) { IoSetTopLevelIrp( NULL ); }
 
    FsRtlExitFileSystem();
 
    //
    //  And return to our caller
    //
 
    DebugTrace(-1, Dbg, "FatFsdSetEa -> %08lx\n", Status);
 
    UNREFERENCED_PARAMETER( VolumeDeviceObject );
 
    return Status;
}

FatCommonQueryEa()

NTSTATUS FatCommonQueryEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 250 of file ea.c.

{
#if 0
    PIO_STACK_LOCATION IrpSp;
 
    NTSTATUS Status;
 
    PUCHAR  Buffer;
    ULONG   UserBufferLength;
 
    PUCHAR  UserEaList;
    ULONG   UserEaListLength;
    ULONG   UserEaIndex;
    BOOLEAN RestartScan;
    BOOLEAN ReturnSingleEntry;
    BOOLEAN IndexSpecified;
 
    PVCB Vcb;
    PCCB Ccb;
 
    PFCB Fcb;
    PDIRENT Dirent;
    PBCB Bcb;
 
    PDIRENT EaDirent;
    PBCB EaBcb;
    BOOLEAN LockedEaFcb;
 
    PEA_SET_HEADER EaSetHeader;
    EA_RANGE EaSetRange;
 
    USHORT ExtendedAttributes;
#endif
 
    PAGED_CODE();
 
    FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
    return STATUS_INVALID_DEVICE_REQUEST;
 
#if 0
    //
    //  Get the current Irp stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatCommonQueryEa...\n", 0);
    DebugTrace( 0, Dbg, " Wait                = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
    DebugTrace( 0, Dbg, " Irp                 = %p\n", Irp );
    DebugTrace( 0, Dbg, " ->SystemBuffer      = %p\n", Irp->AssociatedIrp.SystemBuffer );
    DebugTrace( 0, Dbg, " ->Length            = %08lx\n", IrpSp->Parameters.QueryEa.Length );
    DebugTrace( 0, Dbg, " ->EaList            = %08lx\n", IrpSp->Parameters.QueryEa.EaList );
    DebugTrace( 0, Dbg, " ->EaListLength      = %08lx\n", IrpSp->Parameters.QueryEa.EaListLength );
    DebugTrace( 0, Dbg, " ->EaIndex           = %08lx\n", IrpSp->Parameters.QueryEa.EaIndex );
    DebugTrace( 0, Dbg, " ->RestartScan       = %08lx\n", FlagOn(IrpSp->Flags, SL_RESTART_SCAN));
    DebugTrace( 0, Dbg, " ->ReturnSingleEntry = %08lx\n", FlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY));
    DebugTrace( 0, Dbg, " ->IndexSpecified    = %08lx\n", FlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED));
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    //
    //  Check that the file object is associated with either a user file
    //  or directory open.  We don't allow Ea operations on the root
    //  directory.
    //
 
    {
        TYPE_OF_OPEN OpenType;
 
        if (((OpenType = FatDecodeFileObject( IrpSp->FileObject,
                                             &Vcb,
                                             &Fcb,
                                             &Ccb )) != UserFileOpen
             && OpenType != UserDirectoryOpen) ||
 
            (NodeType( Fcb )) == FAT_NTC_ROOT_DCB) {
 
            FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
            DebugTrace(-1, Dbg,
                       "FatCommonQueryEa -> %08lx\n",
                       STATUS_INVALID_PARAMETER);
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    //  Fat32 does not support ea's.
    //
 
    if (FatIsFat32(Vcb)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_EAS_NOT_SUPPORTED );
        DebugTrace(-1, Dbg,
                   "FatCommonQueryEa -> %08lx\n",
                   STATUS_EAS_NOT_SUPPORTED);
        return STATUS_EAS_NOT_SUPPORTED;
    }
 
    //
    //  Acquire shared access to the Fcb and enqueue the Irp if we didn't
    //  get access.
    //
 
    if (!FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT )) {
 
        DebugTrace(0, Dbg, "FatCommonQueryEa:  Thread can't wait\n", 0);
 
        Status = FatFsdPostRequest( IrpContext, Irp );
 
        DebugTrace(-1, Dbg, "FatCommonQueryEa -> %08lx\n", Status );
 
        return Status;
    }
 
    FatAcquireSharedFcb( IrpContext, Fcb );
 
    //
    //  Reference our input parameters to make things easier
    //
 
    UserBufferLength  = IrpSp->Parameters.QueryEa.Length;
    UserEaList        = IrpSp->Parameters.QueryEa.EaList;
    UserEaListLength  = IrpSp->Parameters.QueryEa.EaListLength;
    UserEaIndex       = IrpSp->Parameters.QueryEa.EaIndex;
    RestartScan       = BooleanFlagOn(IrpSp->Flags, SL_RESTART_SCAN);
    ReturnSingleEntry = BooleanFlagOn(IrpSp->Flags, SL_RETURN_SINGLE_ENTRY);
    IndexSpecified    = BooleanFlagOn(IrpSp->Flags, SL_INDEX_SPECIFIED);
 
    //
    //  Initialize our local values.
    //
 
    LockedEaFcb = FALSE;
    Bcb = NULL;
    EaBcb = NULL;
 
    Status = STATUS_SUCCESS;
 
    RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
    try {
 
        PPACKED_EA FirstPackedEa;
        ULONG PackedEasLength;
 
        Buffer = FatMapUserBuffer( IrpContext, Irp );
 
        //
        //  We verify that the Fcb is still valid.
        //
 
        FatVerifyFcb( IrpContext, Fcb );
 
        //
        //  We need to get the dirent for the Fcb to recover the Ea handle.
        //
 
        FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
        //
        //  Verify that the Ea file is in a consistant state.  If the
        //  Ea modification count in the Fcb doesn't match that in
        //  the CCB, then the Ea file has been changed from under
        //  us.  If we are not starting the search from the beginning
        //  of the Ea set, we return an error.
        //
 
        if (UserEaList == NULL
            && Ccb->OffsetOfNextEaToReturn != 0
            && !IndexSpecified
            && !RestartScan
            && Fcb->EaModificationCount != Ccb->EaModificationCount) {
 
            DebugTrace(0, Dbg,
                      "FatCommonQueryEa:  Ea file in unknown state\n", 0);
 
            Status = STATUS_EA_CORRUPT_ERROR;
 
            try_return( Status );
        }
 
        //
        //  Show that the Ea's for this file are consistant for this
        //  file handle.
        //
 
        Ccb->EaModificationCount = Fcb->EaModificationCount;
 
        //
        //  If the handle value is 0, then the file has no Eas.  We dummy up
        //  an ea list to use below.
        //
 
        ExtendedAttributes = Dirent->ExtendedAttributes;
 
        FatUnpinBcb( IrpContext, Bcb );
 
        if (ExtendedAttributes == 0) {
 
            DebugTrace(0, Dbg,
                      "FatCommonQueryEa:  Zero handle, no Ea's for this file\n", 0);
 
            FirstPackedEa = (PPACKED_EA) NULL;
 
            PackedEasLength = 0;
 
        } else {
 
            //
            //  We need to get the Ea file for this volume.  If the
            //  operation doesn't complete due to blocking, then queue the
            //  Irp to the Fsp.
            //
 
            FatGetEaFile( IrpContext,
                          Vcb,
                          &EaDirent,
                          &EaBcb,
                          FALSE,
                          FALSE );
 
            LockedEaFcb = TRUE;
 
            //
            //  If the above operation completed and the Ea file did not exist,
            //  the disk has been corrupted.  There is an existing Ea handle
            //  without any Ea data.
            //
 
            if (Vcb->VirtualEaFile == NULL) {
 
                DebugTrace(0, Dbg,
                          "FatCommonQueryEa:  No Ea file found when expected\n", 0);
 
                Status = STATUS_NO_EAS_ON_FILE;
 
                try_return( Status );
            }
 
            //
            //  We need to try to get the Ea set for the desired file.  If
            //  blocking is necessary then we'll post the request to the Fsp.
            //
 
            FatReadEaSet( IrpContext,
                          Vcb,
                          ExtendedAttributes,
                          &Fcb->ShortName.Name.Oem,
                          TRUE,
                          &EaSetRange );
 
            EaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            //
            //  Find the start and length of the Eas.
            //
 
            FirstPackedEa = (PPACKED_EA) EaSetHeader->PackedEas;
 
            PackedEasLength = GetcbList( EaSetHeader ) - 4;
        }
 
        //
        //  Protect our access to the user buffer since IO dosn't do this
        //  for us in this path unless we had specified that our driver
        //  requires buffering for these large requests.  We don't, so ...
        //
 
        try {
 
            //
            //  Let's clear the output buffer.
            //
 
            RtlZeroMemory( Buffer, UserBufferLength );
 
            //
            //  We now satisfy the user's request depending on whether he
            //  specified an Ea name list, an Ea index or restarting the
            //  search.
            //
 
            //
            //  The user has supplied a list of Ea names.
            //
 
            if (UserEaList != NULL) {
 
                Irp->IoStatus = FatQueryEaUserEaList( IrpContext,
                                                      Ccb,
                                                      FirstPackedEa,
                                                      PackedEasLength,
                                                      Buffer,
                                                      UserBufferLength,
                                                      UserEaList,
                                                      UserEaListLength,
                                                      ReturnSingleEntry );
 
            //
            //  The user supplied an index into the Ea list.
            //
 
            } else if (IndexSpecified) {
 
                Irp->IoStatus = FatQueryEaIndexSpecified( IrpContext,
                                                          Ccb,
                                                          FirstPackedEa,
                                                          PackedEasLength,
                                                          Buffer,
                                                          UserBufferLength,
                                                          UserEaIndex,
                                                          ReturnSingleEntry );
 
            //
            //  Else perform a simple scan, taking into account the restart
            //  flag and the position of the next Ea stored in the Ccb.
            //
 
            } else {
 
                Irp->IoStatus = FatQueryEaSimpleScan( IrpContext,
                                                      Ccb,
                                                      FirstPackedEa,
                                                      PackedEasLength,
                                                      Buffer,
                                                      UserBufferLength,
                                                      ReturnSingleEntry,
                                                      RestartScan
                                                      ? 0
                                                      : Ccb->OffsetOfNextEaToReturn );
            }
 
        }  except (!FsRtlIsNtstatusExpected(GetExceptionCode()) ?
                   EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
 
               //
               //  We must have had a problem filling in the user's buffer, so fail.
               //
 
               Irp->IoStatus.Status = GetExceptionCode();
               Irp->IoStatus.Information = 0;
        }
 
        Status = Irp->IoStatus.Status;
 
    try_exit: NOTHING;
    } finally {
 
        DebugUnwind( FatCommonQueryEa );
 
        //
        //  Release the Fcb for the file object, and the Ea Fcb if
        //  successfully locked.
        //
 
        FatReleaseFcb( IrpContext, Fcb );
 
        if (LockedEaFcb) {
 
            FatReleaseFcb( IrpContext, Vcb->EaFcb );
        }
 
        //
        //  Unpin the dirents for the Fcb, EaFcb and EaSetFcb if necessary.
        //
 
        FatUnpinBcb( IrpContext, Bcb );
        FatUnpinBcb( IrpContext, EaBcb );
 
        FatUnpinEaRange( IrpContext, &EaSetRange );
 
        if (!AbnormalTermination()) {
 
            FatCompleteRequest( IrpContext, Irp, Status );
        }
 
        DebugTrace(-1, Dbg, "FatCommonQueryEa -> %08lx\n", Status);
    }
 
    return Status;
#endif
}

Referenced by _Function_class_(), FatCommonQueryEa(), and FatFspDispatch().

FatCommonSetEa()

NTSTATUS FatCommonSetEa	(	IN PIRP_CONTEXT	IrpContext,
		IN PIRP	Irp
	)

Definition at line 659 of file ea.c.

{
#if 0
    PIO_STACK_LOCATION IrpSp;
 
    NTSTATUS Status;
 
    USHORT ExtendedAttributes;
 
    PUCHAR Buffer;
    ULONG UserBufferLength;
 
    PVCB Vcb;
    PCCB Ccb;
 
    PFCB Fcb;
    PDIRENT Dirent;
    PBCB Bcb = NULL;
 
    PDIRENT EaDirent = NULL;
    PBCB EaBcb = NULL;
 
    PEA_SET_HEADER EaSetHeader = NULL;
 
    PEA_SET_HEADER PrevEaSetHeader;
    PEA_SET_HEADER NewEaSetHeader;
    EA_RANGE EaSetRange;
 
    BOOLEAN AcquiredVcb = FALSE;
    BOOLEAN AcquiredFcb = FALSE;
    BOOLEAN AcquiredParentDcb = FALSE;
    BOOLEAN AcquiredRootDcb = FALSE;
    BOOLEAN AcquiredEaFcb = FALSE;
#endif
 
    PAGED_CODE();
 
    FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_DEVICE_REQUEST);
    return STATUS_INVALID_DEVICE_REQUEST;
 
#if 0
 
    //
    //  The following booleans are used in the unwind process.
    //
 
    //
    //  Get the current Irp stack location
    //
 
    IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
    DebugTrace(+1, Dbg, "FatCommonSetEa...\n", 0);
    DebugTrace( 0, Dbg, " Wait                = %08lx\n", FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT));
    DebugTrace( 0, Dbg, " Irp                 = %p\n", Irp );
    DebugTrace( 0, Dbg, " ->SystemBuffer      = %p\n", Irp->AssociatedIrp.SystemBuffer );
    DebugTrace( 0, Dbg, " ->Length            = %08lx\n", IrpSp->Parameters.SetEa.Length );
 
    Irp->IoStatus.Status = STATUS_SUCCESS;
    Irp->IoStatus.Information = 0;
 
    //
    //  Check that the file object is associated with either a user file
    //  or directory open.
    //
 
    {
        TYPE_OF_OPEN OpenType;
 
        if (((OpenType = FatDecodeFileObject( IrpSp->FileObject,
                                             &Vcb,
                                             &Fcb,
                                             &Ccb )) != UserFileOpen
             && OpenType != UserDirectoryOpen) ||
 
            (NodeType( Fcb )) == FAT_NTC_ROOT_DCB) {
 
            FatCompleteRequest( IrpContext, Irp, STATUS_INVALID_PARAMETER );
 
            DebugTrace(-1, Dbg,
                       "FatCommonSetEa -> %08lx\n",
                       STATUS_INVALID_PARAMETER);
 
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // Fat32 does not support ea's.
    //
 
    if (FatIsFat32(Vcb)) {
 
        FatCompleteRequest( IrpContext, Irp, STATUS_EAS_NOT_SUPPORTED );
        DebugTrace(-1, Dbg,
                   "FatCommonSetEa -> %08lx\n",
                   STATUS_EAS_NOT_SUPPORTED);
        return STATUS_EAS_NOT_SUPPORTED;
    }
 
    //
    //  Reference our input parameters to make things easier
    //
 
    UserBufferLength  = IrpSp->Parameters.SetEa.Length;
 
    //
    //  Since we ask for no outside help (direct or buffered IO), it
    //  is our responsibility to insulate ourselves from the
    //  deviousness of the user above.  Now, buffer and validate the
    //  contents.
    //
 
    Buffer = FatBufferUserBuffer( IrpContext, Irp, UserBufferLength );
 
    //
    //  Check the validity of the buffer with the new eas.  We really
    //  need to do this always since we don't know, if it was already
    //  buffered, that we buffered and checked it or some overlying
    //  filter buffered without checking.
    //
 
    Status = IoCheckEaBufferValidity( (PFILE_FULL_EA_INFORMATION) Buffer,
                                      UserBufferLength,
                                      (PULONG)&Irp->IoStatus.Information );
 
    if (!NT_SUCCESS( Status )) {
 
        FatCompleteRequest( IrpContext, Irp, Status );
        DebugTrace(-1, Dbg,
                   "FatCommonSetEa -> %08lx\n",
                   Status);
        return Status;
    }
 
    //
    //  Acquire exclusive access to the Fcb.  If this is a write-through operation
    //  we will need to pick up the other possible streams that can be modified in
    //  this operation so that the locking order is preserved - the root directory
    //  (dirent addition if EA database doesn't already exist) and the parent
    //  directory (addition of the EA handle to the object's dirent).
    //
    //  We are primarily synchronizing with directory enumeration here.
    //
    //  If we cannot wait need to send things off to the fsp.
    //
 
    if (!FlagOn(IrpContext->Flags, IRP_CONTEXT_FLAG_WAIT)) {
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Set Ea must be waitable\n", 0);
 
        Status = FatFsdPostRequest( IrpContext, Irp );
 
        DebugTrace(-1, Dbg, "FatCommonSetEa -> %08lx\n", Status );
 
        return Status;
    }
 
    //
    //  Set this handle as having modified the file
    //
 
    IrpSp->FileObject->Flags |= FO_FILE_MODIFIED;
 
    RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
    try {
 
        ULONG PackedEasLength;
        BOOLEAN PreviousEas;
        ULONG AllocationLength;
        ULONG BytesPerCluster;
        USHORT EaHandle;
 
        PFILE_FULL_EA_INFORMATION FullEa;
 
        //
        //  Now go pick up everything
        //
 
        FatAcquireSharedVcb( IrpContext, Fcb->Vcb );
        AcquiredVcb = TRUE;
        FatAcquireExclusiveFcb( IrpContext, Fcb );
        AcquiredFcb = TRUE;
 
        if (FlagOn( IrpContext->Flags, IRP_CONTEXT_FLAG_WRITE_THROUGH)) {
 
            if (Fcb->ParentDcb) {
 
                FatAcquireExclusiveFcb( IrpContext, Fcb->ParentDcb );
                AcquiredParentDcb = TRUE;
            }
 
            FatAcquireExclusiveFcb( IrpContext, Fcb->Vcb->RootDcb );
            AcquiredRootDcb = TRUE;
        }
 
        //
        //  We verify that the Fcb is still valid.
        //
 
        FatVerifyFcb( IrpContext, Fcb );
 
        //
        //  We need to get the dirent for the Fcb to recover the Ea handle.
        //
 
        FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Dirent Address -> %p\n",
                   Dirent );
        DebugTrace(0, Dbg, "FatCommonSetEa:  Dirent Bcb -> %p\n",
                   Bcb);
 
        //
        //  If the handle value is 0, then the file has no Eas.  In that
        //  case we allocate memory to hold the Eas to be added.  If there
        //  are existing Eas for the file, then we must read from the
        //  file and copy the Eas.
        //
 
        ExtendedAttributes = Dirent->ExtendedAttributes;
 
        FatUnpinBcb( IrpContext, Bcb );
 
        if (ExtendedAttributes == 0) {
 
            PreviousEas = FALSE;
 
            DebugTrace(0, Dbg,
                      "FatCommonSetEa:  File has no current Eas\n", 0 );
 
        } else {
 
            PreviousEas = TRUE;
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  File has previous Eas\n", 0 );
 
            FatGetEaFile( IrpContext,
                          Vcb,
                          &EaDirent,
                          &EaBcb,
                          FALSE,
                          TRUE );
 
            AcquiredEaFcb = TRUE;
 
            //
            //  If we didn't get the file then there is an error on
            //  the disk.
            //
 
            if (Vcb->VirtualEaFile == NULL) {
 
                Status = STATUS_NO_EAS_ON_FILE;
                try_return( Status );
            }
        }
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  EaBcb -> %p\n", EaBcb);
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  EaDirent -> %p\n", EaDirent);
 
        //
        //  If the file has existing ea's, we need to read them to
        //  determine the size of the buffer allocation.
        //
 
        if (PreviousEas) {
 
            //
            //  We need to try to get the Ea set for the desired file.
            //
 
            FatReadEaSet( IrpContext,
                          Vcb,
                          ExtendedAttributes,
                          &Fcb->ShortName.Name.Oem,
                          TRUE,
                          &EaSetRange );
 
            PrevEaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            //
            //  We now must allocate pool memory for our copy of the
            //  EaSetHeader and then copy the Ea data into it.  At that
            //  time we can unpin the EaSet.
            //
 
            PackedEasLength = GetcbList( PrevEaSetHeader ) - 4;
 
        //
        //  Else we will create a dummy EaSetHeader.
        //
 
        } else {
 
            PackedEasLength = 0;
        }
 
        BytesPerCluster = 1 << Vcb->AllocationSupport.LogOfBytesPerCluster;
 
        AllocationLength = (PackedEasLength
                            + SIZE_OF_EA_SET_HEADER
                            + BytesPerCluster - 1)
                           & ~(BytesPerCluster - 1);
 
        EaSetHeader = FsRtlAllocatePoolWithTag( PagedPool,
                                                AllocationLength,
                                                TAG_EA_SET_HEADER );
 
        //
        //  Copy the existing Eas over to pool memory.
        //
 
        if (PreviousEas) {
 
            RtlCopyMemory( EaSetHeader, PrevEaSetHeader, AllocationLength );
 
            FatUnpinEaRange( IrpContext, &EaSetRange );
 
        } else {
 
            RtlZeroMemory( EaSetHeader, AllocationLength );
 
            RtlCopyMemory( EaSetHeader->OwnerFileName,
                           Fcb->ShortName.Name.Oem.Buffer,
                           Fcb->ShortName.Name.Oem.Length );
        }
 
 
        AllocationLength -= SIZE_OF_EA_SET_HEADER;
 
        DebugTrace(0, Dbg, "FatCommonSetEa:  Initial Ea set -> %p\n",
                   EaSetHeader);
 
        //
        //  At this point we have either read in the current eas for the file
        //  or we have initialized a new empty buffer for the eas.  Now for
        //  each full ea in the input user buffer we do the specified operation
        //  on the ea
        //
 
        for (FullEa = (PFILE_FULL_EA_INFORMATION) Buffer;
             FullEa < (PFILE_FULL_EA_INFORMATION) &Buffer[UserBufferLength];
             FullEa = (PFILE_FULL_EA_INFORMATION) (FullEa->NextEntryOffset == 0 ?
                                  &Buffer[UserBufferLength] :
                                  (PUCHAR) FullEa + FullEa->NextEntryOffset)) {
 
            OEM_STRING EaName;
            ULONG Offset;
 
            EaName.MaximumLength = EaName.Length = FullEa->EaNameLength;
            EaName.Buffer = &FullEa->EaName[0];
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  Next Ea name -> %Z\n",
                       &EaName);
 
            //
            //  Make sure the ea name is valid
            //
 
            if (!FatIsEaNameValid( IrpContext,EaName )) {
 
                Irp->IoStatus.Information = (PUCHAR)FullEa - Buffer;
                Status = STATUS_INVALID_EA_NAME;
                try_return( Status );
            }
 
            //
            //  Check that no invalid ea flags are set.
            //
 
            //
            //  TEMPCODE  We are returning STATUS_INVALID_EA_NAME
            //  until a more appropriate error code exists.
            //
 
            if (FullEa->Flags != 0
                && FullEa->Flags != FILE_NEED_EA) {
 
                Irp->IoStatus.Information = (PUCHAR)FullEa - (PUCHAR)Buffer;
                try_return( Status = STATUS_INVALID_EA_NAME );
            }
 
            //
            //  See if we can locate the ea name in the ea set
            //
 
            if (FatLocateEaByName( IrpContext,
                                   (PPACKED_EA) EaSetHeader->PackedEas,
                                   PackedEasLength,
                                   &EaName,
                                   &Offset )) {
 
                DebugTrace(0, Dbg, "FatCommonSetEa:  Found Ea name\n", 0);
 
                //
                //  We found the ea name so now delete the current entry,
                //  and if the new ea value length is not zero then we
                //  replace if with the new ea
                //
 
                FatDeletePackedEa( IrpContext,
                                   EaSetHeader,
                                   &PackedEasLength,
                                   Offset );
            }
 
            if (FullEa->EaValueLength != 0) {
 
                FatAppendPackedEa( IrpContext,
                                   &EaSetHeader,
                                   &PackedEasLength,
                                   &AllocationLength,
                                   FullEa,
                                   BytesPerCluster );
            }
        }
 
        //
        //  If there are any ea's not removed, we
        //  call 'AddEaSet' to insert them into the Fat chain.
        //
 
        if (PackedEasLength != 0) {
 
            LARGE_INTEGER EaOffset;
 
            EaOffset.HighPart = 0;
 
            //
            //  If the packed eas length (plus 4 bytes) is greater
            //  than the maximum allowed ea size, we return an error.
            //
 
            if (PackedEasLength + 4 > MAXIMUM_EA_SIZE) {
 
                DebugTrace( 0, Dbg, "Ea length is greater than maximum\n", 0 );
 
                try_return( Status = STATUS_EA_TOO_LARGE );
            }
 
            //
            //  We need to now read the ea file if we haven't already.
            //
 
            if (EaDirent == NULL) {
 
                FatGetEaFile( IrpContext,
                              Vcb,
                              &EaDirent,
                              &EaBcb,
                              TRUE,
                              TRUE );
 
                AcquiredEaFcb = TRUE;
            }
 
            FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
            RtlZeroMemory( &EaSetRange, sizeof( EA_RANGE ));
 
            FatAddEaSet( IrpContext,
                         Vcb,
                         PackedEasLength + SIZE_OF_EA_SET_HEADER,
                         EaBcb,
                         EaDirent,
                         &EaHandle,
                         &EaSetRange );
 
            NewEaSetHeader = (PEA_SET_HEADER) EaSetRange.Data;
 
            DebugTrace(0, Dbg, "FatCommonSetEa:  Adding an ea set\n", 0);
 
            //
            //  Store the length of the new Ea's into the EaSetHeader.
            //  This is the PackedEasLength + 4.
            //
 
            PackedEasLength += 4;
 
            CopyU4char( EaSetHeader->cbList, &PackedEasLength );
 
            //
            //  Copy all but the first four bytes of EaSetHeader into
            //  NewEaSetHeader.  The signature and index fields have
            //  already been filled in.
            //
 
            RtlCopyMemory( &NewEaSetHeader->NeedEaCount,
                           &EaSetHeader->NeedEaCount,
                           PackedEasLength + SIZE_OF_EA_SET_HEADER - 8 );
 
            FatMarkEaRangeDirty( IrpContext, Vcb->VirtualEaFile, &EaSetRange );
            FatUnpinEaRange( IrpContext, &EaSetRange );
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
 
        } else {
 
            FatGetDirentFromFcbOrDcb( IrpContext, Fcb, &Dirent, &Bcb );
 
            EaHandle = 0;
        }
 
        //
        //  Now we do a wholesale replacement of the ea for the file
        //
 
        if (PreviousEas) {
 
            FatDeleteEaSet( IrpContext,
                            Vcb,
                            EaBcb,
                            EaDirent,
                            ExtendedAttributes,
                            &Fcb->ShortName.Name.Oem );
 
            CcFlushCache( Vcb->VirtualEaFile->SectionObjectPointer, NULL, 0, NULL );
        }
 
        if (PackedEasLength != 0 ) {
 
            Fcb->EaModificationCount++;
        }
 
        //
        //  Mark the dirent with the new ea's
        //
 
        Dirent->ExtendedAttributes = EaHandle;
 
        FatSetDirtyBcb( IrpContext, Bcb, Vcb, TRUE );
 
        //
        //  We call the notify package to report that the ea's were
        //  modified.
        //
 
        FatNotifyReportChange( IrpContext,
                               Vcb,
                               Fcb,
                               FILE_NOTIFY_CHANGE_EA,
                               FILE_ACTION_MODIFIED );
 
        Irp->IoStatus.Information = 0;
        Status = STATUS_SUCCESS;
 
    try_exit: NOTHING;
 
        //
        //  Unpin the dirents for the Fcb and EaFcb if necessary.
        //
 
        FatUnpinBcb( IrpContext, Bcb );
        FatUnpinBcb( IrpContext, EaBcb );
 
        FatUnpinRepinnedBcbs( IrpContext );
 
    } finally {
 
        DebugUnwind( FatCommonSetEa );
 
        //
        //  If this is an abnormal termination, we need to clean up
        //  any locked resources.
        //
 
        if (AbnormalTermination()) {
 
            //
            //  Unpin the dirents for the Fcb, EaFcb and EaSetFcb if necessary.
            //
 
            FatUnpinBcb( IrpContext, Bcb );
            FatUnpinBcb( IrpContext, EaBcb );
 
            FatUnpinEaRange( IrpContext, &EaSetRange );
        }
 
        //
        //  Release the Fcbs/Vcb acquired.
        //
 
        if (AcquiredEaFcb) {
            FatReleaseFcb( IrpContext, Vcb->EaFcb );
        }
 
        if (AcquiredFcb) {
            FatReleaseFcb( IrpContext, Fcb );
        }
 
        if (AcquiredParentDcb) {
            FatReleaseFcb( IrpContext, Fcb->ParentDcb );
        }
 
        if (AcquiredRootDcb) {
            FatReleaseFcb( IrpContext, Fcb->Vcb->RootDcb );
        }
 
        if (AcquiredVcb) {
            FatReleaseVcb( IrpContext, Fcb->Vcb );
        }
 
        //
        //  Deallocate our Ea buffer.
        //
 
        if (EaSetHeader != NULL) {
 
            ExFreePool( EaSetHeader );
        }
 
        //
        //  Complete the irp.
        //
 
        if (!AbnormalTermination()) {
 
            FatCompleteRequest( IrpContext, Irp, Status );
        }
 
        DebugTrace(-1, Dbg, "FatCommonSetEa -> %08lx\n", Status);
    }
 
    //
    //  And return to our caller
    //
 
    return Status;
#endif
}

Referenced by _Function_class_(), FatCommonSetEa(), and FatFspDispatch().

FatIsDuplicateEaName()

BOOLEAN FatIsDuplicateEaName	(	IN PIRP_CONTEXT	IrpContext,
		IN PFILE_GET_EA_INFORMATION	GetEa,
		IN PUCHAR	UserBuffer
	)

FatQueryEaIndexSpecified()

IO_STATUS_BLOCK FatQueryEaIndexSpecified	(	IN PIRP_CONTEXT	IrpContext,
		OUT PCCB	Ccb,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		OUT PUCHAR	UserBuffer,
		IN ULONG	UserBufferLength,
		IN ULONG	UserEaIndex,
		IN BOOLEAN	ReturnSingleEntry
	)

Referenced by FatCommonQueryEa().

FatQueryEaSimpleScan()

IO_STATUS_BLOCK FatQueryEaSimpleScan	(	IN PIRP_CONTEXT	IrpContext,
		OUT PCCB	Ccb,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		OUT PUCHAR	UserBuffer,
		IN ULONG	UserBufferLength,
		IN BOOLEAN	ReturnSingleEntry,
		ULONG	StartOffset
	)

Referenced by FatCommonQueryEa().

FatQueryEaUserEaList()

IO_STATUS_BLOCK FatQueryEaUserEaList	(	IN PIRP_CONTEXT	IrpContext,
		OUT PCCB	Ccb,
		IN PPACKED_EA	FirstPackedEa,
		IN ULONG	PackedEasLength,
		OUT PUCHAR	UserBuffer,
		IN ULONG	UserBufferLength,
		IN PUCHAR	UserEaList,
		IN ULONG	UserEaListLength,
		IN BOOLEAN	ReturnSingleEntry
	)

Referenced by FatCommonQueryEa().