Windows: include owner/group in Security DACL
[openafs.git] / src / WINNT / afsrdr / kernel / lib / AFSInit.cpp
1 /*
2  * Copyright (c) 2008, 2009, 2010, 2011 Kernel Drivers, LLC.
3  * Copyright (c) 2009, 2010, 2011 Your File System, Inc.
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  *
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
13  *   notice,
14  *   this list of conditions and the following disclaimer in the
15  *   documentation
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.
21  *
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.
33  */
34
35 //
36 // File: AFSInit.cpp
37 //
38
39 #include "AFSCommon.h"
40
41 //
42 // DriverEntry
43 //
44 // This is the initial entry point for the driver.
45 //
46 // Inputs:
47 //  DriverObject        Pointer to Driver Object created by I/O manager
48 //  RegistryPath        Pointer to registry path representing this Driver
49 //
50 // Returns:
51 //  Success             To indicate Driver's inituaialization processing
52 //                      was successful
53 //  NT ERROR STATUS     Otherwise -- Driver does not remain loaded
54 //
55
56 NTSTATUS
57 DriverEntry( PDRIVER_OBJECT DriverObject,
58              PUNICODE_STRING RegistryPath)
59 {
60
61     NTSTATUS ntStatus = STATUS_SUCCESS;
62     AFSDeviceExt    *pDeviceExt;
63     ULONG ulTimeIncrement = 0;
64     UNICODE_STRING uniDeviceName;
65     ULONG ulIndex = 0;
66     UNICODE_STRING uniRoutine;
67     RTL_OSVERSIONINFOW sysVersion;
68
69     BOOLEAN bExit = FALSE;
70
71     __try
72     {
73
74         AFSPrint("AFSLibrary DriverEntry Initialization build %s:%s\n", __DATE__, __TIME__);
75
76         //
77         // Our backdoor to not let the driver load
78         //
79
80         if( bExit)
81         {
82
83             //
84             // Return a failure so we can update the binary and manually start it without
85             // having to do a reboot
86             //
87
88             try_return( ntStatus = STATUS_UNSUCCESSFUL);
89         }
90
91         //
92         // Perform some initialization
93         //
94
95         AFSLibraryDriverObject = DriverObject;
96
97         //
98         // Setup the registry string
99         //
100
101         AFSRegistryPath.MaximumLength = RegistryPath->MaximumLength;
102         AFSRegistryPath.Length        = RegistryPath->Length;
103
104         AFSRegistryPath.Buffer = (PWSTR)AFSLibExAllocatePoolWithTag( PagedPool,
105                                                                      AFSRegistryPath.Length,
106                                                                      AFS_GENERIC_MEMORY_13_TAG);
107
108         if( AFSRegistryPath.Buffer == NULL)
109         {
110
111             AFSPrint("AFS DriverEntry Failed to allocate registry path buffer\n");
112
113             try_return( ntStatus = STATUS_INSUFFICIENT_RESOURCES);
114         }
115
116         RtlCopyMemory( AFSRegistryPath.Buffer,
117                        RegistryPath->Buffer,
118                        RegistryPath->Length);
119
120         RtlZeroMemory( &sysVersion,
121                        sizeof( RTL_OSVERSIONINFOW));
122
123         sysVersion.dwOSVersionInfoSize = sizeof( RTL_OSVERSIONINFOW);
124
125         RtlGetVersion( &sysVersion);
126
127 #if 0
128         //
129         // By not fetching the RtlSetSaclSecurityDescriptor function
130         // pointer it disables the additional of a mandatory label
131         // to the default acl which is returned by AFSRedir for all
132         // security information queries.   The addition of the
133         // mandatory label appears to have a negative consequence
134         // for roaming profiles and redirected folders.  All links
135         // become untrusted and IE9 is unable to open a new instance
136         // to a non-default home page.
137         //
138         //
139         // Only retrieve this function for Vista and above since
140         // Mandatory Labels only exist on those operating systems.
141         //
142
143         if( sysVersion.dwMajorVersion >= 6)
144         {
145             RtlInitUnicodeString( &uniRoutine,
146                                   L"RtlSetSaclSecurityDescriptor");
147
148             AFSRtlSetSaclSecurityDescriptor = (PAFSRtlSetSaclSecurityDescriptor)MmGetSystemRoutineAddress( &uniRoutine);
149         }
150
151 #endif
152
153         RtlInitUnicodeString( &uniRoutine,
154                               L"RtlSetGroupSecurityDescriptor");
155
156         AFSRtlSetGroupSecurityDescriptor = (PAFSRtlSetGroupSecurityDescriptor)MmGetSystemRoutineAddress( &uniRoutine);
157
158         ntStatus = AFSCreateDefaultSecurityDescriptor();
159
160         if( !NT_SUCCESS( ntStatus))
161         {
162
163             AFSPrint("AFS DriverEntry  AFSCreateDefaultSecurityDescriptor failed Status %08lX\n", ntStatus);
164
165             ntStatus = STATUS_SUCCESS;
166         }
167
168         //
169         // Initilize the control device
170         //
171
172         RtlInitUnicodeString( &uniDeviceName,
173                               AFS_LIBRARY_CONTROL_DEVICE_NAME);
174
175         ntStatus = IoCreateDevice( DriverObject,
176                                    sizeof( AFSDeviceExt),
177                                    &uniDeviceName,
178                                    FILE_DEVICE_DISK_FILE_SYSTEM,
179                                    0,
180                                    FALSE,
181                                    &AFSLibraryDeviceObject);
182
183         if( !NT_SUCCESS( ntStatus))
184         {
185
186             AFSPrint("AFS DriverEntry - Failed to allocate device control object Status %08lX\n", ntStatus);
187
188             try_return( ntStatus);
189         }
190
191         //
192         // Setup the device extension
193         //
194
195         pDeviceExt = (AFSDeviceExt *)AFSLibraryDeviceObject->DeviceExtension;
196
197         //
198         // Now initialize the control device
199         //
200
201         ntStatus = AFSInitializeLibraryDevice();
202
203         if( !NT_SUCCESS( ntStatus))
204         {
205
206             try_return( ntStatus);
207         }
208
209         //
210         // Initialize the worker thread pool
211         //
212
213         ntStatus = AFSInitializeWorkerPool();
214
215         if( !NT_SUCCESS( ntStatus))
216         {
217
218             AFSPrint("AFS DriverEntry Failed to initialize worker pool Status %08lX\n", ntStatus);
219
220             try_return( ntStatus);
221         }
222
223         //
224         // Fill in the dispatch table
225         //
226
227         for( ulIndex = 0; ulIndex <= IRP_MJ_MAXIMUM_FUNCTION; ulIndex++)
228         {
229
230             DriverObject->MajorFunction[ ulIndex] = AFSDefaultDispatch;
231         }
232
233         DriverObject->MajorFunction[IRP_MJ_CREATE] =                    AFSCreate;
234         DriverObject->MajorFunction[IRP_MJ_CLOSE] =                     AFSClose;
235         DriverObject->MajorFunction[IRP_MJ_READ] =                      AFSRead;
236         DriverObject->MajorFunction[IRP_MJ_WRITE] =                     AFSWrite;
237         DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =         AFSQueryFileInfo;
238         DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =           AFSSetFileInfo;
239         DriverObject->MajorFunction[IRP_MJ_QUERY_EA] =                  AFSQueryEA;
240         DriverObject->MajorFunction[IRP_MJ_SET_EA] =                    AFSSetEA;
241         DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] =             AFSFlushBuffers;
242         DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] =  AFSQueryVolumeInfo;
243         DriverObject->MajorFunction[IRP_MJ_SET_VOLUME_INFORMATION] =    AFSSetVolumeInfo;
244         DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =         AFSDirControl;
245         DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =       AFSFSControl;
246         DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] =            AFSDevControl;
247         DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] =   AFSInternalDevControl;
248         DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] =                  AFSShutdown;
249         DriverObject->MajorFunction[IRP_MJ_LOCK_CONTROL] =              AFSLockControl;
250         DriverObject->MajorFunction[IRP_MJ_CLEANUP] =                   AFSCleanup;
251         DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] =            AFSQuerySecurity;
252         DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =              AFSSetSecurity;
253         DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] =            AFSSystemControl;
254         //DriverObject->MajorFunction[IRP_MJ_QUERY_QUOTA] =               AFSQueryQuota;
255         //DriverObject->MajorFunction[IRP_MJ_SET_QUOTA] =                 AFSSetQuota;
256
257         DriverObject->DriverUnload = AFSUnload;
258
259         AFSSysProcess = PsGetCurrentProcessId();
260
261 try_exit:
262
263         if( !NT_SUCCESS( ntStatus))
264         {
265
266             AFSPrint("AFSLibrary DriverEntry failed to initialize %08lX\n", ntStatus);
267
268             if( AFSLibraryDeviceObject != NULL)
269             {
270
271                 AFSRemoveWorkerPool();
272             }
273
274             if( AFSRegistryPath.Buffer != NULL)
275             {
276
277                 ExFreePool( AFSRegistryPath.Buffer);
278             }
279
280             if( AFSLibraryDeviceObject != NULL)
281             {
282
283                 AFSRemoveLibraryDevice();
284
285                 IoDeleteDevice( AFSLibraryDeviceObject);
286             }
287         }
288     }
289     __except( AFSExceptionFilter( GetExceptionCode(), GetExceptionInformation()) )
290     {
291
292         AFSPrint( "EXCEPTION - AFS DriverEntry\n");
293     }
294
295     return ntStatus;
296 }
297
298 void
299 AFSUnload( IN PDRIVER_OBJECT DriverObject)
300 {
301
302     if( AFSGlobalRoot != NULL)
303     {
304
305         AFSInvalidateVolume( AFSGlobalRoot,
306                              AFS_INVALIDATE_CALLBACK);
307
308         ClearFlag( AFSGlobalRoot->Flags, AFS_VOLUME_ACTIVE_GLOBAL_ROOT);
309
310         AFSShutdownVolumeWorker( AFSGlobalRoot);
311     }
312
313     if( AFSLibraryDeviceObject != NULL)
314     {
315
316         AFSRemoveWorkerPool();
317     }
318
319     if( AFSRegistryPath.Buffer != NULL)
320     {
321
322         ExFreePool( AFSRegistryPath.Buffer);
323     }
324
325     AFSCloseLibrary();
326
327     if( AFSDefaultSD != NULL)
328     {
329         ExFreePool( AFSDefaultSD);
330     }
331
332     if( AFSLibraryDeviceObject != NULL)
333     {
334
335         AFSRemoveLibraryDevice();
336
337         IoDeleteDevice( AFSLibraryDeviceObject);
338     }
339
340     return;
341 }