[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / drivers / filters / fltmgr / Registration.c
1 /*
2 * PROJECT: Filesystem Filter Manager
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/fs_minifilter/fltmgr/Registration.c
5 * PURPOSE: Handles registration of mini filters
6 * PROGRAMMERS: Ged Murphy (gedmurphy@reactos.org)
7 */
8
9 /* INCLUDES ******************************************************************/
10
11 #include "fltmgr.h"
12
13 #define NDEBUG
14 #include <debug.h>
15
16
17 /* DATA *********************************************************************/
18
19
20 NTSTATUS
21 FltpStartingToDrainObject(
22 _Inout_ PFLT_OBJECT Object
23 );
24
25
26 /* EXPORTED FUNCTIONS ******************************************************/
27
28 NTSTATUS
29 NTAPI
30 FltRegisterFilter(_In_ PDRIVER_OBJECT DriverObject,
31 _In_ const FLT_REGISTRATION *Registration,
32 _Out_ PFLT_FILTER *RetFilter)
33 {
34 PFLT_OPERATION_REGISTRATION Callbacks;
35 PFLT_FILTER Filter;
36 ULONG CallbackBufferSize;
37 ULONG FilterBufferSize;
38 ULONG Count = 0;
39 PCHAR Ptr;
40 NTSTATUS Status;
41
42 Status = 0; //remove me
43
44 /* Make sure we're targeting the correct major revision */
45 if ((Registration->Version & 0xFF00) != FLT_MAJOR_VERSION)
46 {
47 return STATUS_INVALID_PARAMETER;
48 }
49
50 /* Make sure our namespace callbacks are valid */
51 if ((!Registration->GenerateFileNameCallback && Registration->NormalizeNameComponentCallback) ||
52 (!Registration->NormalizeNameComponentCallback && Registration->NormalizeContextCleanupCallback))
53 {
54 return STATUS_INVALID_PARAMETER;
55 }
56
57 /* Count the number of operations that were requested */
58 Callbacks = (PFLT_OPERATION_REGISTRATION)Registration->OperationRegistration;
59 while (Callbacks)
60 {
61 Count++;
62
63 /* Bail when we find the last one */
64 if (Callbacks->MajorFunction == IRP_MJ_OPERATION_END)
65 break;
66
67 /* Move to the next item */
68 Callbacks++;
69 }
70
71 /* Calculate the buffer sizes */
72 CallbackBufferSize = Count * sizeof(FLT_OPERATION_REGISTRATION);
73 FilterBufferSize = sizeof(FLT_FILTER) + CallbackBufferSize +
74 DriverObject->DriverExtension->ServiceKeyName.Length;
75
76 /* Allocate a buffer to hold our filter data */
77 Filter = ExAllocatePoolWithTag(NonPagedPool,
78 FilterBufferSize,
79 FM_TAG_FILTER);
80 if (Filter == NULL) return STATUS_INSUFFICIENT_RESOURCES;
81 RtlZeroMemory(Filter, FilterBufferSize);
82
83 /* Find the end of the fixed struct */
84 Ptr = (PCHAR)(Filter + 1);
85
86 /* Store a copy of the driver object of this filter */
87 Filter->DriverObject = DriverObject;
88
89 /* Initialize the base object data */
90 Filter->Base.Flags = FLT_OBFL_TYPE_FILTER;
91 Filter->Base.PointerCount = 1;
92 FltpExInitializeRundownProtection(&Filter->Base.RundownRef);
93 FltObjectReference(&Filter->Base);
94
95 /* Set the callback addresses */
96 Filter->FilterUnload = Registration->FilterUnloadCallback;
97 Filter->InstanceSetup = Registration->InstanceSetupCallback;
98 Filter->InstanceQueryTeardown = Registration->InstanceQueryTeardownCallback;
99 Filter->InstanceTeardownStart = Registration->InstanceTeardownStartCallback;
100 Filter->InstanceTeardownComplete = Registration->InstanceTeardownCompleteCallback;
101 Filter->GenerateFileName = Registration->GenerateFileNameCallback;
102 Filter->NormalizeNameComponent = Registration->NormalizeNameComponentCallback;
103 Filter->NormalizeContextCleanup = Registration->NormalizeContextCleanupCallback;
104
105 /* Initialize the instance list */
106 ExInitializeResourceLite(&Filter->InstanceList.rLock);
107 InitializeListHead(&Filter->InstanceList.rList);
108 Filter->InstanceList.rCount = 0;
109
110 ExInitializeFastMutex(&Filter->ActiveOpens.mLock);
111 InitializeListHead(&Filter->ActiveOpens.mList);
112 Filter->ActiveOpens.mCount = 0;
113
114 /* Initialize the usermode port list */
115 ExInitializeFastMutex(&Filter->PortList.mLock);
116 InitializeListHead(&Filter->PortList.mList);
117 Filter->PortList.mCount = 0;
118
119 /* Check if the caller requested any context data */
120 if (Registration->ContextRegistration)
121 {
122 // register the context information
123 }
124
125 if (Registration->OperationRegistration)
126 {
127 /* The callback data comes after the fixed struct */
128 Filter->Operations = (PFLT_OPERATION_REGISTRATION)Ptr;
129 Ptr += (Count * sizeof(FLT_OPERATION_REGISTRATION));
130
131 /* Tag the operation data onto the end of the filter data */
132 RtlCopyMemory(Filter->Operations, Registration->OperationRegistration, CallbackBufferSize);
133
134 /* walk through the requested callbacks */
135 for (Callbacks = Filter->Operations;
136 Callbacks->MajorFunction != IRP_MJ_OPERATION_END;
137 Callbacks++)
138 {
139 // http://fsfilters.blogspot.co.uk/2011/03/how-file-system-filters-attach-to_17.html
140 /* Check if this is an attach to a volume */
141 if (Callbacks->MajorFunction == IRP_MJ_VOLUME_MOUNT)
142 {
143 Filter->PreVolumeMount = Callbacks->PreOperation;
144 Filter->PostVolumeMount = Callbacks->PostOperation;
145 }
146 else if (Callbacks->MajorFunction == IRP_MJ_SHUTDOWN)
147 {
148 Callbacks->PostOperation = NULL;
149 }
150 }
151 }
152
153 /* Add the filter name buffer onto the end of the data and fill in the string */
154 Filter->Name.Length = 0;
155 Filter->Name.MaximumLength = DriverObject->DriverExtension->ServiceKeyName.Length;
156 Filter->Name.Buffer = (PWCH)Ptr;
157 RtlCopyUnicodeString(&Filter->Name, &DriverObject->DriverExtension->ServiceKeyName);
158
159 //
160 // - Get the altitude string
161 // - Slot the filter into the correct altitude location
162 // - More stuff??
163 //
164
165 //Quit:
166 if (!NT_SUCCESS(Status))
167 {
168 // Add cleanup for context resources
169
170 ExDeleteResourceLite(&Filter->InstanceList.rLock);
171 ExFreePoolWithTag(Filter, FM_TAG_FILTER);
172 }
173
174 return Status;
175 }
176
177 VOID
178 FLTAPI
179 FltUnregisterFilter(_In_ PFLT_FILTER Filter)
180 {
181 PFLT_INSTANCE Instance;
182 PLIST_ENTRY CurrentEntry;
183 NTSTATUS Status;
184
185 /* Set the draining flag */
186 Status = FltpStartingToDrainObject(&Filter->Base);
187 if (!NT_SUCCESS(Status))
188 {
189 /* Someone already unregistered us, just remove our ref and bail */
190 FltObjectDereference(&Filter->Base);
191 return;
192 }
193
194 /* Lock the instance list */
195 KeEnterCriticalRegion();
196 ExAcquireResourceSharedLite(&Filter->InstanceList.rLock, TRUE);
197
198 /* Set the first entry in the list */
199 CurrentEntry = Filter->InstanceList.rList.Flink;
200
201 /* Free all instances referenced by the filter */
202 while (CurrentEntry != &Filter->InstanceList.rList)
203 {
204 /* Get the record pointer */
205 Instance = CONTAINING_RECORD(CurrentEntry, FLT_INSTANCE, FilterLink);
206
207 // FIXME: implement
208 (void)Instance;
209
210 /* Reset the pointer and move to next entry */
211 Instance = NULL;
212 CurrentEntry = CurrentEntry->Flink;
213 }
214
215 /* We're done with instances now */
216 ExReleaseResourceLite(&Filter->InstanceList.rLock);
217 KeLeaveCriticalRegion();
218
219 /* Remove the reference from the base object */
220 FltObjectDereference(&Filter->Base);
221
222 /* Wait until we're sure nothing is using the filter */
223 FltpObjectRundownWait(&Filter->Base.RundownRef);
224
225 /* Delete the instance list lock */
226 ExDeleteResourceLite(&Filter->InstanceList.rLock);
227
228 /* We're finished cleaning up now */
229 FltpExRundownCompleted(&Filter->Base.RundownRef);
230
231 /* Hand the memory back */
232 ExFreePoolWithTag(Filter, FM_TAG_FILTER);
233 }
234
235
236 /* INTERNAL FUNCTIONS ******************************************************/
237
238 NTSTATUS
239 FltpStartingToDrainObject(_Inout_ PFLT_OBJECT Object)
240 {
241 /*
242 * Set the draining flag for the filter. This let's us force
243 * a post op callback for minifilters currently awaiting one.
244 */
245 if (InterlockedOr((PLONG)&Object->Flags, FLT_OBFL_DRAINING) & 1)
246 {
247 /* We've been called once, we're already being deleted */
248 return STATUS_FLT_DELETING_OBJECT;
249 }
250
251 return STATUS_SUCCESS;
252 }