2 * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3 * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
10 * - Redistributions of source code must retain the above copyright notice,
11 * this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
14 * this list of conditions and the following disclaimer in the
16 * and/or other materials provided with the distribution.
17 * - Neither the names of Kernel Drivers, LLC and Your File System, Inc.
18 * nor the names of their contributors may be used to endorse or promote
19 * products derived from this software without specific prior written
20 * permission from Kernel Drivers, LLC and Your File System, Inc.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
25 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
26 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 // File: AFSGeneric.cpp
39 #include "AFSCommon.h"
42 // Function: AFSExceptionFilter
46 // This function is the exception handler
50 // A status is returned for the function
54 AFSExceptionFilter( IN ULONG Code,
55 IN PEXCEPTION_POINTERS ExceptPtrs)
58 PEXCEPTION_RECORD ExceptRec;
64 ExceptRec = ExceptPtrs->ExceptionRecord;
66 Context = ExceptPtrs->ContextRecord;
70 "AFSExceptionFilter (Framework) - EXR %p CXR %p Code %08lX Address %p\n",
73 ExceptRec->ExceptionCode,
74 ExceptRec->ExceptionAddress);
76 DbgPrint("**** Exception Caught in AFS Redirector ****\n");
78 DbgPrint("\n\nPerform the following WnDbg Cmds:\n");
79 DbgPrint("\n\t.exr %p ; .cxr %p\n\n", ExceptRec, Context);
81 DbgPrint("**** Exception Complete from AFS Redirector ****\n");
83 if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
86 KeBugCheck( (ULONG)-2);
94 __except( EXCEPTION_EXECUTE_HANDLER)
100 return EXCEPTION_EXECUTE_HANDLER;
104 // Function: AFSAcquireExcl()
106 // Purpose: Called to acquire a resource exclusive with optional wait
109 // PERESOURCE Resource - Resource to acquire
110 // BOOLEAN Wait - Whether to block
113 // BOOLEAN - Whether the mask was acquired
117 AFSAcquireExcl( IN PERESOURCE Resource,
121 BOOLEAN bStatus = FALSE;
124 // Normal kernel APCs must be disabled before calling
125 // ExAcquireResourceExclusiveLite. Otherwise a bugcheck occurs.
128 KeEnterCriticalRegion();
130 bStatus = ExAcquireResourceExclusiveLite( Resource,
136 KeLeaveCriticalRegion();
143 AFSAcquireSharedStarveExclusive( IN PERESOURCE Resource,
147 BOOLEAN bStatus = FALSE;
149 KeEnterCriticalRegion();
151 bStatus = ExAcquireSharedStarveExclusive( Resource,
157 KeLeaveCriticalRegion();
164 // Function: AFSAcquireShared()
166 // Purpose: Called to acquire a resource shared with optional wait
169 // PERESOURCE Resource - Resource to acquire
170 // BOOLEAN Wait - Whether to block
173 // BOOLEAN - Whether the mask was acquired
177 AFSAcquireShared( IN PERESOURCE Resource,
181 BOOLEAN bStatus = FALSE;
183 KeEnterCriticalRegion();
185 bStatus = ExAcquireResourceSharedLite( Resource,
191 KeLeaveCriticalRegion();
198 // Function: AFSReleaseResource()
200 // Purpose: Called to release a resource
203 // PERESOURCE Resource - Resource to release
210 AFSReleaseResource( IN PERESOURCE Resource)
213 if( Resource != &AFSDbgLogLock)
216 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
217 AFS_TRACE_LEVEL_VERBOSE,
218 "AFSReleaseResource Releasing lock %08lX Thread %08lX\n",
220 PsGetCurrentThread());
223 ExReleaseResourceLite( Resource);
225 KeLeaveCriticalRegion();
231 AFSConvertToShared( IN PERESOURCE Resource)
234 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
235 AFS_TRACE_LEVEL_VERBOSE,
236 "AFSConvertToShared Converting lock %08lX Thread %08lX\n",
238 PsGetCurrentThread());
240 ExConvertExclusiveToSharedLite( Resource);
246 // Function: AFSCompleteRequest
250 // This function completes irps
254 // A status is returned for the function
258 AFSCompleteRequest( IN PIRP Irp,
262 Irp->IoStatus.Status = Status;
264 IoCompleteRequest( Irp,
271 AFSReadRegistry( IN PUNICODE_STRING RegistryPath)
274 NTSTATUS ntStatus = STATUS_SUCCESS;
276 UNICODE_STRING paramPath;
278 RTL_QUERY_REGISTRY_TABLE paramTable[2];
279 UNICODE_STRING defaultUnicodeName;
280 WCHAR SubKeyString[] = L"\\Parameters";
283 // Setup the paramPath buffer.
286 paramPath.MaximumLength = RegistryPath->Length + sizeof( SubKeyString);
287 paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
288 paramPath.MaximumLength,
289 AFS_GENERIC_MEMORY_15_TAG);
291 RtlInitUnicodeString( &defaultUnicodeName,
295 // If it exists, setup the path.
298 if( paramPath.Buffer != NULL)
305 RtlCopyMemory( ¶mPath.Buffer[ 0],
306 &RegistryPath->Buffer[ 0],
307 RegistryPath->Length);
309 RtlCopyMemory( ¶mPath.Buffer[ RegistryPath->Length / 2],
311 sizeof( SubKeyString));
313 paramPath.Length = paramPath.MaximumLength;
315 RtlZeroMemory( paramTable,
316 sizeof( paramTable));
321 // Setup the table to query the registry for the needed value
324 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
325 paramTable[0].Name = AFS_REG_DEBUG_FLAGS;
326 paramTable[0].EntryContext = &Value;
328 paramTable[0].DefaultType = REG_DWORD;
329 paramTable[0].DefaultData = &Default;
330 paramTable[0].DefaultLength = sizeof (ULONG) ;
333 // Query the registry
336 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
342 if( NT_SUCCESS( ntStatus))
345 AFSDebugFlags = Value;
348 RtlZeroMemory( paramTable,
349 sizeof( paramTable));
354 // Setup the table to query the registry for the needed value
357 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
358 paramTable[0].Name = AFS_REG_TRACE_SUBSYSTEM;
359 paramTable[0].EntryContext = &Value;
361 paramTable[0].DefaultType = REG_DWORD;
362 paramTable[0].DefaultData = &Default;
363 paramTable[0].DefaultLength = sizeof (ULONG) ;
366 // Query the registry
369 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
375 if( NT_SUCCESS( ntStatus))
378 AFSTraceComponent = Value;
381 RtlZeroMemory( paramTable,
382 sizeof( paramTable));
387 // Setup the table to query the registry for the needed value
390 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
391 paramTable[0].Name = AFS_REG_TRACE_BUFFER_LENGTH;
392 paramTable[0].EntryContext = &Value;
394 paramTable[0].DefaultType = REG_DWORD;
395 paramTable[0].DefaultData = &Default;
396 paramTable[0].DefaultLength = sizeof (ULONG);
399 // Query the registry
402 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
408 if( NT_SUCCESS( ntStatus) &&
412 AFSDbgBufferLength = Value;
415 // Let's limit things a bit ...
418 if( AFSDbgBufferLength > 10240)
421 AFSDbgBufferLength = 1024;
427 AFSDbgBufferLength = 0;
434 AFSDbgBufferLength *= 1024;
437 // Now get ready to set up for MaxServerDirty
440 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
441 paramTable[0].Name = AFS_REG_MAX_DIRTY;
442 paramTable[0].EntryContext = &Value;
444 paramTable[0].DefaultType = REG_DWORD;
445 paramTable[0].DefaultData = &Default;
446 paramTable[0].DefaultLength = sizeof (ULONG) ;
449 // Query the registry
452 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
458 if( NT_SUCCESS( ntStatus))
461 AFSMaxDirtyFile = Value;
464 RtlZeroMemory( paramTable,
465 sizeof( paramTable));
470 // Setup the table to query the registry for the needed value
473 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
474 paramTable[0].Name = AFS_REG_TRACE_LEVEL;
475 paramTable[0].EntryContext = &Value;
477 paramTable[0].DefaultType = REG_DWORD;
478 paramTable[0].DefaultData = &Default;
479 paramTable[0].DefaultLength = sizeof (ULONG) ;
482 // Query the registry
485 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
491 if( NT_SUCCESS( ntStatus))
494 AFSTraceLevel = Value;
501 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
502 paramTable[0].Name = AFS_REG_MAX_IO;
503 paramTable[0].EntryContext = &Value;
505 paramTable[0].DefaultType = REG_DWORD;
506 paramTable[0].DefaultData = &Default;
507 paramTable[0].DefaultLength = sizeof (ULONG) ;
510 // Query the registry
513 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
519 if( NT_SUCCESS( ntStatus))
522 AFSMaxDirectIo = Value;
526 // Now set up for ShutdownStatus query
529 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
530 paramTable[0].Name = AFS_REG_SHUTDOWN_STATUS;
531 paramTable[0].EntryContext = &Value;
533 paramTable[0].DefaultType = REG_DWORD;
534 paramTable[0].DefaultData = &Default;
535 paramTable[0].DefaultLength = sizeof (ULONG) ;
538 // Query the registry
541 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
547 if( !NT_SUCCESS( ntStatus) ||
551 SetFlag( AFSDebugFlags, AFS_DBG_CLEAN_SHUTDOWN);
555 // Now set up for RequireCleanShutdown query
558 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
559 paramTable[0].Name = AFS_REG_REQUIRE_CLEAN_SHUTDOWN;
560 paramTable[0].EntryContext = &Value;
562 paramTable[0].DefaultType = REG_DWORD;
563 paramTable[0].DefaultData = &Default;
564 paramTable[0].DefaultLength = sizeof (ULONG) ;
567 // Query the registry
570 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_ABSOLUTE | RTL_REGISTRY_OPTIONAL,
576 if( !NT_SUCCESS( ntStatus) ||
580 SetFlag( AFSDebugFlags, AFS_DBG_REQUIRE_CLEAN_SHUTDOWN);
584 // Free up the buffer
587 ExFreePool( paramPath.Buffer);
589 ntStatus = STATUS_SUCCESS;
593 ntStatus = STATUS_INSUFFICIENT_RESOURCES;
600 AFSUpdateRegistryParameter( IN PUNICODE_STRING ValueName,
603 IN ULONG ValueDataLength)
606 NTSTATUS ntStatus = STATUS_SUCCESS;
607 UNICODE_STRING paramPath, uniParamKey;
608 HANDLE hParameters = 0;
609 ULONG ulDisposition = 0;
610 OBJECT_ATTRIBUTES stObjectAttributes;
615 RtlInitUnicodeString( &uniParamKey,
619 // Setup the paramPath buffer.
622 paramPath.MaximumLength = AFSRegistryPath.Length + uniParamKey.Length;
623 paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
624 paramPath.MaximumLength,
625 AFS_GENERIC_MEMORY_16_TAG);
627 if( paramPath.Buffer == NULL)
630 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
637 RtlCopyMemory( paramPath.Buffer,
638 AFSRegistryPath.Buffer,
639 AFSRegistryPath.Length);
641 paramPath.Length = AFSRegistryPath.Length;
643 RtlCopyMemory( ¶mPath.Buffer[ paramPath.Length / 2],
647 paramPath.Length += uniParamKey.Length;
649 InitializeObjectAttributes( &stObjectAttributes,
651 OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE,
655 ntStatus = ZwOpenKey( &hParameters,
657 &stObjectAttributes);
659 if( !NT_SUCCESS( ntStatus))
662 try_return( ntStatus);
669 ntStatus = ZwSetValueKey( hParameters,
676 ZwClose( hParameters);
680 if( paramPath.Buffer != NULL)
684 // Free up the buffer
687 ExFreePool( paramPath.Buffer);
695 AFSInitializeControlDevice()
698 NTSTATUS ntStatus = STATUS_SUCCESS;
699 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
700 AFSProcessCB *pProcessCB = NULL;
706 // Initialize the comm pool resources
709 ExInitializeResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolLock);
711 ExInitializeResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.ResultPoolLock);
713 ExInitializeResourceLite( &pDeviceExt->Specific.Control.ExtentReleaseResource);
715 ExInitializeResourceLite( &pDeviceExt->Specific.Control.SysName32ListLock);
717 ExInitializeResourceLite( &pDeviceExt->Specific.Control.SysName64ListLock);
723 KeInitializeEvent( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolHasEntries,
727 KeInitializeEvent( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolHasReleaseEntries,
731 KeInitializeEvent( &pDeviceExt->Specific.Control.ExtentReleaseEvent,
735 pDeviceExt->Specific.Control.ExtentReleaseSequence = 0;
737 KeInitializeEvent( &pDeviceExt->Specific.Control.VolumeWorkerCloseEvent,
742 // Library support information
745 KeInitializeEvent( &pDeviceExt->Specific.Control.LoadLibraryEvent,
746 SynchronizationEvent,
750 // Initialize the library queued as cancelled
753 pDeviceExt->Specific.Control.LibraryState = AFS_LIBRARY_QUEUE_CANCELLED;
755 ExInitializeResourceLite( &pDeviceExt->Specific.Control.LibraryStateLock);
757 pDeviceExt->Specific.Control.InflightLibraryRequests = 0;
759 KeInitializeEvent( &pDeviceExt->Specific.Control.InflightLibraryEvent,
763 pDeviceExt->Specific.Control.ExtentCount = 0;
764 pDeviceExt->Specific.Control.ExtentsHeldLength = 0;
766 KeInitializeEvent( &pDeviceExt->Specific.Control.ExtentsHeldEvent,
770 pDeviceExt->Specific.Control.OutstandingServiceRequestCount = 0;
772 KeInitializeEvent( &pDeviceExt->Specific.Control.OutstandingServiceRequestEvent,
776 ExInitializeResourceLite( &pDeviceExt->Specific.Control.LibraryQueueLock);
778 pDeviceExt->Specific.Control.LibraryQueueHead = NULL;
780 pDeviceExt->Specific.Control.LibraryQueueTail = NULL;
783 // Set the initial state of the irp pool
786 pDeviceExt->Specific.Control.CommServiceCB.IrpPoolControlFlag = POOL_INACTIVE;
789 // Initialize our process and sid tree information
792 ExInitializeResourceLite( &pDeviceExt->Specific.Control.ProcessTreeLock);
794 pDeviceExt->Specific.Control.ProcessTree.TreeLock = &pDeviceExt->Specific.Control.ProcessTreeLock;
796 pDeviceExt->Specific.Control.ProcessTree.TreeHead = NULL;
798 ExInitializeResourceLite( &pDeviceExt->Specific.Control.AuthGroupTreeLock);
800 pDeviceExt->Specific.Control.AuthGroupTree.TreeLock = &pDeviceExt->Specific.Control.AuthGroupTreeLock;
802 pDeviceExt->Specific.Control.AuthGroupTree.TreeHead = NULL;
809 AFSRemoveControlDevice()
812 NTSTATUS ntStatus = STATUS_SUCCESS;
813 AFSDeviceExt *pDeviceExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
814 AFSProcessCB *pProcessCB = NULL;
820 // Initialize the comm pool resources
823 ExDeleteResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.IrpPoolLock);
825 ExDeleteResourceLite( &pDeviceExt->Specific.Control.CommServiceCB.ResultPoolLock);
827 ExDeleteResourceLite( &pDeviceExt->Specific.Control.ExtentReleaseResource);
829 ExDeleteResourceLite( &pDeviceExt->Specific.Control.SysName32ListLock);
831 ExDeleteResourceLite( &pDeviceExt->Specific.Control.SysName64ListLock);
833 ExDeleteResourceLite( &pDeviceExt->Specific.Control.ProcessTreeLock);
835 if( pDeviceExt->Specific.Control.ProcessTree.TreeHead != NULL)
837 ExFreePool( pDeviceExt->Specific.Control.ProcessTree.TreeHead);
840 ExDeleteResourceLite( &pDeviceExt->Specific.Control.AuthGroupTreeLock);
842 ExDeleteResourceLite( &pDeviceExt->Specific.Control.LibraryStateLock);
844 ExDeleteResourceLite( &pDeviceExt->Specific.Control.LibraryQueueLock);
851 AFSInitServerStrings()
854 UNICODE_STRING uniFullName;
855 WCHAR wchBuffer[ 50];
858 // Add the server name into the list of resources
861 uniFullName.Length = (2 * sizeof( WCHAR)) + AFSServerName.Length;
862 uniFullName.MaximumLength = uniFullName.Length + sizeof( WCHAR);
864 uniFullName.Buffer = wchBuffer;
866 wchBuffer[ 0] = L'\\';
867 wchBuffer[ 1] = L'\\';
869 RtlCopyMemory( &wchBuffer[ 2],
870 AFSServerName.Buffer,
871 AFSServerName.Length);
873 AFSAddConnectionEx( &uniFullName,
874 RESOURCEDISPLAYTYPE_SERVER,
878 // Add in the global share name
881 wchBuffer[ uniFullName.Length/sizeof( WCHAR)] = L'\\';
883 uniFullName.Length += sizeof( WCHAR);
885 RtlCopyMemory( &wchBuffer[ uniFullName.Length/sizeof( WCHAR)],
886 AFSGlobalRootName.Buffer,
887 AFSGlobalRootName.Length);
889 uniFullName.Length += AFSGlobalRootName.Length;
891 AFSAddConnectionEx( &uniFullName,
892 RESOURCEDISPLAYTYPE_SHARE,
893 AFS_CONNECTION_FLAG_GLOBAL_SHARE);
902 NTSTATUS ntStatus = STATUS_SUCCESS;
904 UNICODE_STRING paramPath;
905 RTL_QUERY_REGISTRY_TABLE paramTable[2];
911 // Setup the paramPath buffer.
914 paramPath.MaximumLength = PAGE_SIZE;
915 paramPath.Buffer = (PWSTR)AFSExAllocatePoolWithTag( PagedPool,
916 paramPath.MaximumLength,
917 AFS_GENERIC_MEMORY_17_TAG);
920 // If it exists, setup the path.
923 if( paramPath.Buffer == NULL)
926 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
933 RtlZeroMemory( paramPath.Buffer,
934 paramPath.MaximumLength);
936 RtlCopyMemory( ¶mPath.Buffer[ 0],
937 L"\\TransarcAFSDaemon\\Parameters",
940 paramPath.Length = 58;
942 RtlZeroMemory( paramTable,
943 sizeof( paramTable));
946 // Setup the table to query the registry for the needed value
949 AFSServerName.Length = 0;
950 AFSServerName.MaximumLength = 0;
951 AFSServerName.Buffer = NULL;
953 paramTable[0].Flags = RTL_QUERY_REGISTRY_DIRECT;
954 paramTable[0].Name = AFS_NETBIOS_NAME;
955 paramTable[0].EntryContext = &AFSServerName;
957 paramTable[0].DefaultType = REG_NONE;
958 paramTable[0].DefaultData = NULL;
959 paramTable[0].DefaultLength = 0;
962 // Query the registry
965 ntStatus = RtlQueryRegistryValues( RTL_REGISTRY_SERVICES,
972 // Free up the buffer
975 ExFreePool( paramPath.Buffer);
979 if( !NT_SUCCESS( ntStatus))
982 RtlInitUnicodeString( &AFSServerName,
991 AFSSetSysNameInformation( IN AFSSysNameNotificationCB *SysNameInfo,
992 IN ULONG SysNameInfoBufferLength)
995 NTSTATUS ntStatus = STATUS_SUCCESS;
996 AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
997 AFSSysNameCB *pSysName = NULL;
998 ERESOURCE *pSysNameLock = NULL;
999 AFSSysNameCB **pSysNameListHead = NULL, **pSysNameListTail = NULL;
1005 // Depending on the architecture of the information, set up the lsit
1008 if( SysNameInfo->Architecture == AFS_SYSNAME_ARCH_32BIT)
1011 pSysNameLock = &pControlDevExt->Specific.Control.SysName32ListLock;
1013 pSysNameListHead = &pControlDevExt->Specific.Control.SysName32ListHead;
1015 pSysNameListTail = &pControlDevExt->Specific.Control.SysName32ListTail;
1022 pSysNameLock = &pControlDevExt->Specific.Control.SysName64ListLock;
1024 pSysNameListHead = &pControlDevExt->Specific.Control.SysName64ListHead;
1026 pSysNameListTail = &pControlDevExt->Specific.Control.SysName64ListTail;
1030 try_return( ntStatus = STATUS_INVALID_PARAMETER);
1035 // Process the request
1038 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1039 AFS_TRACE_LEVEL_VERBOSE,
1040 "AFSSetSysNameInformation Acquiring SysName lock %08lX EXCL %08lX\n",
1042 PsGetCurrentThread());
1044 AFSAcquireExcl( pSysNameLock,
1048 // If we already have a list, then tear it down
1051 if( *pSysNameListHead != NULL)
1054 AFSResetSysNameList( *pSysNameListHead);
1056 *pSysNameListHead = NULL;
1060 // Loop through the entries adding in a node for each
1063 while( ulIndex < SysNameInfo->NumberOfNames)
1066 pSysName = (AFSSysNameCB *)AFSExAllocatePoolWithTag( PagedPool,
1067 sizeof( AFSSysNameCB) +
1068 SysNameInfo->SysNames[ ulIndex].Length +
1070 AFS_SYS_NAME_NODE_TAG);
1072 if( pSysName == NULL)
1076 // Reset the current list
1079 AFSResetSysNameList( *pSysNameListHead);
1081 *pSysNameListHead = NULL;
1083 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1086 RtlZeroMemory( pSysName,
1087 sizeof( AFSSysNameCB) +
1088 SysNameInfo->SysNames[ ulIndex].Length +
1091 pSysName->SysName.Length = (USHORT)SysNameInfo->SysNames[ ulIndex].Length;
1093 pSysName->SysName.MaximumLength = pSysName->SysName.Length + sizeof( WCHAR);
1095 pSysName->SysName.Buffer = (WCHAR *)((char *)pSysName + sizeof( AFSSysNameCB));
1097 RtlCopyMemory( pSysName->SysName.Buffer,
1098 SysNameInfo->SysNames[ ulIndex].String,
1099 pSysName->SysName.Length);
1101 if( *pSysNameListHead == NULL)
1104 *pSysNameListHead = pSysName;
1109 (*pSysNameListTail)->fLink = pSysName;
1112 *pSysNameListTail = pSysName;
1119 AFSReleaseResource( pSysNameLock);
1126 AFSResetSysNameList( IN AFSSysNameCB *SysNameList)
1129 AFSSysNameCB *pNextEntry = NULL, *pCurrentEntry = SysNameList;
1131 while( pCurrentEntry != NULL)
1134 pNextEntry = pCurrentEntry->fLink;
1136 ExFreePool( pCurrentEntry);
1138 pCurrentEntry = pNextEntry;
1145 AFSDefaultDispatch( IN PDEVICE_OBJECT DeviceObject,
1149 NTSTATUS ntStatus = STATUS_INVALID_DEVICE_REQUEST;
1150 PIO_STACK_LOCATION pIrpSp = IoGetCurrentIrpStackLocation( Irp);
1152 AFSCompleteRequest( Irp,
1159 AFSSendDeviceIoControl( IN DEVICE_OBJECT *TargetDeviceObject,
1161 IN void *InputBuffer,
1162 IN ULONG InputBufferLength,
1163 IN OUT void *OutputBuffer,
1164 IN ULONG OutputBufferLength,
1165 OUT ULONG *ResultLength)
1168 NTSTATUS ntStatus = STATUS_SUCCESS;
1171 PIO_STACK_LOCATION pIoStackLocation = NULL;
1177 // Initialize the event
1180 KeInitializeEvent( &kEvent,
1181 SynchronizationEvent,
1185 // Allocate an irp for this request. This could also come from a
1186 // private pool, for instance.
1189 pIrp = IoAllocateIrp( TargetDeviceObject->StackSize,
1195 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1199 // Build the IRP's main body
1202 pIrp->RequestorMode = KernelMode;
1205 // Set up the I/O stack location.
1208 pIoStackLocation = IoGetNextIrpStackLocation( pIrp);
1209 pIoStackLocation->MajorFunction = IRP_MJ_DEVICE_CONTROL;
1210 pIoStackLocation->DeviceObject = TargetDeviceObject;
1212 pIoStackLocation->Parameters.DeviceIoControl.IoControlCode = IOControl;
1214 pIrp->AssociatedIrp.SystemBuffer = (void *)InputBuffer;
1215 pIoStackLocation->Parameters.DeviceIoControl.InputBufferLength = InputBufferLength;
1218 // Set the completion routine.
1221 IoSetCompletionRoutine( pIrp,
1229 // Send it to the FSD
1232 ntStatus = IoCallDriver( TargetDeviceObject,
1235 if( NT_SUCCESS( ntStatus))
1242 ntStatus = KeWaitForSingleObject( &kEvent,
1248 if( NT_SUCCESS( ntStatus))
1251 ntStatus = pIrp->IoStatus.Status;
1253 if( ResultLength != NULL)
1255 *ResultLength = (ULONG)pIrp->IoStatus.Information;
1265 if( pIrp->MdlAddress != NULL)
1268 if( FlagOn( pIrp->MdlAddress->MdlFlags, MDL_PAGES_LOCKED))
1271 MmUnlockPages( pIrp->MdlAddress);
1274 IoFreeMdl( pIrp->MdlAddress);
1277 pIrp->MdlAddress = NULL;
1291 AFSIrpComplete( IN PDEVICE_OBJECT DeviceObject,
1296 KEVENT *pEvent = (KEVENT *)Context;
1302 return STATUS_MORE_PROCESSING_REQUIRED;
1306 AFSExAllocatePoolWithTag( IN POOL_TYPE PoolType,
1307 IN SIZE_T NumberOfBytes,
1311 void *pBuffer = NULL;
1313 pBuffer = ExAllocatePoolWithTag( PoolType,
1317 if( pBuffer == NULL)
1320 if( BooleanFlagOn( AFSDebugFlags, AFS_DBG_BUGCHECK_EXCEPTION))
1323 KeBugCheck( (ULONG)-2);
1330 "AFSExAllocatePoolWithTag failure Type %08lX Size %08lX Tag %08lX %08lX\n",
1334 PsGetCurrentThread());
1338 case AFS_GENERIC_MEMORY_21_TAG:
1339 case AFS_GENERIC_MEMORY_22_TAG:
1340 // AFSDumpTraceFiles -- do nothing;
1353 AFSExFreePool( IN void *Buffer)
1356 ExFreePool( Buffer);
1362 AFSShutdownRedirector()
1365 NTSTATUS ntStatus = STATUS_SUCCESS;
1366 AFSDeviceExt *pRDRDevExt = (AFSDeviceExt *)AFSRDRDeviceObject->DeviceExtension;
1367 AFSDeviceExt *pControlDevExt = (AFSDeviceExt *)AFSDeviceObject->DeviceExtension;
1368 LARGE_INTEGER liTimeout;
1373 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1374 AFS_TRACE_LEVEL_VERBOSE,
1375 "%s Shutting down redirector Extent count %08lX Request count %08lX\n",
1377 pControlDevExt->Specific.Control.ExtentCount,
1378 pControlDevExt->Specific.Control.OutstandingServiceRequestCount);
1381 // Set the shutdown flag so the worker is more agressive in tearing down extents
1384 SetFlag( pRDRDevExt->DeviceFlags, AFS_DEVICE_FLAG_REDIRECTOR_SHUTDOWN);
1387 // Wait on any outstanding service requests
1390 liTimeout.QuadPart = -(30 *AFS_ONE_SECOND);
1392 ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.OutstandingServiceRequestEvent,
1398 if( ntStatus == STATUS_TIMEOUT)
1401 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1402 AFS_TRACE_LEVEL_WARNING,
1403 "AFSShutdownRedirector Failed to complete all service requests Remaining count %08lX\n",
1404 pControlDevExt->Specific.Control.OutstandingServiceRequestCount);
1406 try_return( ntStatus = STATUS_UNSUCCESSFUL);
1409 AFSProcessQueuedResults( TRUE);
1412 // Wait for all extents to be released
1415 liTimeout.QuadPart = -(30 *AFS_ONE_SECOND);
1417 ntStatus = KeWaitForSingleObject( &pControlDevExt->Specific.Control.ExtentsHeldEvent,
1423 if( ntStatus == STATUS_TIMEOUT)
1426 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1427 AFS_TRACE_LEVEL_WARNING,
1428 "AFSShutdownRedirector Failed to purge all extents Remaining count %08lX\n",
1429 pControlDevExt->Specific.Control.ExtentCount);
1431 try_return( ntStatus = STATUS_UNSUCCESSFUL);
1434 ntStatus = AFSUnloadLibrary( TRUE);
1436 if( !NT_SUCCESS( ntStatus))
1439 try_return( ntStatus);
1444 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1445 AFS_TRACE_LEVEL_VERBOSE,
1446 "%s Completed shut down of redirector Extent count %08lX Request count %08lX Status %08lX\n",
1448 pControlDevExt->Specific.Control.ExtentCount,
1449 pControlDevExt->Specific.Control.OutstandingServiceRequestCount,
1457 // Cache manager callback routines
1461 AFSAcquireFcbForLazyWrite( IN PVOID Fcb,
1465 BOOLEAN bStatus = FALSE;
1466 AFSFcb *pFcb = (AFSFcb *)Fcb;
1467 BOOLEAN bReleaseMain = FALSE, bReleasePaging = FALSE;
1470 // Try and acquire the Fcb resource
1473 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1474 AFS_TRACE_LEVEL_VERBOSE,
1475 "AFSAcquireFcbForLazyWrite Acquiring Fcb %08lX\n",
1478 ASSERT( NULL == pFcb->Specific.File.LazyWriterThread);
1480 pFcb->Specific.File.LazyWriterThread = PsGetCurrentThread();
1482 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1483 AFS_TRACE_LEVEL_VERBOSE,
1484 "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
1485 &pFcb->NPFcb->Resource,
1486 PsGetCurrentThread());
1488 if( AFSAcquireShared( &pFcb->NPFcb->Resource,
1492 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1493 AFS_TRACE_LEVEL_VERBOSE,
1494 "AFSAcquireFcbForLazyWrite Acquired Fcb lock %08lX SHARED %08lX\n",
1495 &pFcb->NPFcb->Resource,
1496 PsGetCurrentThread());
1498 bReleaseMain = TRUE;
1501 // Try and grab the paging
1504 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1505 AFS_TRACE_LEVEL_VERBOSE,
1506 "AFSAcquireFcbForLazyWrite Attempt to acquire Fcb PagingIo lock %08lX SHARED %08lX\n",
1507 &pFcb->NPFcb->PagingResource,
1508 PsGetCurrentThread());
1510 if( AFSAcquireShared( &pFcb->NPFcb->PagingResource,
1514 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1515 AFS_TRACE_LEVEL_VERBOSE,
1516 "AFSAcquireFcbForLazyWrite Acquired Fcb PagingIo lock %08lX SHARED %08lX\n",
1517 &pFcb->NPFcb->PagingResource,
1518 PsGetCurrentThread());
1520 bReleasePaging = TRUE;
1528 IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
1538 AFSReleaseResource( &pFcb->NPFcb->Resource);
1544 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1552 AFSReleaseFcbFromLazyWrite( IN PVOID Fcb)
1555 AFSFcb *pFcb = (AFSFcb *)Fcb;
1557 AFSDbgLogMsg( AFS_SUBSYSTEM_IO_PROCESSING,
1558 AFS_TRACE_LEVEL_VERBOSE,
1559 "AFSReleaseFcbFromLazyWrite Releasing Fcb %08lX\n",
1562 IoSetTopLevelIrp( NULL);
1564 ASSERT( PsGetCurrentThread() == pFcb->Specific.File.LazyWriterThread);
1566 pFcb->Specific.File.LazyWriterThread = NULL;
1569 AFSReleaseResource( &pFcb->NPFcb->PagingResource);
1571 AFSReleaseResource( &pFcb->NPFcb->Resource);
1577 AFSAcquireFcbForReadAhead( IN PVOID Fcb,
1581 BOOLEAN bStatus = FALSE;
1582 AFSFcb *pFcb = (AFSFcb *)Fcb;
1584 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1585 AFS_TRACE_LEVEL_VERBOSE,
1586 "AFSAcquireFcbForReadAhead Attempt to acquire Fcb lock %08lX SHARED %08lX\n",
1587 &pFcb->NPFcb->Resource,
1588 PsGetCurrentThread());
1590 if( AFSAcquireShared( &pFcb->NPFcb->Resource,
1594 AFSDbgLogMsg( AFS_SUBSYSTEM_LOCK_PROCESSING,
1595 AFS_TRACE_LEVEL_VERBOSE,
1596 "AFSAcquireFcbForReadAhead Acquired Fcb lock %08lX SHARED %08lX\n",
1597 &pFcb->NPFcb->Resource,
1598 PsGetCurrentThread());
1602 IoSetTopLevelIrp( (PIRP)FSRTL_CACHE_TOP_LEVEL_IRP);
1609 AFSReleaseFcbFromReadAhead( IN PVOID Fcb)
1612 AFSFcb *pFcb = (AFSFcb *)Fcb;
1614 IoSetTopLevelIrp( NULL);
1616 AFSReleaseResource( &pFcb->NPFcb->Resource);
1622 AFSGetCallerSID( OUT UNICODE_STRING *SIDString, OUT BOOLEAN *pbImpersonation)
1625 NTSTATUS ntStatus = STATUS_SUCCESS;
1626 PACCESS_TOKEN hToken = NULL;
1627 TOKEN_USER *pTokenInfo = NULL;
1628 BOOLEAN bCopyOnOpen = FALSE;
1629 BOOLEAN bEffectiveOnly = FALSE;
1630 BOOLEAN bPrimaryToken = FALSE;
1631 SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1632 UNICODE_STRING uniSIDString;
1637 hToken = PsReferenceImpersonationToken( PsGetCurrentThread(),
1640 &stImpersonationLevel);
1645 hToken = PsReferencePrimaryToken( PsGetCurrentProcess());
1650 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1651 AFS_TRACE_LEVEL_ERROR,
1652 "AFSGetCallerSID Failed to retrieve impersonation or primary token\n");
1654 try_return( ntStatus);
1657 bPrimaryToken = TRUE;
1660 ntStatus = SeQueryInformationToken( hToken,
1662 (PVOID *)&pTokenInfo);
1664 if( !NT_SUCCESS( ntStatus))
1667 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1668 AFS_TRACE_LEVEL_ERROR,
1669 "AFSGetCallerSID Failed to retrieve information Status %08lX\n", ntStatus);
1671 try_return( ntStatus);
1674 uniSIDString.Length = 0;
1675 uniSIDString.MaximumLength = 0;
1676 uniSIDString.Buffer = NULL;
1678 ntStatus = RtlConvertSidToUnicodeString( &uniSIDString,
1679 pTokenInfo->User.Sid,
1682 if( !NT_SUCCESS( ntStatus))
1685 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1686 AFS_TRACE_LEVEL_ERROR,
1687 "AFSGetCallerSID Failed to convert sid to string Status %08lX\n", ntStatus);
1689 try_return( ntStatus);
1692 *SIDString = uniSIDString;
1694 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
1695 AFS_TRACE_LEVEL_VERBOSE_2,
1696 "AFSGetCallerSID Successfully retrieved SID %wZ\n",
1699 if ( bPrimaryToken == FALSE &&
1702 *pbImpersonation = TRUE;
1711 PsDereferencePrimaryToken( hToken);
1715 PsDereferenceImpersonationToken( hToken);
1719 if( pTokenInfo != NULL)
1721 AFSExFreePool( pTokenInfo);
1729 AFSGetSessionId( IN HANDLE ProcessId, OUT BOOLEAN *pbImpersonation)
1732 NTSTATUS ntStatus = STATUS_SUCCESS;
1733 PACCESS_TOKEN hToken = NULL;
1734 ULONG ulSessionId = (ULONG)-1;
1735 BOOLEAN bCopyOnOpen = FALSE;
1736 BOOLEAN bEffectiveOnly = FALSE;
1737 BOOLEAN bPrimaryToken = FALSE;
1738 SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1743 hToken = PsReferenceImpersonationToken( PsGetCurrentThread(),
1746 &stImpersonationLevel);
1751 hToken = PsReferencePrimaryToken( PsGetCurrentProcess());
1756 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1757 AFS_TRACE_LEVEL_ERROR,
1758 "AFSGetSessionId Failed to retrieve impersonation or primary token\n");
1760 try_return( ntStatus);
1763 bPrimaryToken = TRUE;
1766 ntStatus = SeQueryInformationToken( hToken,
1768 (PVOID *)&ulSessionId);
1770 if( !NT_SUCCESS( ntStatus))
1772 ulSessionId = (ULONG)-1;
1774 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING,
1775 AFS_TRACE_LEVEL_ERROR,
1776 "AFSGetSessionId Failed to retrieve session id Status %08lX\n",
1779 try_return( ntStatus);
1782 AFSDbgLogMsg( AFS_SUBSYSTEM_FILE_PROCESSING | AFS_SUBSYSTEM_AUTHGROUP_PROCESSING,
1783 AFS_TRACE_LEVEL_VERBOSE_2,
1784 "AFSGetSessionId found %08lX\n",
1787 if ( bPrimaryToken == FALSE &&
1790 *pbImpersonation = TRUE;
1799 PsDereferencePrimaryToken( hToken);
1803 PsDereferenceImpersonationToken( hToken);
1812 AFSCheckThreadDacl( OUT GUID *AuthGroup)
1815 NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
1817 PACCESS_TOKEN token = NULL;
1818 PTOKEN_DEFAULT_DACL defDacl = NULL;
1820 PACCESS_ALLOWED_ACE adace;
1821 BOOLEAN bCopyOnOpen = FALSE, bEffectiveOnly = FALSE;
1822 SECURITY_IMPERSONATION_LEVEL stImpersonationLevel;
1823 BOOLEAN bLocatedACE = FALSE;
1828 token = PsReferenceImpersonationToken( PsGetCurrentThread(),
1831 &stImpersonationLevel);
1835 try_return( ntStatus);
1838 ntStatus = SeQueryInformationToken( token,
1842 if( ntStatus != STATUS_SUCCESS)
1844 try_return( ntStatus);
1847 // scan through all ACEs in the DACL
1848 for (idx = 0, ace = (PACE_HEADER)((char *)defDacl->DefaultDacl + sizeof(ACL)); idx < defDacl->DefaultDacl->AceCount; idx++)
1850 if (ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
1852 adace = (PACCESS_ALLOWED_ACE)ace;
1854 if (adace->Header.AceSize == (FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH))
1856 if (RtlCompareMemory( RtlSubAuthoritySid((PSID)&adace->SidStart, 0), &AFSSidGuid, sizeof(GUID)) == sizeof(GUID))
1859 RtlCopyMemory( AuthGroup,
1860 RtlSubAuthoritySid((PSID)&adace->SidStart, 4),
1871 ace = (PACE_HEADER)((char *)ace + ace->AceSize);
1878 PsDereferenceImpersonationToken( token);
1881 if (defDacl != NULL)
1883 ExFreePool(defDacl);
1888 ntStatus = STATUS_UNSUCCESSFUL;
1896 AFSProcessSetProcessDacl( IN AFSProcessCB *ProcessCB)
1899 PTOKEN_DEFAULT_DACL defDacl = NULL;
1900 HANDLE hToken = NULL;
1901 PACE_HEADER ace = NULL;
1902 SID_IDENTIFIER_AUTHORITY sia = SECURITY_NT_AUTHORITY;
1903 PACCESS_ALLOWED_ACE aaace;
1905 ULONG bytesReturned;
1908 NTSTATUS ntStatus = STATUS_SUCCESS;
1913 ntStatus = ZwOpenProcessTokenEx( NtCurrentProcess(),
1918 if( !NT_SUCCESS( ntStatus))
1920 try_return( ntStatus);
1923 // get the size of the current DACL
1924 ntStatus = ZwQueryInformationToken( hToken,
1930 // if we failed to get the buffer size needed
1931 if ((ntStatus != STATUS_SUCCESS) && (ntStatus != STATUS_BUFFER_TOO_SMALL))
1933 try_return( ntStatus);
1936 // tack on enough space for our ACE if we need to add it...
1937 bytesNeeded += FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH;
1939 // allocate space for the DACL
1940 defDacl = (PTOKEN_DEFAULT_DACL)ExAllocatePoolWithTag( PagedPool, bytesNeeded, AFS_GENERIC_MEMORY_26_TAG);
1942 if (defDacl == NULL)
1944 try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
1948 ntStatus = ZwQueryInformationToken( hToken,
1954 if( ntStatus != STATUS_SUCCESS)
1956 try_return( ntStatus);
1959 // scan through DACL to see if we have the SID set already...
1960 ace = (PACE_HEADER)((char *)defDacl->DefaultDacl + sizeof(ACL));
1961 for (idx = 0; idx < defDacl->DefaultDacl->AceCount; idx++)
1963 if (ace->AceType == ACCESS_ALLOWED_ACE_TYPE)
1965 aaace = (PACCESS_ALLOWED_ACE)ace;
1967 if (aaace->Header.AceSize == (FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + AFS_DACL_SID_LENGTH))
1969 // if the GUID part matches
1970 if( RtlCompareMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 0),
1972 sizeof(GUID)) == sizeof(GUID))
1975 if ( RtlCompareMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 4),
1976 ProcessCB->ActiveAuthGroup,
1977 sizeof( GUID)) != sizeof( GUID))
1980 RtlCopyMemory( RtlSubAuthoritySid((PSID)&aaace->SidStart, 4),
1981 ProcessCB->ActiveAuthGroup,
1984 if( AFSSetInformationToken != NULL)
1986 ntStatus = AFSSetInformationToken( hToken,
1993 try_return( ntStatus);
1999 ace = (PACE_HEADER)((char *)ace + ace->AceSize);
2003 // if we made it here we need to add a new ACE to the DACL
2006 aaace = (ACCESS_ALLOWED_ACE *)ace;
2007 aaace->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
2008 aaace->Header.AceFlags = 0;
2009 aaace->Mask = GENERIC_ALL;
2010 psid = (PSID)&aaace->SidStart;
2011 RtlInitializeSid( psid, &sia, 8);
2013 RtlCopyMemory( RtlSubAuthoritySid(psid, 0),
2017 RtlCopyMemory( RtlSubAuthoritySid(psid, 4),
2018 ProcessCB->ActiveAuthGroup,
2021 aaace->Header.AceSize = (USHORT)(FIELD_OFFSET(ACCESS_ALLOWED_ACE, SidStart) + RtlLengthSid( psid));
2023 defDacl->DefaultDacl->AclSize += aaace->Header.AceSize;
2024 defDacl->DefaultDacl->AceCount++;
2026 if( AFSSetInformationToken != NULL)
2028 ntStatus = AFSSetInformationToken( hToken,
2031 defDacl->DefaultDacl->AclSize + sizeof(PTOKEN_DEFAULT_DACL));
2041 if (defDacl != NULL)
2043 ExFreePool( defDacl);