NTSTATUS
IopFileObjectAddDispatched(
IN PIO_FILE_OBJECT pFileObject,
IN IRP_TYPE Type
)
{
NTSTATUS status = STATUS_SUCCESS;
IopFileObjectLock(pFileObject);
if ((Type != IRP_TYPE_CLOSE) &&
(IsSetFlag(pFileObject->Flags, FILE_OBJECT_FLAG_CANCELLED) ||
IsSetFlag(pFileObject->Flags, FILE_OBJECT_FLAG_RUNDOWN)))
{
status = STATUS_CANCELLED;
}
else
{
status = STATUS_SUCCESS;
pFileObject->DispatchedIrpCount++;
LWIO_ASSERT(pFileObject->DispatchedIrpCount >= 1);
}
IopFileObjectUnlock(pFileObject);
return status;
}
VOID
IoIrpMarkPending(
IN PIRP pIrp,
IN PIO_IRP_CALLBACK CancelCallback,
IN OPTIONAL PVOID CancelCallbackContext
)
{
PIRP_INTERNAL irpInternal = IopIrpGetInternal(pIrp);
LWIO_ASSERT(CancelCallback);
IopIrpAcquireCancelLock(pIrp);
LWIO_ASSERT(!irpInternal->Cancel.Callback);
LWIO_ASSERT(!IsSetFlag(irpInternal->Flags, IRP_FLAG_PENDING));
LWIO_ASSERT(!IsSetFlag(irpInternal->Flags, IRP_FLAG_COMPLETE));
LWIO_ASSERT(!IsSetFlag(irpInternal->Flags, IRP_FLAG_CANCELLED));
SetFlag(irpInternal->Flags, IRP_FLAG_PENDING);
irpInternal->Cancel.Callback = CancelCallback;
irpInternal->Cancel.CallbackContext = CancelCallbackContext;
IopIrpReleaseCancelLock(pIrp);
//
// Take a reference that will be released by IoIrpComplete.
//
IopIrpReference(pIrp);
}
USHORT
PvfsIrpContextConditionalSetFlag(
PPVFS_IRP_CONTEXT pIrpContext,
USHORT BitToCheck,
USHORT BitToSetOnTrue,
USHORT BitToSetOnFalse
)
{
BOOLEAN bLocked = FALSE;
USHORT FlagWasSet = 0;
LWIO_LOCK_MUTEX(bLocked, &pIrpContext->Mutex);
if (IsSetFlag(pIrpContext->Flags, BitToCheck))
{
SetFlag(pIrpContext->Flags, BitToSetOnTrue);
FlagWasSet = BitToSetOnTrue;
}
else
{
SetFlag(pIrpContext->Flags, BitToSetOnFalse);
FlagWasSet = BitToSetOnFalse;
}
LWIO_UNLOCK_MUTEX(bLocked, &pIrpContext->Mutex);
return FlagWasSet;
}
static
DWORD
DoLeaveDomain(
IN PCSTR pszDomain,
IN OPTIONAL PCSTR pszUsername,
IN OPTIONAL PCSTR pszPassword,
IN LSA_NET_JOIN_FLAGS JoinFlags
)
{
HANDLE hLsa = NULL;
DWORD dwError = 0;
PCSTR pszUseDomain = IsSetFlag(JoinFlags, LSA_NET_JOIN_DOMAIN_MULTIPLE) ? pszDomain : NULL;
assert(pszDomain);
printf("Leaving AD Domain: %s\n", pszDomain);
dwError = LsaOpenServer(&hLsa);
GOTO_CLEANUP_ON_WINERROR(dwError);
dwError = LsaAdLeaveDomain2(hLsa, pszUsername, pszPassword, pszUseDomain, JoinFlags);
GOTO_CLEANUP_ON_WINERROR(dwError);
printf("SUCCESS\n");
cleanup:
if (hLsa)
{
LsaCloseServer(hLsa);
}
return dwError;
}
NTSTATUS
IopIrpAttach(
IN OUT PIRP pIrp,
IN IRP_TYPE Type,
IN PIO_FILE_OBJECT pFileObject
)
{
NTSTATUS status = 0;
int EE = 0;
PIRP_INTERNAL irpInternal = IopIrpGetInternal(pIrp);
LWIO_ASSERT(!pIrp->FileHandle);
LWIO_ASSERT(pIrp->Type == IRP_TYPE_UNINITIALIZED);
LWIO_ASSERT(Type != IRP_TYPE_UNINITIALIZED);
IopFileObjectLock(pFileObject);
// TODO-Add FILE_OBJECT_FLAG_CLOSED
if ((Type != IRP_TYPE_CLOSE) &&
(IsSetFlag(pFileObject->Flags, FILE_OBJECT_FLAG_CANCELLED) ||
IsSetFlag(pFileObject->Flags, FILE_OBJECT_FLAG_RUNDOWN)))
{
status = STATUS_CANCELLED;
GOTO_CLEANUP_EE(EE);
}
else
{
LwListInsertTail(&pFileObject->IrpList,
&irpInternal->FileObjectLinks);
}
// These are immutable from here until the IRP is freed.
pIrp->Type = Type;
pIrp->FileHandle = pFileObject;
IopFileObjectReference(pFileObject);
// The file object reference keeps an implicit reference to the
// device and driver.
pIrp->DeviceHandle = pFileObject->pDevice;
pIrp->DriverHandle = pFileObject->pDevice->Driver;
cleanup:
IopFileObjectUnlock(pFileObject);
IO_LOG_LEAVE_ON_STATUS_EE(status, EE);
return status;
}
static
BOOLEAN
SrvTree2IsRundown_inlock(
PLWIO_SRV_TREE_2 pTree
)
{
return IsSetFlag(pTree->objectFlags, SRV_OBJECT_FLAG_RUNDOWN);
}
static
BOOLEAN
SrvTree2IsInParent_inlock(
PLWIO_SRV_TREE_2 pTree
)
{
return IsSetFlag(pTree->objectFlags, SRV_OBJECT_FLAG_IN_PARENT);
}
static
DWORD
LsaAdBatchGatherNonSchemaModeGroup(
IN OUT PLSA_AD_BATCH_ITEM pItem,
IN DWORD dwKeywordValuesCount,
IN PSTR* ppszKeywordValues
)
{
DWORD dwError = 0;
DWORD dwValue = 0;
dwError = ADNonSchemaKeywordGetUInt32(
ppszKeywordValues,
dwKeywordValuesCount,
AD_LDAP_GID_TAG,
&dwValue);
if (LW_ERROR_INVALID_LDAP_ATTR_VALUE == dwError)
{
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_DISABLED);
dwError = LW_ERROR_SUCCESS;
}
BAIL_ON_LSA_ERROR(dwError);
if (IsSetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_DISABLED))
{
goto cleanup;
}
if (!dwValue)
{
LSA_LOG_DEBUG("gid must be non-zero for SID '%s'", pItem->pszSid);
// SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_SKIP);
dwError = LW_ERROR_DATA_ERROR;
BAIL_ON_LSA_ERROR(dwError);
}
pItem->GroupInfo.gid = (gid_t)dwValue;
dwError = ADNonSchemaKeywordGetString(
ppszKeywordValues,
dwKeywordValuesCount,
AD_LDAP_DISPLAY_NAME_TAG,
&pItem->GroupInfo.pszAlias);
BAIL_ON_LSA_ERROR(dwError);
dwError = ADNonSchemaKeywordGetString(
ppszKeywordValues,
dwKeywordValuesCount,
AD_LDAP_PASSWD_TAG,
&pItem->GroupInfo.pszPasswd);
BAIL_ON_LSA_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
static
VOID
SrvTree2SetRundown_inlock(
PLWIO_SRV_TREE_2 pTree
)
{
LWIO_ASSERT(!IsSetFlag(pTree->objectFlags, SRV_OBJECT_FLAG_RUNDOWN));
SetFlag(pTree->objectFlags, SRV_OBJECT_FLAG_RUNDOWN);
}
BOOLEAN
IopIrpCancel(
IN PIRP pIrp
)
{
PIRP_INTERNAL irpInternal = IopIrpGetInternal(pIrp);
BOOLEAN isCancellable = FALSE;
BOOLEAN isAcquired = FALSE;
if (!pIrp)
{
GOTO_CLEANUP();
}
IopIrpReference(pIrp);
IopIrpAcquireCancelLock(pIrp);
isAcquired = TRUE;
if (!IsSetFlag(irpInternal->Flags, IRP_FLAG_CANCELLED | IRP_FLAG_COMPLETE))
{
if (irpInternal->Cancel.Callback)
{
ClearFlag(irpInternal->Flags, IRP_FLAG_CANCEL_PENDING);
SetFlag(irpInternal->Flags, IRP_FLAG_CANCELLED);
isCancellable = TRUE;
irpInternal->Cancel.Callback(
pIrp,
irpInternal->Cancel.CallbackContext);
}
else
{
SetFlag(irpInternal->Flags, IRP_FLAG_CANCEL_PENDING);
}
}
else
{
// If already cancelled or complete, we consider it as cancellable.
isCancellable = TRUE;
}
cleanup:
if (isAcquired)
{
IopIrpReleaseCancelLock(pIrp);
}
if (pIrp)
{
IopIrpDereference(&pIrp);
}
return isCancellable;
}
NTSTATUS
PvfsQuerySecurityFile(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_NOT_SUPPORTED;
PIRP pIrp = pIrpContext->pIrp;
PPVFS_CCB pCcb = NULL;
PSECURITY_DESCRIPTOR_RELATIVE pReturnSecDesc = NULL;
ULONG SecDescLength = 0;
SECURITY_INFORMATION SecInfo = 0;
IRP_ARGS_QUERY_SET_SECURITY Args = pIrpContext->pIrp->Args.QuerySetSecurity;
/* Sanity checks */
ntError = PvfsAcquireCCB(pIrp->FileHandle, &pCcb);
BAIL_ON_NT_STATUS(ntError);
if (!IsSetFlag(pCcb->Flags, PVFS_CCB_FLAG_CREATE_COMPLETE))
{
ntError = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntError);
}
BAIL_ON_INVALID_PTR(Args.SecurityDescriptor, ntError);
ntError = PvfsAccessCheckFileHandle(pCcb, READ_CONTROL);
BAIL_ON_NT_STATUS(ntError);
pReturnSecDesc = Args.SecurityDescriptor;
SecDescLength = Args.Length;
SecInfo = Args.SecurityInformation;
/* Real work starts here */
ntError = PvfsGetSecurityDescriptorFile(pCcb,
SecInfo,
pReturnSecDesc,
&SecDescLength);
BAIL_ON_NT_STATUS(ntError);
pIrp->IoStatusBlock.BytesTransferred = SecDescLength;
ntError = STATUS_SUCCESS;
cleanup:
if (pCcb) {
PvfsReleaseCCB(pCcb);
}
return ntError;
error:
goto cleanup;
}
// This function fills in all of the booleans in pObjectUserInfo except for
// bPromptPasswordChange and bAccountExpired
static
VOID
LsaAdBatchMarshalUserInfoAccountControl(
IN UINT32 AccountControl,
IN OUT PLSA_SECURITY_OBJECT_USER_INFO pObjectUserInfo
)
{
pObjectUserInfo->bPasswordNeverExpires = IsSetFlag(AccountControl, LSA_AD_UF_DONT_EXPIRE_PASSWD);
if (pObjectUserInfo->bPasswordNeverExpires)
{
pObjectUserInfo->bPasswordExpired = FALSE;
}
else
{
pObjectUserInfo->bPasswordExpired = IsSetFlag(AccountControl, LSA_AD_UF_PASSWORD_EXPIRED);
}
pObjectUserInfo->bUserCanChangePassword = !IsSetFlag(AccountControl, LSA_AD_UF_CANT_CHANGE_PASSWD);
pObjectUserInfo->bAccountDisabled = IsSetFlag(AccountControl, LSA_AD_UF_ACCOUNTDISABLE);
pObjectUserInfo->bAccountLocked = IsSetFlag(AccountControl, LSA_AD_UF_LOCKOUT);
}
VOID
SrvTree2ClearInParent(
PLWIO_SRV_TREE_2 pTree
)
{
BOOLEAN bInLock = FALSE;
LWIO_LOCK_RWMUTEX_EXCLUSIVE(bInLock, &pTree->mutex);
LWIO_ASSERT(IsSetFlag(pTree->objectFlags, SRV_OBJECT_FLAG_IN_PARENT));
ClearFlag(pTree->objectFlags, SRV_OBJECT_FLAG_IN_PARENT);
LWIO_UNLOCK_RWMUTEX(bInLock, &pTree->mutex);
}
VOID
IopFileObjectRemoveDispatched(
IN PIO_FILE_OBJECT pFileObject,
IN IRP_TYPE Type
)
{
BOOLEAN needContinueAsycClose = FALSE;
IopFileObjectLock(pFileObject);
pFileObject->DispatchedIrpCount--;
LWIO_ASSERT(pFileObject->DispatchedIrpCount >= 0);
if (IsSetFlag(pFileObject->Flags, FILE_OBJECT_FLAG_RUNDOWN_WAIT) &&
(0 == pFileObject->DispatchedIrpCount))
{
// TODO-Perhaps remove Type parameter since the use of
// FILE_OBJECT_FLAG_RUNDOWN_WAIT negates the need for it.
LWIO_ASSERT(Type != IRP_TYPE_CLOSE);
if (pFileObject->Rundown.Callback)
{
needContinueAsycClose = TRUE;
}
else
{
LwRtlSignalConditionVariable(&pFileObject->Rundown.Condition);
}
ClearFlag(pFileObject->Flags, FILE_OBJECT_FLAG_RUNDOWN_WAIT);
}
IopFileObjectUnlock(pFileObject);
if (needContinueAsycClose)
{
// This will send the close to the FSD. Note that the callback
// must be called from here on a synchronous completion because
// there was no asynchronous IRP completion to take care of calling
// the callback.
NTSTATUS status = IopContinueAsyncCloseFile(
pFileObject,
pFileObject->Rundown.Callback,
pFileObject->Rundown.CallbackContext,
pFileObject->Rundown.pIoStatusBlock);
if (STATUS_PENDING != status)
{
pFileObject->Rundown.Callback(pFileObject->Rundown.CallbackContext);
}
}
}
DWORD
LsaAdBatchGatherPseudoObjectDefaultSchema(
IN OUT PLSA_AD_BATCH_ITEM pItem,
IN LSA_AD_BATCH_OBJECT_TYPE ObjectType,
IN OUT OPTIONAL PSTR* ppszSid,
IN HANDLE hDirectory,
IN LDAPMessage* pMessage
)
{
DWORD dwError = 0;
dwError = LsaAdBatchGatherObjectType(pItem, ObjectType);
BAIL_ON_LSA_ERROR(dwError);
if (!pItem->pszSid)
{
if (ppszSid)
{
LSA_XFER_STRING(*ppszSid, pItem->pszSid);
}
else
{
dwError = ADLdap_GetObjectSid(hDirectory, pMessage, &pItem->pszSid);
BAIL_ON_LSA_ERROR(dwError);
}
}
if (LW_IS_NULL_OR_EMPTY_STR(pItem->pszSid))
{
dwError = LW_ERROR_DATA_ERROR;
BAIL_ON_LSA_ERROR(dwError);
}
if (!IsSetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_HAVE_PSEUDO))
{
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_HAVE_PSEUDO);
dwError = LsaAdBatchGatherSchemaMode(
pItem,
hDirectory,
pMessage);
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
return dwError;
error:
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_ERROR);
goto cleanup;
}
static
inline
VOID
RtlpMapGenericMaskSingleFlag(
IN OUT PACCESS_MASK AccessMask,
IN ACCESS_MASK GenericFlag,
IN ACCESS_MASK SpecificFlags
)
{
if (IsSetFlag(*AccessMask, GenericFlag))
{
ClearFlag(*AccessMask, GenericFlag);
SetFlag(*AccessMask, SpecificFlags);
}
}
BOOLEAN
PvfsIrpContextCheckFlag(
PPVFS_IRP_CONTEXT pIrpContext,
USHORT BitToCheck
)
{
BOOLEAN bLocked = FALSE;
BOOLEAN bIsSet = FALSE;
LWIO_LOCK_MUTEX(bLocked, &pIrpContext->Mutex);
bIsSet = IsSetFlag(pIrpContext->Flags, BitToCheck);
LWIO_UNLOCK_MUTEX(bLocked, &pIrpContext->Mutex);
return bIsSet;
}
NTSTATUS
PvfsRead(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
IRP_ARGS_READ_WRITE Args = pIrpContext->pIrp->Args.ReadWrite;
PPVFS_CCB pCcb = NULL;
ntError = PvfsAcquireCCB(pIrpContext->pIrp->FileHandle, &pCcb);
BAIL_ON_NT_STATUS(ntError);
if (!IsSetFlag(pCcb->Flags, PVFS_CCB_FLAG_CREATE_COMPLETE))
{
ntError = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntError);
}
switch (pIrpContext->pIrp->Args.ReadWrite.ZctOperation)
{
case IRP_ZCT_OPERATION_NONE:
ntError = PvfsReadInternal(pIrpContext);
break;
case IRP_ZCT_OPERATION_PREPARE:
BAIL_ON_INVALID_PTR(Args.Zct, ntError);
ntError = PvfsReadInternal(pIrpContext);
break;
case IRP_ZCT_OPERATION_COMPLETE:
BAIL_ON_INVALID_PTR(Args.ZctCompletionContext, ntError);
ntError = PvfsZctCompleteRead(pIrpContext);
break;
default:
ntError = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntError);
}
cleanup:
if (pCcb)
{
PvfsReleaseCCB(pCcb);
}
return ntError;
error:
goto cleanup;
}
ACCESS_MASK
PvfsGetGrantedAccessForNewObject(
ACCESS_MASK DesiredAccess
)
{
ACCESS_MASK GrantedAccess = DesiredAccess;
// TODO: This function probably needs to be more complicated.
if (IsSetFlag(DesiredAccess, MAXIMUM_ALLOWED))
{
GrantedAccess = FILE_ALL_ACCESS;
}
RtlMapGenericMask(&GrantedAccess, &gPvfsDriverState.GenericSecurityMap);
return GrantedAccess;
}
NTSTATUS
RtlQueryAccessTokenUnixInformation(
IN PACCESS_TOKEN AccessToken,
OUT PTOKEN_UNIX TokenInformation
)
{
NTSTATUS status = STATUS_SUCCESS;
BOOLEAN isLocked = FALSE;
TOKEN_UNIX tokenInfo = { 0 };
if (!AccessToken)
{
status = STATUS_INVALID_PARAMETER;
GOTO_CLEANUP();
}
SHARED_LOCK_RWLOCK(&AccessToken->RwLock, isLocked);
if (!IsSetFlag(AccessToken->Flags, ACCESS_TOKEN_FLAG_UNIX_PRESENT))
{
status = STATUS_NOT_FOUND;
GOTO_CLEANUP();
}
tokenInfo.Uid = AccessToken->Uid;
tokenInfo.Gid = AccessToken->Gid;
tokenInfo.Umask = AccessToken->Umask;
status = STATUS_SUCCESS;
cleanup:
UNLOCK_RWLOCK(&AccessToken->RwLock, isLocked);
if (!NT_SUCCESS(status))
{
RtlZeroMemory(&tokenInfo, sizeof(tokenInfo));
}
*TokenInformation = tokenInfo;
return status;
}
DWORD
LsaAdBatchGatherPseudoObjectSidFromGc(
IN PAD_PROVIDER_DATA pProviderData,
IN OUT PLSA_AD_BATCH_ITEM pItem,
IN LSA_AD_BATCH_OBJECT_TYPE ObjectType,
IN OPTIONAL DWORD dwKeywordValuesCount,
IN OPTIONAL PSTR* ppszKeywordValues,
IN HANDLE hDirectory,
IN LDAPMessage* pMessage
)
{
DWORD dwError = 0;
LSA_ASSERT(LSA_IS_XOR(LsaAdBatchIsDefaultSchemaMode(pProviderData), ppszKeywordValues));
LSA_ASSERT(!IsSetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_HAVE_PSEUDO));
dwError = LsaAdBatchGatherObjectType(pItem, ObjectType);
BAIL_ON_LSA_ERROR(dwError);
if (!pItem->pszSid)
{
dwError = LsaAdBatchGatherPseudoSid(
&pItem->pszSid,
pProviderData,
dwKeywordValuesCount,
ppszKeywordValues,
hDirectory,
pMessage);
BAIL_ON_LSA_ERROR(dwError);
}
cleanup:
return dwError;
error:
SetFlag(pItem->Flags, LSA_AD_BATCH_ITEM_FLAG_ERROR);
goto cleanup;
}
BOOLEAN
RtlIsSidMemberOfToken(
IN PACCESS_TOKEN AccessToken,
IN PSID Sid
)
{
BOOLEAN isMember = FALSE;
BOOLEAN isLocked = FALSE;
ULONG i = 0;
SHARED_LOCK_RWLOCK(&AccessToken->RwLock, isLocked);
if (RtlEqualSid(Sid, AccessToken->User.Sid))
{
isMember = TRUE;
GOTO_CLEANUP();
}
for (i = 0; i < AccessToken->GroupCount; i++)
{
PSID_AND_ATTRIBUTES sidInfo = &AccessToken->Groups[i];
if (IsSetFlag(sidInfo->Attributes, SE_GROUP_ENABLED) &&
RtlEqualSid(Sid, sidInfo->Sid))
{
isMember = TRUE;
GOTO_CLEANUP();
}
}
isMember = FALSE;
cleanup:
UNLOCK_RWLOCK(&AccessToken->RwLock, isLocked);
return isMember;
}
NTSTATUS
PvfsReadDirectoryChange(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
PIRP pIrp = pIrpContext->pIrp;
IRP_ARGS_READ_DIRECTORY_CHANGE Args = pIrp->Args.ReadDirectoryChange;
PPVFS_CCB pCcb = NULL;
PULONG pMaxBufferSize = Args.MaxBufferSize;
/* Sanity checks */
ntError = PvfsAcquireCCB(pIrp->FileHandle, &pCcb);
BAIL_ON_NT_STATUS(ntError);
if (!IsSetFlag(pCcb->Flags, PVFS_CCB_FLAG_CREATE_COMPLETE))
{
ntError = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntError);
}
if (!PVFS_IS_DIR(pCcb))
{
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsAccessCheckFileHandle(pCcb, FILE_LIST_DIRECTORY);
BAIL_ON_NT_STATUS(ntError);
BAIL_ON_INVALID_PTR(Args.Buffer, ntError);
BAIL_ON_ZERO_LENGTH(Args.Length, ntError);
/* If we have something in the buffer, return that immediately. Else
register a notification filter */
LWIO_ASSERT(pCcb->pScb->pOwnerFcb);
ntError = PvfsNotifyReportBufferedChanges(
pCcb,
pCcb->pScb->pOwnerFcb,
pIrpContext);
if (ntError == STATUS_NOT_FOUND)
{
PvfsIrpMarkPending(pIrpContext, PvfsQueueCancelIrp, pIrpContext);
LWIO_ASSERT(pCcb->pScb->pOwnerFcb);
ntError = PvfsNotifyAddFilter(
pCcb->pScb->pOwnerFcb,
pIrpContext,
pCcb,
Args.NotifyFilter,
Args.WatchTree,
pMaxBufferSize);
if (ntError == STATUS_SUCCESS)
{
pIrpContext->QueueType = PVFS_QUEUE_TYPE_NOTIFY;
if (!pIrpContext->pScb)
{
pIrpContext->pScb = PvfsReferenceSCB(pCcb->pScb);
}
/* Allow the call to be cancelled while in the queue */
PvfsIrpContextClearFlag(pIrpContext, PVFS_IRP_CTX_FLAG_ACTIVE);
ntError = STATUS_PENDING;
goto cleanup;
}
}
BAIL_ON_NT_STATUS(ntError);
cleanup:
if (pCcb)
{
PvfsReleaseCCB(pCcb);
}
return ntError;
error:
if (PvfsIrpContextCheckFlag(pIrpContext, PVFS_IRP_CTX_FLAG_PENDED))
{
pIrpContext->pIrp->IoStatusBlock.Status = ntError;
PvfsCompleteIrpContext(pIrpContext);
}
goto cleanup;
}
void AircraftClass::DoCountermeasures (void)
{
// 2000-11-17 ADDED BY S.G. SO AIRCRAFT HAVE A FLAG TELLING IF THEY CARRY CHAFFS/FLARES OR NOT
if (!(GetVehicleClassData(Type() - VU_LAST_ENTITY_TYPE)->Flags & 0x40000000))
return;
// END OF ADDED SECTION
if (mFaults && (mFaults->GetFault(FaultClass::cmds_fault) & FaultClass::bus))
return;
if (!IsSetFlag(ON_GROUND))
{
if (dropFlareCmd) {
if (!(mFaults && (mFaults->GetFault(FaultClass::cmds_fault) & FaultClass::flar)))
{
DropFlare();
}
dropFlareCmd = FALSE;
}
else if (dropChaffCmd) {
if (!(mFaults && (mFaults->GetFault(FaultClass::cmds_fault) & FaultClass::chaf)))
{
DropChaff();
}
dropChaffCmd = FALSE;
}
else if (dropProgrammedStep)
{
// Run the countdown to the next programmed event
// 2000-09-02 S.G. dropProgrammedTimer IS int WHILE SimLibMajorFrameTime
// IS A float LESS THAN 1.0! NO WONDER IT'S NOT WORKING! ONLY USE int FOR NOW ON
//if (dropProgrammedTimer > SimLibMajorFrameTime)
if (dropProgrammedTimer + AutoProgramTiming < SimLibElapsedTime)
// {
// // Not time yet. Just keep counting down
// dropProgrammedTimer -= FloatToInt32(SimLibMajorFrameTime);
// }
// else
{
// Time to do something
switch (dropProgrammedStep) {
case 3:
dropChaffCmd = TRUE;
break;
case 2:
dropFlareCmd = TRUE;
break;
case 1:
dropChaffCmd = TRUE;
break;
default:
ShiWarning( "Bad counter measures program step" );
dropProgrammedStep = 1;
}
// Set the next state
dropProgrammedStep--;
// 2000-09-02 S.G. NEED TO SET IT TO SimLibElapsedTime INSTEAD
//dropProgrammedTimer = AutoProgramTiming;
dropProgrammedTimer = SimLibElapsedTime;
}
}
}
if (ChaffExpireTime() < SimLibElapsedTime)
{
SetChaffExpireTime( 0 );
SetNewestChaffID( FalconNullId );
}
if (FlareExpireTime() < SimLibElapsedTime)
{
//me123 for flare timing SetFlareExpireTime( 0 );
SetNewestFlareID( FalconNullId );
}
}
void AircraftClass::DropFlare (void)
{
vector pos, posDelta;
int type;
BombClass *weapon;
if (counterMeasureStation[FLARE_STATION].weaponCount > 0)
{
if (this == FalconLocalSession->GetPlayerEntity())
g_intellivibeData.FlareDropped++;
{
static int chaffsid=0; // just need a fake id so multiple chaffs can play at once.
chaffsid = (chaffsid + 1) & 0xf;
SoundPos.Sfx( af->auxaeroData->sndBBFlare, chaffsid);
}
/*
pos.x = XPos();
pos.y = YPos();
pos.z = ZPos();
posDelta.x = XDelta() * 0.75F;
posDelta.y = YDelta() * 0.75F;
posDelta.z = ZDelta() * 0.75F;
*/
// MLR 2003-11-16 New positional dispensers
int NumToLaunch = 1;
if(af->auxaeroData->Flare.Sequence==2)
{
NumToLaunch=af->auxaeroData->Flare.Count;
}
int i;
for(i=0;i<NumToLaunch && counterMeasureStation[FLARE_STATION].weaponCount > 0;i++)
{
counterMeasureStation[FLARE_STATION].weaponCount--;
Tpoint work;
MatrixMult( &((DrawableBSP*)af->platform->drawPointer)->orientation, &af->auxaeroData->Flare.Pos[flareDispenser], &work );
pos.x=work.x + XPos();
pos.y=work.y + YPos();
pos.z=work.z + ZPos();
MatrixMult( &((DrawableBSP*)af->platform->drawPointer)->orientation, &af->auxaeroData->Flare.Vec[flareDispenser], &work );
posDelta.x=work.x + XDelta();
posDelta.y=work.y + YDelta();
posDelta.z=work.z + ZDelta();
switch(af->auxaeroData->Flare.Sequence)
{
case 0: // alternate dispensers;
case 2:
flareDispenser++;
if(flareDispenser>=af->auxaeroData->Flare.Count)
flareDispenser=0;
break;
case 1: // use 1 dispenser, then move to the next
default:
flareUsed++;
if(flareUsed>=af->auxaeroData->Flare.Decoys[flareDispenser])
{
flareUsed=0;
flareDispenser++;
if(flareDispenser>=af->auxaeroData->Flare.Count)
flareDispenser=0;
}
break;
}
//type = GetClassID (DOMAIN_AIR, CLASS_VEHICLE, TYPE_BOMB, STYPE_BOMB_IRON, SPTYPE_MK82, VU_ANY, VU_ANY, VU_ANY) + VU_LAST_ENTITY_TYPE; // JB 010220
type = GetClassID (DOMAIN_AIR, CLASS_VEHICLE, TYPE_BOMB, STYPE_FLARE1, SPTYPE_CHAFF1 + 1, VU_ANY, VU_ANY, VU_ANY) + VU_LAST_ENTITY_TYPE; // JB 010220
weapon = new FlareClass (type);
weapon->Init();
weapon->SetParent(this);
weapon->Start(&pos, &posDelta, 0.2f);
vuDatabase->/*Quick*/Insert(weapon);
weapon->Wake();
}
SetFlareExpireTime( SimLibElapsedTime + FlareTime );
SetNewestFlareID( weapon->Id() );
}
//MI for EWS stuff
if(g_bRealisticAvionics && this == FalconLocalSession->GetPlayerEntity())
{
if(counterMeasureStation[FLARE_STATION].weaponCount == 0)
{
//F4SoundFXSetDist(af->auxaeroData->sndBBChaffFlareOut, TRUE, 0.0f, 1.0f);
SoundPos.Sfx(af->auxaeroData->sndBBChaffFlareOut);
//make sure we don't get here again, no sounds from now on
counterMeasureStation[FLARE_STATION].weaponCount--;
}
else if(OTWDriver.pCockpitManager->mpIcp->FlareBingo == counterMeasureStation[FLARE_STATION].weaponCount)
{
if(OTWDriver.pCockpitManager->mpIcp->EWS_BINGO_ON)
SoundPos.Sfx(af->auxaeroData->sndBBChaffFlareLow);
//F4SoundFXSetDist( af->auxaeroData->sndBBChaffFlareLow, TRUE, 0.0f, 1.0f );
}
//MI moved further down
/*else if(counterMeasureStation[FLARE_STATION].weaponCount > 0)
F4SoundFXSetDist(SFX_BB_CHAFLARE, FALSE, 0.0f, 1.0f);*/
}
// If this is the player and they want unlimited chaff, let 'em have it
if (IsSetFlag(MOTION_OWNSHIP) && PlayerOptions.UnlimitedChaff())
counterMeasureStation[FLARE_STATION].weaponCount++;
}
void AircraftClass::DropChaff (void)
{
vector pos, posDelta;
int type;
BombClass *weapon;
if (counterMeasureStation[CHAFF_STATION].weaponCount > 0)
{
if (this == FalconLocalSession->GetPlayerEntity())
g_intellivibeData.ChaffDropped++;
/*
pos.x = XPos();
pos.y = YPos();
pos.z = ZPos();
posDelta.x = XDelta() * 0.75F;
posDelta.y = YDelta() * 0.75F;
posDelta.z = ZDelta() * 0.75F;
*/
// new positional Dispensers
int NumToLaunch = 1;
if(af->auxaeroData->Chaff.Sequence==2)
{
NumToLaunch=af->auxaeroData->Chaff.Count;
}
int i;
for(i=0;i<NumToLaunch && counterMeasureStation[CHAFF_STATION].weaponCount > 0;i++)
{
counterMeasureStation[CHAFF_STATION].weaponCount--;
Tpoint work;
MatrixMult( &((DrawableBSP*)af->platform->drawPointer)->orientation, &af->auxaeroData->Chaff.Pos[chaffDispenser], &work );
pos.x=work.x + XPos();
pos.y=work.y + YPos();
pos.z=work.z + ZPos();
MatrixMult( &((DrawableBSP*)af->platform->drawPointer)->orientation, &af->auxaeroData->Chaff.Vec[chaffDispenser], &work );
posDelta.x=work.x + XDelta();
posDelta.y=work.y + YDelta();
posDelta.z=work.z + ZDelta();
switch(af->auxaeroData->Chaff.Sequence)
{
case 0: // alternate dispensers;
case 2:
chaffDispenser++;
if(chaffDispenser>=af->auxaeroData->Chaff.Count)
chaffDispenser=0;
break;
case 1: // use 1 dispenser, then move to the next
default:
chaffUsed++;
if(chaffUsed>=af->auxaeroData->Chaff.Decoys[chaffDispenser])
{
chaffUsed=0;
chaffDispenser++;
if(chaffDispenser>=af->auxaeroData->Chaff.Count)
chaffDispenser=0;
}
break;
}
// TODO: Use a different (much higher drag) type for the chaff
//type = GetClassID (DOMAIN_AIR, CLASS_SFX, TYPE_CHAFF, STYPE_CHAFF, SPTYPE_CHAFF1, VU_ANY, VU_ANY, VU_ANY) + VU_LAST_ENTITY_TYPE; // JB 010220
type = GetClassID (DOMAIN_AIR, CLASS_VEHICLE, TYPE_BOMB, STYPE_CHAFF, SPTYPE_CHAFF1, VU_ANY, VU_ANY, VU_ANY) + VU_LAST_ENTITY_TYPE; // JB 010220
weapon = new ChaffClass(type);
weapon->Init();
weapon->SetParent(this);
weapon->Start(&pos, &posDelta, 0.2f);
vuDatabase->/*Quick*/Insert(weapon);
weapon->Wake();
}
SetChaffExpireTime( SimLibElapsedTime + ChaffTime );
SetNewestChaffID( weapon->Id() );
}
//MI for EWS stuff
if(g_bRealisticAvionics && this == FalconLocalSession->GetPlayerEntity())
{
if(counterMeasureStation[CHAFF_STATION].weaponCount == 0)
{
SoundPos.Sfx(af->auxaeroData->sndBBChaffFlareOut);
//make sure we don't get here again, no sounds from now on
counterMeasureStation[CHAFF_STATION].weaponCount--;
}
else if(OTWDriver.pCockpitManager->mpIcp->ChaffBingo == counterMeasureStation[CHAFF_STATION].weaponCount)
{
if(OTWDriver.pCockpitManager->mpIcp->EWS_BINGO_ON)
SoundPos.Sfx(af->auxaeroData->sndBBChaffFlareLow);
}
//MI Moved further down
/*if(counterMeasureStation[CHAFF_STATION].weaponCount > 0)
F4SoundFXSetDist(SFX_BB_CHAFLARE, FALSE, 0.0f, 1.0f);*/
}
// If this is the player and they want unlimited chaff, let 'em have it
if (IsSetFlag(MOTION_OWNSHIP) && PlayerOptions.UnlimitedChaff())
counterMeasureStation[CHAFF_STATION].weaponCount++;
}
static
NTSTATUS
PvfsCreateDirOpenIf(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
IRP_ARGS_CREATE Args = pIrpContext->pIrp->Args.Create;
PPVFS_PENDING_CREATE pCreateCtx = NULL;
PVFS_STAT statPath = { 0 };
PVFS_STAT statFile = { 0 };
PPVFS_FILE_NAME directoryName = NULL;
PPVFS_FILE_NAME resolvedDirName = NULL;
PPVFS_FILE_NAME relativeFileName = NULL;
ntError = PvfsAllocateCreateContext(&pCreateCtx, pIrpContext);
BAIL_ON_NT_STATUS(ntError);
if (IsSetFlag(
pCreateCtx->OriginalFileName->NameOptions,
PVFS_FILE_NAME_OPTION_DEFINED_STREAM_TYPE))
{
// Disallow named streams here (shouldn't happen) and "::$DATA"
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsSplitFileNamePath(
&directoryName,
&relativeFileName,
pCreateCtx->OriginalFileName);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsLookupPath2(
&resolvedDirName,
&statPath,
directoryName,
IsSetFlag(Args.FileName.IoNameOptions, IO_NAME_OPTION_CASE_SENSITIVE));
BAIL_ON_NT_STATUS(ntError);
/* Check for file existence */
ntError = PvfsLookupFile2(
&pCreateCtx->ResolvedFileName,
&statFile,
directoryName,
relativeFileName,
IsSetFlag(Args.FileName.IoNameOptions, IO_NAME_OPTION_CASE_SENSITIVE));
pCreateCtx->bFileExisted = NT_SUCCESS(ntError) ? TRUE : FALSE;
if (!pCreateCtx->bFileExisted)
{
ntError = PvfsAppendFileName(
&pCreateCtx->ResolvedFileName,
resolvedDirName,
relativeFileName);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsAccessCheckFile(
pCreateCtx->pCcb->pUserToken,
resolvedDirName,
FILE_ADD_SUBDIRECTORY,
&pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
pCreateCtx->GrantedAccess = PvfsGetGrantedAccessForNewObject(
Args.DesiredAccess);
}
else
{
if (!S_ISDIR(statFile.s_mode))
{
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsAccessCheckFile(
pCreateCtx->pCcb->pUserToken,
pCreateCtx->ResolvedFileName,
Args.DesiredAccess,
&pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsCheckDosAttributes(
Args,
pCreateCtx->bFileExisted ? pCreateCtx->ResolvedFileName : NULL,
pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCheckShareMode(
pCreateCtx->ResolvedFileName,
Args.ShareAccess,
pCreateCtx->GrantedAccess,
&pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateFileCheckPendingDelete(pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
if (!pCreateCtx->bFileExisted)
{
pCreateCtx->SetPropertyFlags = PVFS_SET_PROP_SECURITY|
PVFS_SET_PROP_ATTRIB;
}
ntError = PvfsAddCCBToSCB(pCreateCtx->pScb, pCreateCtx->pCcb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateDirDoSysOpen(pCreateCtx);
BAIL_ON_NT_STATUS(ntError);
cleanup:
PvfsFreeCreateContext(OUT_PPVOID(&pCreateCtx));
if (directoryName)
{
PvfsFreeFileName(directoryName);
}
if (relativeFileName)
{
PvfsFreeFileName(relativeFileName);
}
if (resolvedDirName)
{
PvfsFreeFileName(resolvedDirName);
}
return ntError;
error:
if (ntError != STATUS_PENDING)
{
pIrpContext->pIrp->IoStatusBlock.CreateResult =
PvfsSetCreateResult(
Args.CreateDisposition,
pCreateCtx ? pCreateCtx->bFileExisted : FALSE,
ntError);
}
if (pCreateCtx &&
pCreateCtx->pCcb &&
pCreateCtx->pCcb->pDirContext &&
pCreateCtx->pCcb->pDirContext->pDir)
{
PvfsSysCloseDir(pCreateCtx->pCcb->pDirContext->pDir);
}
goto cleanup;
}
static
NTSTATUS
PvfsCreateDirOpen(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
IRP_ARGS_CREATE Args = pIrpContext->pIrp->Args.Create;
PPVFS_PENDING_CREATE pCreateCtx = NULL;
PVFS_STAT Stat = {0};
ntError = PvfsAllocateCreateContext(&pCreateCtx, pIrpContext);
BAIL_ON_NT_STATUS(ntError);
if (IsSetFlag(
pCreateCtx->OriginalFileName->NameOptions,
PVFS_FILE_NAME_OPTION_DEFINED_STREAM_TYPE))
{
// Disallow named streams here (shouldn't happen) and "::$DATA"
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsLookupPath2(
&pCreateCtx->ResolvedFileName,
&Stat,
pCreateCtx->OriginalFileName,
IsSetFlag(Args.FileName.IoNameOptions, IO_NAME_OPTION_CASE_SENSITIVE));
BAIL_ON_NT_STATUS(ntError);
if (!S_ISDIR(Stat.s_mode))
{
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
ntError = PvfsAccessCheckFile(
pCreateCtx->pCcb->pUserToken,
pCreateCtx->ResolvedFileName,
Args.DesiredAccess,
&pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCheckDosAttributes(
Args,
pCreateCtx->bFileExisted ? pCreateCtx->ResolvedFileName : NULL,
pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCheckShareMode(
pCreateCtx->ResolvedFileName,
Args.ShareAccess,
pCreateCtx->GrantedAccess,
&pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateFileCheckPendingDelete(pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCheckQuotaFile(&Args, pCreateCtx->pCcb);
BAIL_ON_NT_STATUS(ntError);
pCreateCtx->bFileExisted = TRUE;
ntError = PvfsAddCCBToSCB(pCreateCtx->pScb, pCreateCtx->pCcb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateDirDoSysOpen(pCreateCtx);
BAIL_ON_NT_STATUS(ntError);
cleanup:
PvfsFreeCreateContext(OUT_PPVOID(&pCreateCtx));
return ntError;
error:
if (ntError != STATUS_PENDING)
{
pIrpContext->pIrp->IoStatusBlock.CreateResult =
PvfsSetCreateResult(
Args.CreateDisposition,
pCreateCtx ? pCreateCtx->bFileExisted : FALSE,
ntError);
}
if (pCreateCtx &&
pCreateCtx->pCcb &&
pCreateCtx->pCcb->pDirContext &&
pCreateCtx->pCcb->pDirContext->pDir)
{
PvfsSysCloseDir(pCreateCtx->pCcb->pDirContext->pDir);
}
goto cleanup;
}
static
NTSTATUS
PvfsCreateDirCreate(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_UNSUCCESSFUL;
IRP_ARGS_CREATE Args = pIrpContext->pIrp->Args.Create;
PPVFS_PENDING_CREATE pCreateCtx = NULL;
PVFS_STAT statPath = { 0 };
PPVFS_FILE_NAME directoryName = NULL;
PPVFS_FILE_NAME relativeFileName = NULL;
PPVFS_FILE_NAME resolvedDirName = NULL;
ntError = PvfsAllocateCreateContext(&pCreateCtx, pIrpContext);
BAIL_ON_NT_STATUS(ntError);
if (IsSetFlag(
pCreateCtx->OriginalFileName->NameOptions,
PVFS_FILE_NAME_OPTION_DEFINED_STREAM_TYPE))
{
// Disallow named streams here (shouldn't happen) and "::$DATA"
ntError = STATUS_NOT_A_DIRECTORY;
BAIL_ON_NT_STATUS(ntError);
}
/* We expect this call to fail with OBJECT_NAME_NOT_FOUND */
ntError = PvfsLookupPath2(
&pCreateCtx->ResolvedFileName,
&statPath,
pCreateCtx->OriginalFileName,
IsSetFlag(Args.FileName.IoNameOptions, IO_NAME_OPTION_CASE_SENSITIVE));
switch (ntError)
{
case STATUS_SUCCESS:
ntError = STATUS_OBJECT_NAME_COLLISION;
break;
case STATUS_OBJECT_NAME_NOT_FOUND:
ntError = STATUS_SUCCESS;
break;
default:
/* do nothing */
break;
}
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsSplitFileNamePath(
&directoryName,
&relativeFileName,
pCreateCtx->OriginalFileName);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsLookupPath2(
&resolvedDirName,
&statPath,
directoryName,
IsSetFlag(Args.FileName.IoNameOptions, IO_NAME_OPTION_CASE_SENSITIVE));
if (ntError == STATUS_OBJECT_NAME_NOT_FOUND)
{
ntError = STATUS_OBJECT_PATH_NOT_FOUND;
}
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsAppendFileName(
&pCreateCtx->ResolvedFileName,
resolvedDirName,
relativeFileName);
BAIL_ON_NT_STATUS(ntError);
/* check parent here */
ntError = PvfsAccessCheckFile(
pCreateCtx->pCcb->pUserToken,
resolvedDirName,
FILE_ADD_SUBDIRECTORY,
&pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
pCreateCtx->GrantedAccess = PvfsGetGrantedAccessForNewObject(
Args.DesiredAccess);
ntError = PvfsCheckDosAttributes(
Args,
NULL, /* New directory */
pCreateCtx->GrantedAccess);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCheckShareMode(
pCreateCtx->ResolvedFileName,
Args.ShareAccess,
pCreateCtx->GrantedAccess,
&pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateFileCheckPendingDelete(pCreateCtx->pScb);
BAIL_ON_NT_STATUS(ntError);
pCreateCtx->bFileExisted = FALSE;
pCreateCtx->SetPropertyFlags = PVFS_SET_PROP_SECURITY|PVFS_SET_PROP_ATTRIB;
ntError = PvfsAddCCBToSCB(pCreateCtx->pScb, pCreateCtx->pCcb);
BAIL_ON_NT_STATUS(ntError);
ntError = PvfsCreateDirDoSysOpen(pCreateCtx);
BAIL_ON_NT_STATUS(ntError);
cleanup:
PvfsFreeCreateContext(OUT_PPVOID(&pCreateCtx));
if (directoryName)
{
PvfsFreeFileName(directoryName);
}
if (relativeFileName)
{
PvfsFreeFileName(relativeFileName);
}
if (resolvedDirName)
{
PvfsFreeFileName(resolvedDirName);
}
return ntError;
error:
if (ntError != STATUS_PENDING)
{
pIrpContext->pIrp->IoStatusBlock.CreateResult =
PvfsSetCreateResult(
Args.CreateDisposition,
pCreateCtx ? pCreateCtx->bFileExisted : FALSE,
ntError);
}
if (pCreateCtx &&
pCreateCtx->pCcb &&
pCreateCtx->pCcb->pDirContext &&
pCreateCtx->pCcb->pDirContext->pDir)
{
PvfsSysCloseDir(pCreateCtx->pCcb->pDirContext->pDir);
}
goto cleanup;
}
NTSTATUS
PvfsSetSecurityFile(
PPVFS_IRP_CONTEXT pIrpContext
)
{
NTSTATUS ntError = STATUS_ACCESS_DENIED;
PIRP pIrp = pIrpContext->pIrp;
PPVFS_CCB pCcb = NULL;
PSECURITY_DESCRIPTOR_RELATIVE pSecDesc = NULL;
ULONG SecDescLength = 0;
SECURITY_INFORMATION SecInfo = 0;
IRP_ARGS_QUERY_SET_SECURITY Args = pIrpContext->pIrp->Args.QuerySetSecurity;
ACCESS_MASK RequiredMask = 0;
/* Sanity checks */
ntError = PvfsAcquireCCB(pIrp->FileHandle, &pCcb);
BAIL_ON_NT_STATUS(ntError);
if (!IsSetFlag(pCcb->Flags, PVFS_CCB_FLAG_CREATE_COMPLETE))
{
ntError = STATUS_INVALID_PARAMETER;
BAIL_ON_NT_STATUS(ntError);
}
BAIL_ON_INVALID_PTR(Args.SecurityDescriptor, ntError);
pSecDesc = Args.SecurityDescriptor;
SecDescLength = Args.Length;
SecInfo = Args.SecurityInformation;
if (SecInfo & OWNER_SECURITY_INFORMATION) {
RequiredMask |= WRITE_OWNER;
}
if (SecInfo & GROUP_SECURITY_INFORMATION) {
RequiredMask |= WRITE_OWNER;
}
if (SecInfo & DACL_SECURITY_INFORMATION) {
RequiredMask |= WRITE_DAC;
}
if (SecInfo & SACL_SECURITY_INFORMATION) {
RequiredMask |= ACCESS_SYSTEM_SECURITY;
}
ntError = PvfsAccessCheckFileHandle(pCcb, RequiredMask);
BAIL_ON_NT_STATUS(ntError);
/* Real work starts here */
ntError = PvfsSetSecurityDescriptorFile(pCcb,
SecInfo,
pSecDesc,
SecDescLength);
BAIL_ON_NT_STATUS(ntError);
pIrp->IoStatusBlock.BytesTransferred = 0;
ntError = STATUS_SUCCESS;
cleanup:
if (pCcb) {
PvfsReleaseCCB(pCcb);
}
return ntError;
error:
goto cleanup;
}
