![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dispatch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib|
Return to dispatch.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / soundlib |
1.1 root 1: /*++
2:
3: Copyright (c) 1992 Microsoft Corporation
4:
5: Module Name:
6:
7: dispatch.c
8:
9: Abstract:
10:
11: This module contains code for the function dispatcher.
12:
13: Author:
14:
15: Robin Speed (RobinSp) 22-Oct-1992
16:
17: Environment:
18:
19: Kernel mode
20:
21: Revision History:
22:
23: Robin Speed (RobinSp) 29-Jan-1992 - Add extra IOCTLs and access control
24:
25: --*/
26:
27: #include <string.h>
28: #include <soundlib.h> // Definition of what's in here
29:
30: /**************************************************************************
31: *
32: *
33: * Function dispatch
34: *
35: *
36: **************************************************************************/
37:
38:
39: NTSTATUS
40: SoundSetShareAccess(
41: IN OUT PLOCAL_DEVICE_INFO pLDI,
42: IN PIO_STACK_LOCATION IrpStack
43: )
44: /*++
45:
46: Routine Description:
47:
48: Tests if access is allowed to the device on the basis of the sharing
49: requested.
50:
51: Also sets the PreventVolumeSetting flag up in the local device info
52:
53: If write access required and the device is already in use we return
54: STATUS_DEVICE_BUSY.
55:
56: If shared write was requested set the flag to say that others can
57: set the volume
58:
59: Arguments:
60:
61: pLDI - Local device info
62: pIrp - Pointer to IO request packet
63: IrpStack - stack location info
64:
65: Return Value:
66:
67: Return status from dispatched routine
68:
69: --*/
70: {
71: NTSTATUS Status;
72:
73: //
74: // Get the system to update the file object access flags
75: //
76: {
77: SHARE_ACCESS ShareAccess;
78: IoSetShareAccess(IrpStack->Parameters.Create.SecurityContext->DesiredAccess,
79: (ULONG)IrpStack->Parameters.Create.ShareAccess,
80: IrpStack->FileObject,
81: &ShareAccess);
82: }
83: //
84: // Always allow non-write access. For neatness we'll require
85: // that read access was requested
86: //
87: if (IrpStack->Parameters.Create.SecurityContext->DesiredAccess & FILE_READ_DATA) {
88: if (IrpStack->Parameters.Create.SecurityContext->DesiredAccess & FILE_WRITE_DATA) {
89: ASSERT(IrpStack->FileObject->WriteAccess);
90: dprintf2(("Trying to open device %4.4s for write",
91: (char *)&pLDI->Key));
92:
93: if (!(*pLDI->DeviceInit->ExclusionRoutine)(
94: pLDI, SoundExcludeOpen)) {
95: Status = STATUS_DEVICE_BUSY;
96: } else {
97: Status = STATUS_SUCCESS;
98: }
99:
100: //
101: // Note that if share for write is given this is a way
102: // of saying that others can set our volume with just read
103: // access
104: //
105: pLDI->PreventVolumeSetting = FALSE;
106: if (NT_SUCCESS(Status)) {
107: if (IrpStack->FileObject->SharedWrite) {
108: } else {
109: pLDI->PreventVolumeSetting = TRUE;
110: }
111: }
112: } else {
113: Status = STATUS_SUCCESS;
114: }
115: } else {
116: Status = STATUS_ACCESS_DENIED;
117: }
118:
119: return Status;
120: }
121:
122:
123: NTSTATUS
124: SoundDispatch(
125: IN PDEVICE_OBJECT pDO,
126: IN PIRP pIrp
127: )
128: /*++
129:
130: Routine Description:
131:
132: Driver function dispatch routine
133:
134: Arguments:
135:
136: pDO - Pointer to device object
137: pIrp - Pointer to IO request packet
138:
139: Return Value:
140:
141: Return status from dispatched routine
142:
143: --*/
144: {
145: PLOCAL_DEVICE_INFO pLDI;
146: PIO_STACK_LOCATION pIrpStack;
147: NTSTATUS Status;
148:
149: Status = STATUS_SUCCESS;
150:
151: //
152: // Initialize the irp information field.
153: //
154:
155: pIrp->IoStatus.Information = 0;
156:
157: //
158: // get the address of the local info structure in the device extension
159: //
160:
161: pLDI = (PLOCAL_DEVICE_INFO)pDO->DeviceExtension;
162:
163: //
164: // Acquire the device mutant - we need to do this for some
165: // devices anyway because we have to execute waits for slow
166: // operations to complete
167: //
168:
169: if (!(*pLDI->DeviceInit->ExclusionRoutine)(pLDI, SoundExcludeEnter)) {
170: Status = STATUS_DEVICE_BUSY;
171: } else {
172: //
173: // Dispatch the function based on the major function code
174: //
175:
176: pIrpStack = IoGetCurrentIrpStackLocation(pIrp);
177:
178: #ifdef VOLUME_NOTIFY
179:
180: /**********************************************************************
181: *
182: * Do general volume stuff here
183: *
184: **********************************************************************/
185:
186: //
187: // Free anyone waiting for the volume to change
188: //
189:
190: if (pIrpStack->MajorFunction == IRP_MJ_CLEANUP) {
191:
192: int i;
193: KIRQL OldIrql;
194:
195: //
196: // Free anyone waiting for the volume to change whose file object
197: // is the one about to be closed.
198: //
199:
200: PLIST_ENTRY ListEntry, Next;
201:
202: //
203: // Our list is cancellable so do this under the cancel spin
204: // lock
205: //
206:
207: IoAcquireCancelSpinLock(&OldIrql);
208:
209: for (ListEntry = pLDI->VolumeQueue.Flink;
210: ListEntry != &pLDI->VolumeQueue;
211: ListEntry = Next) {
212:
213: PIRP IrpList;
214: IrpList = CONTAINING_RECORD(ListEntry, IRP, Tail.Overlay.ListEntry);
215:
216: Next = ListEntry->Flink;
217:
218: ASSERT(IoGetCurrentIrpStackLocation(IrpList)->MajorFunction ==
219: IRP_MJ_DEVICE_CONTROL &&
220: IoGetCurrentIrpStackLocation(IrpList)->
221: Parameters.DeviceIoControl.IoControlCode ==
222: IOCTL_SOUND_GET_CHANGED_VOLUME);
223:
224: if (pIrpStack->FileObject ==
225: IoGetCurrentIrpStackLocation(IrpList)->FileObject) {
226:
227: RemoveEntryList(ListEntry);
228:
229: //
230: // Make sure our cancel routine doesn't get in!
231: //
232:
233: IoSetCancelRoutine(IrpList, NULL);
234:
235:
236: //
237: // Free the spin lock in case IoCompleteRequest doesn't
238: // like us to hold it
239: //
240:
241: IoReleaseCancelSpinLock(OldIrql);
242:
243: IrpList->IoStatus.Status = STATUS_SUCCESS;
244: IoCompleteRequest(IrpList, IO_NO_INCREMENT);
245:
246: IoAcquireCancelSpinLock(&OldIrql);
247:
248: //
249: // The world may have changed so restart
250: //
251:
252: Next = pLDI->VolumeQueue.Flink;
253: }
254: }
255:
256: IoReleaseCancelSpinLock(OldIrql);
257: }
258:
259: #endif // VOLUME_NOTIFY
260:
261: //
262: // Call the real device code
263: //
264:
265: if (NT_SUCCESS(Status)) {
266: Status = (*pLDI->DeviceInit->DispatchRoutine)(pLDI, pIrp, pIrpStack);
267: }
268:
269: //
270: // Free the device
271: //
272:
273: (*pLDI->DeviceInit->ExclusionRoutine)(pLDI, SoundExcludeLeave);
274: }
275:
276: //
277: // Tell the IO subsystem we're done. If the Irp is pending we
278: // don't touch it as it could be being processed by another
279: // processor (or may even be complete already !).
280: //
281:
282: if (Status != STATUS_PENDING) {
283: pIrp->IoStatus.Status = Status;
284: IoCompleteRequest(pIrp, IO_SOUND_INCREMENT );
285: }
286:
287: return Status;
288: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.