[MSAFD] Add some parameter checks on send/recv based on wine tests. CORE-12104
[reactos.git] / reactos / drivers / wdm / audio / legacy / wdmaud / control.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Kernel Streaming
4 * FILE: drivers/wdm/audio/legacy/wdmaud/deviface.c
5 * PURPOSE: System Audio graph builder
6 * PROGRAMMER: Andrew Greenwood
7 * Johannes Anderwald
8 */
9
10 #include "wdmaud.h"
11
12 #define NDEBUG
13 #include <debug.h>
14
15 const GUID KSPROPSETID_Sysaudio = {0xCBE3FAA0L, 0xCC75, 0x11D0, {0xB4, 0x65, 0x00, 0x00, 0x1A, 0x18, 0x18, 0xE6}};
16
17 NTSTATUS
18 WdmAudControlOpen(
19 IN PDEVICE_OBJECT DeviceObject,
20 IN PIRP Irp,
21 IN PWDMAUD_DEVICE_INFO DeviceInfo,
22 IN PWDMAUD_CLIENT ClientInfo)
23 {
24 if (DeviceInfo->DeviceType == MIXER_DEVICE_TYPE)
25 {
26 return WdmAudControlOpenMixer(DeviceObject, Irp, DeviceInfo, ClientInfo);
27 }
28
29 if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE || DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
30 {
31 return WdmAudControlOpenWave(DeviceObject, Irp, DeviceInfo, ClientInfo);
32 }
33
34 if (DeviceInfo->DeviceType == MIDI_OUT_DEVICE_TYPE || DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE)
35 {
36 return WdmAudControlOpenMidi(DeviceObject, Irp, DeviceInfo, ClientInfo);
37 }
38
39
40 return SetIrpIoStatus(Irp, STATUS_NOT_SUPPORTED, sizeof(WDMAUD_DEVICE_INFO));
41 }
42
43 NTSTATUS
44 WdmAudControlDeviceType(
45 IN PDEVICE_OBJECT DeviceObject,
46 IN PIRP Irp,
47 IN PWDMAUD_DEVICE_INFO DeviceInfo,
48 IN PWDMAUD_CLIENT ClientInfo)
49 {
50 ULONG Result = 0;
51
52 if (DeviceInfo->DeviceType == MIXER_DEVICE_TYPE)
53 {
54 Result = WdmAudGetMixerDeviceCount();
55 }
56 else if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
57 {
58 Result = WdmAudGetWaveInDeviceCount();
59 }
60 else if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
61 {
62 Result = WdmAudGetWaveOutDeviceCount();
63 }
64 else if (DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE)
65 {
66 Result = WdmAudGetMidiInDeviceCount();
67 }
68 else if (DeviceInfo->DeviceType == MIDI_OUT_DEVICE_TYPE)
69 {
70 Result = WdmAudGetMidiOutDeviceCount();
71 }
72
73
74 /* store result count */
75 DeviceInfo->DeviceCount = Result;
76
77 DPRINT("WdmAudControlDeviceType Devices %u\n", DeviceInfo->DeviceCount);
78 return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
79 }
80
81 NTSTATUS
82 WdmAudControlDeviceState(
83 IN PDEVICE_OBJECT DeviceObject,
84 IN PIRP Irp,
85 IN PWDMAUD_DEVICE_INFO DeviceInfo,
86 IN PWDMAUD_CLIENT ClientInfo)
87 {
88 KSPROPERTY Property;
89 KSSTATE State;
90 NTSTATUS Status;
91 ULONG BytesReturned;
92 PFILE_OBJECT FileObject;
93
94 DPRINT("WdmAudControlDeviceState\n");
95
96 Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_READ | GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
97 if (!NT_SUCCESS(Status))
98 {
99 DPRINT1("Error: invalid device handle provided %p Type %x\n", DeviceInfo->hDevice, DeviceInfo->DeviceType);
100 return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
101 }
102
103 Property.Set = KSPROPSETID_Connection;
104 Property.Id = KSPROPERTY_CONNECTION_STATE;
105 Property.Flags = KSPROPERTY_TYPE_SET;
106
107 State = DeviceInfo->u.State;
108
109 Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&State, sizeof(KSSTATE), &BytesReturned);
110
111 ObDereferenceObject(FileObject);
112
113 DPRINT("WdmAudControlDeviceState Status %x\n", Status);
114 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
115 }
116
117 NTSTATUS
118 WdmAudCapabilities(
119 IN PDEVICE_OBJECT DeviceObject,
120 IN PIRP Irp,
121 IN PWDMAUD_DEVICE_INFO DeviceInfo,
122 IN PWDMAUD_CLIENT ClientInfo)
123 {
124 PWDMAUD_DEVICE_EXTENSION DeviceExtension;
125 NTSTATUS Status = STATUS_UNSUCCESSFUL;
126
127 DPRINT("WdmAudCapabilities entered\n");
128
129 DeviceExtension = (PWDMAUD_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
130
131 if (DeviceInfo->DeviceType == MIXER_DEVICE_TYPE)
132 {
133 Status = WdmAudMixerCapabilities(DeviceObject, DeviceInfo, ClientInfo, DeviceExtension);
134 }
135 else if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE || DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
136 {
137 Status = WdmAudWaveCapabilities(DeviceObject, DeviceInfo, ClientInfo, DeviceExtension);
138 }
139 else if (DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE || DeviceInfo->DeviceType == MIDI_OUT_DEVICE_TYPE)
140 {
141 Status = WdmAudMidiCapabilities(DeviceObject, DeviceInfo, ClientInfo, DeviceExtension);
142 }
143
144 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
145 }
146
147 NTSTATUS
148 NTAPI
149 WdmAudIoctlClose(
150 IN PDEVICE_OBJECT DeviceObject,
151 IN PIRP Irp,
152 IN PWDMAUD_DEVICE_INFO DeviceInfo,
153 IN PWDMAUD_CLIENT ClientInfo)
154 {
155 ULONG Index;
156
157 for(Index = 0; Index < ClientInfo->NumPins; Index++)
158 {
159 if (ClientInfo->hPins[Index].Handle == DeviceInfo->hDevice && ClientInfo->hPins[Index].Type != MIXER_DEVICE_TYPE)
160 {
161 DPRINT1("Closing device %p\n", DeviceInfo->hDevice);
162 ZwClose(DeviceInfo->hDevice);
163 ClientInfo->hPins[Index].Handle = NULL;
164 SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
165 return STATUS_SUCCESS;
166 }
167 else if (ClientInfo->hPins[Index].Handle == DeviceInfo->hDevice && ClientInfo->hPins[Index].Type == MIXER_DEVICE_TYPE)
168 {
169 if (ClientInfo->hPins[Index].NotifyEvent)
170 {
171 ObDereferenceObject(ClientInfo->hPins[Index].NotifyEvent);
172 ClientInfo->hPins[Index].NotifyEvent = NULL;
173 }
174 }
175 }
176
177 SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, sizeof(WDMAUD_DEVICE_INFO));
178 return STATUS_INVALID_PARAMETER;
179 }
180
181 NTSTATUS
182 NTAPI
183 WdmAudFrameSize(
184 IN PDEVICE_OBJECT DeviceObject,
185 IN PIRP Irp,
186 IN PWDMAUD_DEVICE_INFO DeviceInfo,
187 IN PWDMAUD_CLIENT ClientInfo)
188 {
189 PFILE_OBJECT FileObject;
190 KSPROPERTY Property;
191 ULONG BytesReturned;
192 KSALLOCATOR_FRAMING Framing;
193 NTSTATUS Status;
194
195 /* Get sysaudio pin file object */
196 Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
197 if (!NT_SUCCESS(Status))
198 {
199 DPRINT1("Invalid buffer handle %p\n", DeviceInfo->hDevice);
200 return SetIrpIoStatus(Irp, Status, 0);
201 }
202
203 /* Setup get framing request */
204 Property.Id = KSPROPERTY_CONNECTION_ALLOCATORFRAMING;
205 Property.Flags = KSPROPERTY_TYPE_GET;
206 Property.Set = KSPROPSETID_Connection;
207
208 Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&Framing, sizeof(KSALLOCATOR_FRAMING), &BytesReturned);
209 /* Did we succeed */
210 if (NT_SUCCESS(Status))
211 {
212 /* Store framesize */
213 DeviceInfo->u.FrameSize = Framing.FrameSize;
214 }
215
216 /* Release file object */
217 ObDereferenceObject(FileObject);
218
219 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
220
221 }
222
223 NTSTATUS
224 NTAPI
225 WdmAudGetDeviceInterface(
226 IN PDEVICE_OBJECT DeviceObject,
227 IN PIRP Irp,
228 IN PWDMAUD_DEVICE_INFO DeviceInfo)
229 {
230 NTSTATUS Status;
231 LPWSTR Device;
232 ULONG Size, Length;
233
234 /* get device interface string input length */
235 Size = DeviceInfo->u.Interface.DeviceInterfaceStringSize;
236
237 /* get mixer info */
238 Status = WdmAudGetPnpNameByIndexAndType(DeviceInfo->DeviceIndex, DeviceInfo->DeviceType, &Device);
239
240 /* check for success */
241 if (!NT_SUCCESS(Status))
242 {
243 /* invalid device id */
244 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
245 }
246
247 /* calculate length */
248 Length = (wcslen(Device)+1) * sizeof(WCHAR);
249
250 if (!Size)
251 {
252 /* store device interface size */
253 DeviceInfo->u.Interface.DeviceInterfaceStringSize = Length;
254 }
255 else if (Size < Length)
256 {
257 /* buffer too small */
258 DeviceInfo->u.Interface.DeviceInterfaceStringSize = Length;
259 return SetIrpIoStatus(Irp, STATUS_BUFFER_OVERFLOW, sizeof(WDMAUD_DEVICE_INFO));
260 }
261 else
262 {
263 //FIXME SEH
264 RtlMoveMemory(DeviceInfo->u.Interface.DeviceInterfaceString, Device, Length);
265 }
266
267 FreeItem(Device);
268 return SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
269 }
270
271 NTSTATUS
272 NTAPI
273 WdmAudResetStream(
274 IN PDEVICE_OBJECT DeviceObject,
275 IN PIRP Irp,
276 IN PWDMAUD_DEVICE_INFO DeviceInfo)
277 {
278 KSRESET ResetStream;
279 NTSTATUS Status;
280 ULONG BytesReturned;
281 PFILE_OBJECT FileObject;
282
283 DPRINT("WdmAudResetStream\n");
284
285 Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_READ | GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
286 if (!NT_SUCCESS(Status))
287 {
288 DPRINT1("Error: invalid device handle provided %p Type %x\n", DeviceInfo->hDevice, DeviceInfo->DeviceType);
289 return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
290 }
291
292 ResetStream = DeviceInfo->u.ResetStream;
293 ASSERT(ResetStream == KSRESET_BEGIN || ResetStream == KSRESET_END);
294
295 Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_RESET_STATE, (PVOID)&ResetStream, sizeof(KSRESET), NULL, 0, &BytesReturned);
296
297 ObDereferenceObject(FileObject);
298
299 DPRINT("WdmAudResetStream Status %x\n", Status);
300 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
301 }
302
303 NTSTATUS
304 NTAPI
305 WdmAudDeviceControl(
306 IN PDEVICE_OBJECT DeviceObject,
307 IN PIRP Irp)
308 {
309 PIO_STACK_LOCATION IoStack;
310 PWDMAUD_DEVICE_INFO DeviceInfo;
311 PWDMAUD_CLIENT ClientInfo;
312
313 IoStack = IoGetCurrentIrpStackLocation(Irp);
314
315 DPRINT("WdmAudDeviceControl entered\n");
316
317 if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(WDMAUD_DEVICE_INFO))
318 {
319 /* invalid parameter */
320 DPRINT1("Input buffer too small size %u expected %u\n", IoStack->Parameters.DeviceIoControl.InputBufferLength, sizeof(WDMAUD_DEVICE_INFO));
321 return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
322 }
323
324 DeviceInfo = (PWDMAUD_DEVICE_INFO)Irp->AssociatedIrp.SystemBuffer;
325
326 if (DeviceInfo->DeviceType < MIN_SOUND_DEVICE_TYPE || DeviceInfo->DeviceType > MAX_SOUND_DEVICE_TYPE)
327 {
328 /* invalid parameter */
329 DPRINT1("Error: device type not set\n");
330 return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
331 }
332
333 if (!IoStack->FileObject || !IoStack->FileObject->FsContext)
334 {
335 /* file object parameter */
336 DPRINT1("Error: file object is not attached\n");
337 return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
338 }
339 ClientInfo = (PWDMAUD_CLIENT)IoStack->FileObject->FsContext;
340
341 DPRINT("WdmAudDeviceControl entered\n");
342
343 switch(IoStack->Parameters.DeviceIoControl.IoControlCode)
344 {
345 case IOCTL_OPEN_WDMAUD:
346 return WdmAudControlOpen(DeviceObject, Irp, DeviceInfo, ClientInfo);
347 case IOCTL_GETNUMDEVS_TYPE:
348 return WdmAudControlDeviceType(DeviceObject, Irp, DeviceInfo, ClientInfo);
349 case IOCTL_SETDEVICE_STATE:
350 return WdmAudControlDeviceState(DeviceObject, Irp, DeviceInfo, ClientInfo);
351 case IOCTL_GETCAPABILITIES:
352 return WdmAudCapabilities(DeviceObject, Irp, DeviceInfo, ClientInfo);
353 case IOCTL_CLOSE_WDMAUD:
354 return WdmAudIoctlClose(DeviceObject, Irp, DeviceInfo, ClientInfo);
355 case IOCTL_GETFRAMESIZE:
356 return WdmAudFrameSize(DeviceObject, Irp, DeviceInfo, ClientInfo);
357 case IOCTL_GETLINEINFO:
358 return WdmAudGetLineInfo(DeviceObject, Irp, DeviceInfo, ClientInfo);
359 case IOCTL_GETLINECONTROLS:
360 return WdmAudGetLineControls(DeviceObject, Irp, DeviceInfo, ClientInfo);
361 case IOCTL_SETCONTROLDETAILS:
362 return WdmAudSetControlDetails(DeviceObject, Irp, DeviceInfo, ClientInfo);
363 case IOCTL_GETCONTROLDETAILS:
364 return WdmAudGetControlDetails(DeviceObject, Irp, DeviceInfo, ClientInfo);
365 case IOCTL_QUERYDEVICEINTERFACESTRING:
366 return WdmAudGetDeviceInterface(DeviceObject, Irp, DeviceInfo);
367 case IOCTL_GET_MIXER_EVENT:
368 return WdmAudGetMixerEvent(DeviceObject, Irp, DeviceInfo, ClientInfo);
369 case IOCTL_RESET_STREAM:
370 return WdmAudResetStream(DeviceObject, Irp, DeviceInfo);
371 case IOCTL_GETPOS:
372 case IOCTL_GETDEVID:
373 case IOCTL_GETVOLUME:
374 case IOCTL_SETVOLUME:
375
376 DPRINT1("Unhandeled %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
377 break;
378 }
379
380 return SetIrpIoStatus(Irp, STATUS_NOT_IMPLEMENTED, 0);
381 }
382
383 NTSTATUS
384 NTAPI
385 IoCompletion (
386 PDEVICE_OBJECT DeviceObject,
387 PIRP Irp,
388 PVOID Ctx)
389 {
390 PKSSTREAM_HEADER Header;
391 PMDL Mdl, NextMdl;
392 PWDMAUD_COMPLETION_CONTEXT Context = (PWDMAUD_COMPLETION_CONTEXT)Ctx;
393
394 /* get stream header */
395 Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
396
397 /* sanity check */
398 ASSERT(Header);
399
400 /* time to free all allocated mdls */
401 Mdl = Irp->MdlAddress;
402
403 while(Mdl)
404 {
405 /* get next mdl */
406 NextMdl = Mdl->Next;
407
408 /* unlock pages */
409 MmUnlockPages(Mdl);
410
411 /* grab next mdl */
412 Mdl = NextMdl;
413 }
414 //IoFreeMdl(Mdl);
415 /* clear mdl list */
416 Irp->MdlAddress = Context->Mdl;
417
418
419
420 DPRINT("IoCompletion Irp %p IoStatus %lx Information %lx\n", Irp, Irp->IoStatus.Status, Irp->IoStatus.Information);
421
422 if (!NT_SUCCESS(Irp->IoStatus.Status))
423 {
424 /* failed */
425 Irp->IoStatus.Information = 0;
426 }
427
428 /* dereference file object */
429 ObDereferenceObject(Context->FileObject);
430
431 /* free context */
432 FreeItem(Context);
433
434 return STATUS_SUCCESS;
435 }
436
437 NTSTATUS
438 NTAPI
439 WdmAudReadWrite(
440 IN PDEVICE_OBJECT DeviceObject,
441 IN PIRP Irp)
442 {
443 NTSTATUS Status;
444 PWDMAUD_DEVICE_INFO DeviceInfo;
445 PFILE_OBJECT FileObject;
446 PIO_STACK_LOCATION IoStack;
447 ULONG Length;
448 PMDL Mdl;
449 BOOLEAN Read = TRUE;
450 PWDMAUD_COMPLETION_CONTEXT Context;
451
452 /* allocate completion context */
453 Context = AllocateItem(NonPagedPool, sizeof(WDMAUD_COMPLETION_CONTEXT));
454
455 if (!Context)
456 {
457 /* not enough memory */
458 Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
459 IoCompleteRequest(Irp, IO_NO_INCREMENT);
460
461 /* done */
462 return STATUS_INSUFFICIENT_RESOURCES;
463 }
464
465 /* get current irp stack location */
466 IoStack = IoGetCurrentIrpStackLocation(Irp);
467
468 /* store the input buffer in UserBuffer - as KsProbeStreamIrp operates on IRP_MJ_DEVICE_CONTROL */
469 Irp->UserBuffer = MmGetMdlVirtualAddress(Irp->MdlAddress);
470
471 /* sanity check */
472 ASSERT(Irp->UserBuffer);
473
474 /* get the length of the request length */
475 Length = IoStack->Parameters.Write.Length;
476
477 /* store outputbuffer length */
478 IoStack->Parameters.DeviceIoControl.OutputBufferLength = Length;
479
480 /* setup context */
481 Context->Length = Length;
482 Context->Function = (IoStack->MajorFunction == IRP_MJ_WRITE ? IOCTL_KS_WRITE_STREAM : IOCTL_KS_READ_STREAM);
483 Context->Mdl = Irp->MdlAddress;
484
485 /* store mdl address */
486 Mdl = Irp->MdlAddress;
487
488 /* remove mdladdress as KsProbeStreamIrp will interprete it as an already probed audio buffer */
489 Irp->MdlAddress = NULL;
490
491 if (IoStack->MajorFunction == IRP_MJ_WRITE)
492 {
493 /* probe the write stream irp */
494 Read = FALSE;
495 Status = KsProbeStreamIrp(Irp, KSPROBE_STREAMWRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK, Length);
496 }
497 else
498 {
499 /* probe the read stream irp */
500 Status = KsProbeStreamIrp(Irp, KSPROBE_STREAMREAD | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK, Length);
501 }
502
503 if (!NT_SUCCESS(Status))
504 {
505 DPRINT1("KsProbeStreamIrp failed with Status %x Cancel %u\n", Status, Irp->Cancel);
506 Irp->MdlAddress = Mdl;
507 FreeItem(Context);
508 return SetIrpIoStatus(Irp, Status, 0);
509 }
510
511 /* get device info */
512 DeviceInfo = (PWDMAUD_DEVICE_INFO)Irp->AssociatedIrp.SystemBuffer;
513 ASSERT(DeviceInfo);
514
515 /* now get sysaudio file object */
516 Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_WRITE, *IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
517 if (!NT_SUCCESS(Status))
518 {
519 DPRINT1("Invalid pin handle %p\n", DeviceInfo->hDevice);
520 Irp->MdlAddress = Mdl;
521 FreeItem(Context);
522 return SetIrpIoStatus(Irp, Status, 0);
523 }
524
525 /* store file object whose reference is released in the completion callback */
526 Context->FileObject = FileObject;
527
528 /* skip current irp stack location */
529 IoSkipCurrentIrpStackLocation(Irp);
530
531 /* get next stack location */
532 IoStack = IoGetNextIrpStackLocation(Irp);
533
534 /* prepare stack location */
535 IoStack->FileObject = FileObject;
536 IoStack->Parameters.Write.Length = Length;
537 IoStack->MajorFunction = IRP_MJ_WRITE;
538 IoStack->Parameters.DeviceIoControl.IoControlCode = (Read ? IOCTL_KS_READ_STREAM : IOCTL_KS_WRITE_STREAM);
539 IoSetCompletionRoutine(Irp, IoCompletion, (PVOID)Context, TRUE, TRUE, TRUE);
540
541 /* mark irp as pending */
542 // IoMarkIrpPending(Irp);
543 /* call the driver */
544 Status = IoCallDriver(IoGetRelatedDeviceObject(FileObject), Irp);
545 return Status;
546 }