0bb191d131358db7732d9b377ca43be5a076907e
[reactos.git] / drivers / network / ndisuio / ioctl.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS NDIS User I/O driver
4 * FILE: ioctl.c
5 * PURPOSE: IOCTL handling
6 * PROGRAMMERS: Cameron Gutman (cameron.gutman@reactos.org)
7 */
8
9 #include "ndisuio.h"
10
11 #define NDEBUG
12 #include <debug.h>
13
14
15 NTSTATUS
16 WaitForBind(PIRP Irp, PIO_STACK_LOCATION IrpSp)
17 {
18 /* I've seen several code samples that use this IOCTL but there's
19 * no official documentation on it. I'm just implementing it as a no-op
20 * right now because I don't see any reason we need it. We handle an open
21 * and bind just fine with IRP_MJ_CREATE and IOCTL_NDISUIO_OPEN_DEVICE */
22
23 Irp->IoStatus.Status = STATUS_SUCCESS;
24 Irp->IoStatus.Information = 0;
25
26 IoCompleteRequest(Irp, IO_NO_INCREMENT);
27
28 return STATUS_SUCCESS;
29 }
30
31 NTSTATUS
32 QueryBinding(PIRP Irp, PIO_STACK_LOCATION IrpSp)
33 {
34 PNDISUIO_ADAPTER_CONTEXT AdapterContext;
35 PNDISUIO_QUERY_BINDING QueryBinding = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
36 ULONG BindingLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
37 NTSTATUS Status;
38 PLIST_ENTRY CurrentEntry;
39 KIRQL OldIrql;
40 ULONG i;
41 ULONG BytesCopied = 0;
42
43 if (QueryBinding && BindingLength >= sizeof(NDISUIO_QUERY_BINDING))
44 {
45 KeAcquireSpinLock(&GlobalAdapterListLock, &OldIrql);
46 i = 0;
47 CurrentEntry = GlobalAdapterList.Flink;
48 while (CurrentEntry != &GlobalAdapterList)
49 {
50 if (i == QueryBinding->BindingIndex)
51 break;
52 i++;
53 CurrentEntry = CurrentEntry->Flink;
54 }
55 KeReleaseSpinLock(&GlobalAdapterListLock, OldIrql);
56 if (i == QueryBinding->BindingIndex)
57 {
58 AdapterContext = CONTAINING_RECORD(CurrentEntry, NDISUIO_ADAPTER_CONTEXT, ListEntry);
59 if (AdapterContext->DeviceName.Length <= QueryBinding->DeviceNameLength)
60 {
61 BytesCopied += AdapterContext->DeviceName.Length;
62 RtlCopyMemory((PUCHAR)QueryBinding + QueryBinding->DeviceNameOffset,
63 AdapterContext->DeviceName.Buffer,
64 BytesCopied);
65 QueryBinding->DeviceNameLength = AdapterContext->DeviceName.Length;
66
67 /* FIXME: Copy description too */
68 QueryBinding->DeviceDescrLength = 0;
69
70 /* Successful */
71 Status = STATUS_SUCCESS;
72 }
73 else
74 {
75 /* Not enough buffer space */
76 Status = STATUS_BUFFER_TOO_SMALL;
77 }
78 }
79 else
80 {
81 /* Invalid index */
82 Status = STATUS_NO_MORE_ENTRIES;
83 }
84 }
85 else
86 {
87 /* Invalid parameters */
88 Status = STATUS_INVALID_PARAMETER;
89 }
90
91 Irp->IoStatus.Status = Status;
92 Irp->IoStatus.Information = BytesCopied;
93
94 IoCompleteRequest(Irp, IO_NO_INCREMENT);
95
96 return Status;
97 }
98
99 NTSTATUS
100 CancelPacketRead(PIRP Irp, PIO_STACK_LOCATION IrpSp)
101 {
102 PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
103 PNDISUIO_PACKET_ENTRY PacketEntry;
104 NTSTATUS Status;
105
106 /* Indicate a 0-byte packet on the queue so one read returns 0 */
107 PacketEntry = ExAllocatePool(PagedPool, sizeof(NDISUIO_PACKET_ENTRY));
108 if (PacketEntry)
109 {
110 PacketEntry->PacketLength = 0;
111
112 ExInterlockedInsertHeadList(&AdapterContext->PacketList,
113 &PacketEntry->ListEntry,
114 &AdapterContext->Spinlock);
115
116 KeSetEvent(&AdapterContext->PacketReadEvent, IO_NO_INCREMENT, FALSE);
117
118 Status = STATUS_SUCCESS;
119 }
120 else
121 {
122 Status = STATUS_NO_MEMORY;
123 }
124
125 Irp->IoStatus.Status = Status;
126 Irp->IoStatus.Information = 0;
127
128 IoCompleteRequest(Irp, IO_NO_INCREMENT);
129
130 return Status;
131 }
132
133 NTSTATUS
134 SetAdapterOid(PIRP Irp, PIO_STACK_LOCATION IrpSp)
135 {
136 PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
137 PNDISUIO_SET_OID SetOidRequest;
138 NDIS_REQUEST NdisRequest;
139 ULONG RequestLength;
140 NDIS_STATUS Status;
141
142 Irp->IoStatus.Information = 0;
143
144 SetOidRequest = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
145 RequestLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
146 if (QueryOidRequest && RequestLength >= sizeof(NDIS_OID))
147 {
148 /* Setup the NDIS request */
149 NdisRequest.RequestType = NdisRequestSetInformation;
150 NdisRequest.Oid = SetOidRequest->Oid;
151 NdisRequest.InformationBuffer = SetOidRequest->Data;
152 NdisRequest.InformationBufferLength = RequestLength - sizeof(NDIS_OID);
153
154 /* Dispatch the request */
155 NdisRequest(&Status,
156 AdapterContext->BindingHandle,
157 &NdisRequest);
158
159 /* Wait for the request */
160 if (Status == NDIS_STATUS_PENDING)
161 {
162 KeWaitForSingleObject(&AdapterContext->AsyncEvent,
163 Executive,
164 KernelMode,
165 FALSE,
166 NULL);
167 Status = AdapterContext->AsyncStatus;
168 }
169
170 /* Return the bytes read */
171 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = NdisRequest.BytesRead;
172 }
173 else
174 {
175 /* Bad parameters */
176 Status = STATUS_INVALID_PARAMETER;
177 }
178
179 Irp->IoStatus.Status = Status;
180
181 IoCompleteRequest(Irp, IO_NO_INCREMENT);
182
183 return Status;
184 }
185
186 NTSTATUS
187 QueryAdapterOid(PIRP Irp, PIO_STACK_LOCATION IrpSp)
188 {
189 PNDISUIO_ADAPTER_CONTEXT AdapterContext = IrpSp->FileObject->FsContext;
190 PNDISUIO_QUERY_OID QueryOidRequest;
191 NDIS_REQUEST NdisRequest;
192 ULONG RequestLength;
193 NDIS_STATUS Status;
194
195 Irp->IoStatus.Information = 0;
196
197 QueryOidRequest = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
198 RequestLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
199 if (QueryOidRequest && RequestLength >= sizeof(NDIS_OID))
200 {
201 /* Setup the NDIS request */
202 NdisRequest.RequestType = NdisRequestQueryInformation;
203 NdisRequest.Oid = QueryOidRequest->Oid;
204 NdisRequest.InformationBuffer = QueryOidRequest->Data;
205 NdisRequest.InformationBufferLength = RequestLength - sizeof(NDIS_OID);
206
207 /* Dispatch the request */
208 NdisRequest(&Status,
209 AdapterContext->BindingHandle,
210 &NdisRequest);
211
212 /* Wait for the request */
213 if (Status == NDIS_STATUS_PENDING)
214 {
215 KeWaitForSingleObject(&AdapterContext->AsyncEvent,
216 Executive,
217 KernelMode,
218 FALSE,
219 NULL);
220 Status = AdapterContext->AsyncStatus;
221 }
222
223 /* Return the bytes written */
224 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = NdisRequest.BytesWritten;
225 }
226 else
227 {
228 /* Bad parameters */
229 Status = STATUS_INVALID_PARAMETER;
230 }
231
232 Irp->IoStatus.Status = Status;
233
234 IoCompleteRequest(Irp, IO_NO_INCREMENT);
235
236 return Status;
237 }
238
239 NTSTATUS
240 OpenDeviceReadWrite(PIRP Irp, PIO_STACK_LOCATION IrpSp)
241 {
242 PFILE_OBJECT FileObject = IrpSp->FileObject;
243 UNICODE_STRING DeviceName;
244 ULONG NameLength;
245 NTSTATUS Status;
246 PNDISUIO_ADAPTER_CONTEXT AdapterContext;
247 PNDISUIO_OPEN_ENTRY OpenEntry;
248 KIRQL OldIrql;
249
250 NameLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
251 if (NameLength != 0)
252 {
253 DeviceName.MaximumLength = DeviceName.Length = NameLength;
254 DeviceName.Buffer = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
255
256 /* Check if this already has a context */
257 AdapterContext = FindAdapterContextByName(&DeviceName);
258 if (AdapterContext != NULL)
259 {
260 /* Reference the adapter context */
261 KeAcquireSpinLock(&AdapterContext->Spinlock, &OldIrql);
262 if (AdapterContext->OpenCount != 0)
263 {
264 /* An open for read-write is exclusive,
265 * so we can't have any other open handles */
266 KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
267 Status = STATUS_INVALID_PARAMETER;
268 }
269 else
270 {
271 /* Add a reference */
272 ReferenceAdapterContext(AdapterContext);
273 Status = STATUS_SUCCESS;
274 }
275 }
276 else
277 {
278 /* Invalid device name */
279 Status = STATUS_INVALID_PARAMETER;
280 }
281
282 /* Check that the bind succeeded */
283 if (NT_SUCCESS(Status))
284 {
285 OpenEntry = ExAllocatePool(NonPagedPool, sizeof(*OpenEntry));
286 if (OpenEntry)
287 {
288 /* Set the file object pointer */
289 OpenEntry->FileObject = FileObject;
290
291 /* Set the permissions */
292 OpenEntry->WriteOnly = FALSE;
293
294 /* Associate this FO with the adapter */
295 FileObject->FsContext = AdapterContext;
296 FileObject->FsContext2 = OpenEntry;
297
298 /* Add it to the adapter's list */
299 InsertTailList(&AdapterContext->OpenEntryList,
300 &OpenEntry->ListEntry);
301
302 /* Success */
303 KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
304 Status = STATUS_SUCCESS;
305 }
306 else
307 {
308 /* Remove the reference we added */
309 KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
310 DereferenceAdapterContext(AdapterContext, NULL);
311 Status = STATUS_NO_MEMORY;
312 }
313 }
314 }
315 else
316 {
317 /* Invalid device name */
318 Status = STATUS_INVALID_PARAMETER;
319 }
320
321 Irp->IoStatus.Status = Status;
322 Irp->IoStatus.Information = 0;
323
324 IoCompleteRequest(Irp, IO_NO_INCREMENT);
325
326 return Status;
327 }
328
329 NTSTATUS
330 OpenDeviceWrite(PIRP Irp, PIO_STACK_LOCATION IrpSp)
331 {
332 PFILE_OBJECT FileObject = IrpSp->FileObject;
333 UNICODE_STRING DeviceName;
334 ULONG NameLength;
335 NTSTATUS Status;
336 PNDISUIO_ADAPTER_CONTEXT AdapterContext;
337 PNDISUIO_OPEN_ENTRY OpenEntry;
338 KIRQL OldIrql;
339
340 NameLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
341 if (NameLength != 0)
342 {
343 DeviceName.MaximumLength = DeviceName.Length = NameLength;
344 DeviceName.Buffer = IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
345
346 /* Check if this already has a context */
347 AdapterContext = FindAdapterContextByName(&DeviceName);
348 if (AdapterContext != NULL)
349 {
350 /* Reference the adapter context */
351 KeAcquireSpinLock(&AdapterContext->Spinlock, &OldIrql);
352 ReferenceAdapterContext(AdapterContext);
353 Status = STATUS_SUCCESS;
354 }
355 else
356 {
357 /* Invalid device name */
358 Status = STATUS_INVALID_PARAMETER;
359 }
360
361 /* Check that the bind succeeded */
362 if (NT_SUCCESS(Status))
363 {
364 OpenEntry = ExAllocatePool(NonPagedPool, sizeof(*OpenEntry));
365 if (OpenEntry)
366 {
367 /* Set the file object pointer */
368 OpenEntry->FileObject = FileObject;
369
370 /* Associate this FO with the adapter */
371 FileObject->FsContext = AdapterContext;
372 FileObject->FsContext2 = OpenEntry;
373
374 /* Set permissions */
375 OpenEntry->WriteOnly = TRUE;
376
377 /* Add it to the adapter's list */
378 InsertTailList(&AdapterContext->OpenEntryList,
379 &OpenEntry->ListEntry);
380
381 /* Success */
382 KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
383 Status = STATUS_SUCCESS;
384 }
385 else
386 {
387 /* Remove the reference we added */
388 KeReleaseSpinLock(&AdapterContext->Spinlock, OldIrql);
389 DereferenceAdapterContext(AdapterContext, NULL);
390 Status = STATUS_NO_MEMORY;
391 }
392 }
393 }
394 else
395 {
396 /* Invalid device name */
397 Status = STATUS_INVALID_PARAMETER;
398 }
399
400 Irp->IoStatus.Status = Status;
401 Irp->IoStatus.Information = 0;
402
403 IoCompleteRequest(Irp, IO_NO_INCREMENT);
404
405 return Status;
406 }
407
408 NTSTATUS
409 NTAPI
410 NduDispatchDeviceControl(PDEVICE_OBJECT DeviceObject,
411 PIRP Irp)
412 {
413 PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
414 PNDISUIO_OPEN_ENTRY OpenEntry;
415
416 ASSERT(DeviceObject == GlobalDeviceObject);
417
418 /* Handle open IOCTLs first */
419 switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
420 {
421 case IOCTL_NDISUIO_OPEN_DEVICE:
422 return OpenDeviceReadWrite(Irp, IrpSp);
423
424 case IOCTL_NDISUIO_OPEN_WRITE_DEVICE:
425 return OpenDeviceWrite(Irp, IrpSp);
426
427 case IOCTL_NDISUIO_BIND_WAIT:
428 return WaitForBind(Irp, IrpSp);
429
430 case IOCTL_NDISUIO_QUERY_BINDING:
431 return QueryBinding(Irp, IrpSp);
432
433 default:
434 /* Fail if this file object has no adapter associated */
435 if (IrpSp->FileObject->FsContext == NULL)
436 {
437 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
438 Irp->IoStatus.Information = 0;
439 IoCompleteRequest(Irp, IO_NO_INCREMENT);
440
441 return STATUS_INVALID_PARAMETER;
442 }
443
444 /* Now handle write IOCTLs */
445 switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
446 {
447 case IOCTL_NDISUIO_SET_OID_VALUE:
448 return SetAdapterOid(Irp, IrpSp);
449
450 default:
451 /* Check that we have read permissions */
452 OpenEntry = IrpSp->FileObject->FsContext2;
453 if (OpenEntry->WriteOnly)
454 {
455 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
456 Irp->IoStatus.Information = 0;
457 IoCompleteRequest(Irp, IO_NO_INCREMENT);
458
459 return STATUS_INVALID_PARAMETER;
460 }
461
462 switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
463 {
464 case IOCTL_CANCEL_READ:
465 return CancelPacketRead(Irp, IrpSp);
466
467 case IOCTL_NDISUIO_QUERY_OID_VALUE:
468 return QueryAdapterOid(Irp, IrpSp);
469
470 default:
471 DPRINT1("Unimplemented\n");
472 Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
473 Irp->IoStatus.Information = 0;
474 IoCompleteRequest(Irp, IO_NO_INCREMENT);
475 break;
476 }
477 }
478 break;
479 }
480 }