[FASTFAT] Fix size checking in VfatGetFileNameInformation()
[reactos.git] / drivers / battery / battc / battc.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: drivers/battery/battc/battc.c
5 * PURPOSE: Battery Class Driver
6 * PROGRAMMERS: Cameron Gutman (cameron.gutman@reactos.org)
7 */
8
9 #include <battc.h>
10
11 #define NDEBUG
12 #include <debug.h>
13
14 NTSTATUS
15 NTAPI
16 DriverEntry(PDRIVER_OBJECT DriverObject,
17 PUNICODE_STRING RegistryPath)
18 {
19 DPRINT("Battery class driver initialized\n");
20
21 return STATUS_SUCCESS;
22 }
23
24 BCLASSAPI
25 NTSTATUS
26 NTAPI
27 BatteryClassUnload(PVOID ClassData)
28 {
29 PBATTERY_CLASS_DATA BattClass = ClassData;
30
31 DPRINT("Battery 0x%x is being unloaded\n");
32
33 if (BattClass->InterfaceName.Length != 0)
34 {
35 IoSetDeviceInterfaceState(&BattClass->InterfaceName, FALSE);
36 RtlFreeUnicodeString(&BattClass->InterfaceName);
37 }
38
39 ExFreePoolWithTag(BattClass,
40 BATTERY_CLASS_DATA_TAG);
41
42 return STATUS_SUCCESS;
43 }
44
45 BCLASSAPI
46 NTSTATUS
47 NTAPI
48 BatteryClassSystemControl(PVOID ClassData,
49 PVOID WmiLibContext,
50 PDEVICE_OBJECT DeviceObject,
51 PIRP Irp,
52 PVOID Disposition)
53 {
54 UNIMPLEMENTED;
55
56 return STATUS_WMI_GUID_NOT_FOUND;
57 }
58
59 BCLASSAPI
60 NTSTATUS
61 NTAPI
62 BatteryClassQueryWmiDataBlock(PVOID ClassData,
63 PDEVICE_OBJECT DeviceObject,
64 PIRP Irp,
65 ULONG GuidIndex,
66 PULONG InstanceLengthArray,
67 ULONG OutBufferSize,
68 PUCHAR Buffer)
69 {
70 UNIMPLEMENTED;
71
72 return STATUS_WMI_GUID_NOT_FOUND;
73 }
74
75 BCLASSAPI
76 NTSTATUS
77 NTAPI
78 BatteryClassStatusNotify(PVOID ClassData)
79 {
80 PBATTERY_CLASS_DATA BattClass = ClassData;
81 PBATTERY_WAIT_STATUS BattWait = BattClass->EventTriggerContext;
82 BATTERY_STATUS BattStatus;
83 NTSTATUS Status;
84
85 DPRINT("Received battery status notification from 0x%x\n", ClassData);
86
87 ExAcquireFastMutex(&BattClass->Mutex);
88 if (!BattClass->Waiting)
89 {
90 ExReleaseFastMutex(&BattClass->Mutex);
91 return STATUS_SUCCESS;
92 }
93
94 switch (BattClass->EventTrigger)
95 {
96 case EVENT_BATTERY_TAG:
97 ExReleaseFastMutex(&BattClass->Mutex);
98 DPRINT1("Waiting for battery is UNIMPLEMENTED!\n");
99 break;
100
101 case EVENT_BATTERY_STATUS:
102 ExReleaseFastMutex(&BattClass->Mutex);
103 Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
104 BattWait->BatteryTag,
105 &BattStatus);
106 if (!NT_SUCCESS(Status))
107 return Status;
108
109 ExAcquireFastMutex(&BattClass->Mutex);
110
111 if (!(BattWait->PowerState & BattStatus.PowerState) ||
112 (BattWait->HighCapacity > BattStatus.Capacity) ||
113 (BattWait->LowCapacity < BattStatus.Capacity))
114 {
115 KeSetEvent(&BattClass->WaitEvent, IO_NO_INCREMENT, FALSE);
116 }
117
118 ExReleaseFastMutex(&BattClass->Mutex);
119 break;
120
121 default:
122 ExReleaseFastMutex(&BattClass->Mutex);
123 ASSERT(FALSE);
124 break;
125 }
126
127 return STATUS_SUCCESS;
128 }
129
130 BCLASSAPI
131 NTSTATUS
132 NTAPI
133 BatteryClassInitializeDevice(PBATTERY_MINIPORT_INFO MiniportInfo,
134 PVOID *ClassData)
135 {
136 NTSTATUS Status;
137 PBATTERY_CLASS_DATA BattClass = ExAllocatePoolWithTag(NonPagedPool,
138 sizeof(BATTERY_CLASS_DATA),
139 BATTERY_CLASS_DATA_TAG);
140
141 if (!BattClass)
142 return STATUS_INSUFFICIENT_RESOURCES;
143
144 RtlZeroMemory(BattClass, sizeof(BATTERY_CLASS_DATA));
145
146 RtlCopyMemory(&BattClass->MiniportInfo,
147 MiniportInfo,
148 sizeof(BattClass->MiniportInfo));
149
150 KeInitializeEvent(&BattClass->WaitEvent, SynchronizationEvent, FALSE);
151
152 ExInitializeFastMutex(&BattClass->Mutex);
153
154 if (MiniportInfo->Pdo != NULL)
155 {
156 Status = IoRegisterDeviceInterface(MiniportInfo->Pdo,
157 &GUID_DEVICE_BATTERY,
158 NULL,
159 &BattClass->InterfaceName);
160 if (NT_SUCCESS(Status))
161 {
162 DPRINT("Initialized battery interface: %wZ\n", &BattClass->InterfaceName);
163 Status = IoSetDeviceInterfaceState(&BattClass->InterfaceName, TRUE);
164 if (Status == STATUS_OBJECT_NAME_EXISTS)
165 {
166 DPRINT1("Got STATUS_OBJECT_NAME_EXISTS for SetDeviceInterfaceState\n");
167 Status = STATUS_SUCCESS;
168 }
169 }
170 else
171 {
172 DPRINT1("IoRegisterDeviceInterface failed (0x%x)\n", Status);
173 }
174 }
175
176 *ClassData = BattClass;
177
178 return STATUS_SUCCESS;
179 }
180
181 BCLASSAPI
182 NTSTATUS
183 NTAPI
184 BatteryClassIoctl(PVOID ClassData,
185 PIRP Irp)
186 {
187 PBATTERY_CLASS_DATA BattClass = ClassData;
188 PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
189 NTSTATUS Status;
190 ULONG WaitTime;
191 PBATTERY_WAIT_STATUS BattWait;
192 PBATTERY_QUERY_INFORMATION BattQueryInfo;
193 PBATTERY_SET_INFORMATION BattSetInfo;
194 LARGE_INTEGER Timeout;
195 PBATTERY_STATUS BattStatus;
196 BATTERY_NOTIFY BattNotify;
197 ULONG ReturnedLength;
198
199 Irp->IoStatus.Information = 0;
200
201 DPRINT("Received IOCTL %x for 0x%x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode,
202 ClassData);
203
204 switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
205 {
206 case IOCTL_BATTERY_QUERY_TAG:
207 if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(ULONG) ||
208 IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
209 {
210 Status = STATUS_BUFFER_TOO_SMALL;
211 break;
212 }
213
214 WaitTime = *(PULONG)Irp->AssociatedIrp.SystemBuffer;
215
216 Timeout.QuadPart = Int32x32To64(WaitTime, -1000);
217
218 Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context,
219 (PULONG)Irp->AssociatedIrp.SystemBuffer);
220 if (!NT_SUCCESS(Status))
221 {
222 ExAcquireFastMutex(&BattClass->Mutex);
223 BattClass->EventTrigger = EVENT_BATTERY_TAG;
224 BattClass->Waiting = TRUE;
225 ExReleaseFastMutex(&BattClass->Mutex);
226
227 Status = KeWaitForSingleObject(&BattClass->WaitEvent,
228 Executive,
229 KernelMode,
230 FALSE,
231 WaitTime != -1 ? &Timeout : NULL);
232
233 ExAcquireFastMutex(&BattClass->Mutex);
234 BattClass->Waiting = FALSE;
235 ExReleaseFastMutex(&BattClass->Mutex);
236
237 if (Status == STATUS_SUCCESS)
238 {
239 Status = BattClass->MiniportInfo.QueryTag(BattClass->MiniportInfo.Context,
240 (PULONG)Irp->AssociatedIrp.SystemBuffer);
241 if (NT_SUCCESS(Status))
242 Irp->IoStatus.Information = sizeof(ULONG);
243 }
244 else
245 {
246 Status = STATUS_NO_SUCH_DEVICE;
247 }
248 }
249 else
250 Irp->IoStatus.Information = sizeof(ULONG);
251 break;
252
253 case IOCTL_BATTERY_QUERY_STATUS:
254 if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattWait) ||
255 IrpSp->Parameters.DeviceIoControl.OutputBufferLength < sizeof(BATTERY_STATUS))
256 {
257 Status = STATUS_BUFFER_TOO_SMALL;
258 break;
259 }
260
261 BattWait = Irp->AssociatedIrp.SystemBuffer;
262
263 Timeout.QuadPart = Int32x32To64(BattWait->Timeout, -1000);
264
265 Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
266 BattWait->BatteryTag,
267 (PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer);
268
269 BattStatus = Irp->AssociatedIrp.SystemBuffer;
270
271 if (!NT_SUCCESS(Status) ||
272 ((BattWait->PowerState & BattStatus->PowerState) &&
273 (BattWait->HighCapacity <= BattStatus->Capacity) &&
274 (BattWait->LowCapacity >= BattStatus->Capacity)))
275 {
276 BattNotify.PowerState = BattWait->PowerState;
277 BattNotify.HighCapacity = BattWait->HighCapacity;
278 BattNotify.LowCapacity = BattWait->LowCapacity;
279
280 BattClass->MiniportInfo.SetStatusNotify(BattClass->MiniportInfo.Context,
281 BattWait->BatteryTag,
282 &BattNotify);
283
284 ExAcquireFastMutex(&BattClass->Mutex);
285 BattClass->EventTrigger = EVENT_BATTERY_STATUS;
286 BattClass->EventTriggerContext = BattWait;
287 BattClass->Waiting = TRUE;
288 ExReleaseFastMutex(&BattClass->Mutex);
289
290 Status = KeWaitForSingleObject(&BattClass->WaitEvent,
291 Executive,
292 KernelMode,
293 FALSE,
294 BattWait->Timeout != -1 ? &Timeout : NULL);
295
296 ExAcquireFastMutex(&BattClass->Mutex);
297 BattClass->Waiting = FALSE;
298 ExReleaseFastMutex(&BattClass->Mutex);
299
300 BattClass->MiniportInfo.DisableStatusNotify(BattClass->MiniportInfo.Context);
301
302 if (Status == STATUS_SUCCESS)
303 {
304 Status = BattClass->MiniportInfo.QueryStatus(BattClass->MiniportInfo.Context,
305 BattWait->BatteryTag,
306 (PBATTERY_STATUS)Irp->AssociatedIrp.SystemBuffer);
307 if (NT_SUCCESS(Status))
308 Irp->IoStatus.Information = sizeof(ULONG);
309 }
310 else
311 {
312 Status = STATUS_NO_SUCH_DEVICE;
313 }
314 }
315 else
316 Irp->IoStatus.Information = sizeof(BATTERY_STATUS);
317 break;
318
319 case IOCTL_BATTERY_QUERY_INFORMATION:
320 if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattQueryInfo))
321 {
322 Status = STATUS_BUFFER_TOO_SMALL;
323 break;
324 }
325
326 BattQueryInfo = Irp->AssociatedIrp.SystemBuffer;
327
328 Status = BattClass->MiniportInfo.QueryInformation(BattClass->MiniportInfo.Context,
329 BattQueryInfo->BatteryTag,
330 BattQueryInfo->InformationLevel,
331 BattQueryInfo->AtRate,
332 Irp->AssociatedIrp.SystemBuffer,
333 IrpSp->Parameters.DeviceIoControl.OutputBufferLength,
334 &ReturnedLength);
335 Irp->IoStatus.Information = ReturnedLength;
336 if (!NT_SUCCESS(Status))
337 DPRINT1("QueryInformation failed (0x%x)\n", Status);
338 break;
339 case IOCTL_BATTERY_SET_INFORMATION:
340 if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < sizeof(*BattSetInfo))
341 {
342 Status = STATUS_BUFFER_TOO_SMALL;
343 break;
344 }
345
346 BattSetInfo = Irp->AssociatedIrp.SystemBuffer;
347
348 Status = BattClass->MiniportInfo.SetInformation(BattClass->MiniportInfo.Context,
349 BattSetInfo->BatteryTag,
350 BattSetInfo->InformationLevel,
351 BattSetInfo->Buffer);
352 if (!NT_SUCCESS(Status))
353 DPRINT1("SetInformation failed (0x%x)\n", Status);
354 break;
355
356 default:
357 DPRINT1("Received unsupported IRP %x\n", IrpSp->Parameters.DeviceIoControl.IoControlCode);
358 /* Do NOT complete the irp */
359 return STATUS_NOT_SUPPORTED;
360 }
361
362 Irp->IoStatus.Status = Status;
363 IoCompleteRequest(Irp, IO_NO_INCREMENT);
364
365 return Status;
366 }