- Forgot to commit these for MSVC build...
[reactos.git] / reactos / drivers / net / tcpip / tcpip / dispatch.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS TCP/IP protocol driver
4 * FILE: tcpip/dispatch.h
5 * PURPOSE: TDI dispatch routines
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * REVISIONS:
8 * CSH 01/08-2000 Created
9 * TODO: Validate device object in all dispatch routines
10 */
11
12 #include "precomp.h"
13 #include <pseh/pseh.h>
14
15 NTSTATUS DispPrepareIrpForCancel(
16 PTRANSPORT_CONTEXT Context,
17 PIRP Irp,
18 PDRIVER_CANCEL CancelRoutine)
19 /*
20 * FUNCTION: Prepare an IRP for cancellation
21 * ARGUMENTS:
22 * Context = Pointer to context information
23 * Irp = Pointer to an I/O request packet
24 * CancelRoutine = Routine to be called when I/O request is cancelled
25 * RETURNS:
26 * Status of operation
27 */
28 {
29 KIRQL OldIrql;
30
31 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
32
33 IoAcquireCancelSpinLock(&OldIrql);
34
35 if (!Irp->Cancel) {
36 IoMarkIrpPending(Irp);
37 IoSetCancelRoutine(Irp, CancelRoutine);
38 IoReleaseCancelSpinLock(OldIrql);
39
40 TI_DbgPrint(DEBUG_IRP, ("Leaving (IRP at 0x%X can now be cancelled).\n", Irp));
41
42 return STATUS_SUCCESS;
43 }
44
45 /* IRP has already been cancelled */
46
47 IoReleaseCancelSpinLock(OldIrql);
48
49 Irp->IoStatus.Status = STATUS_CANCELLED;
50 Irp->IoStatus.Information = 0;
51
52 TI_DbgPrint(DEBUG_IRP, ("Leaving (IRP was already cancelled).\n"));
53
54 return IRPFinish(Irp, STATUS_CANCELLED);
55 }
56
57
58 VOID DispCancelComplete(
59 PVOID Context)
60 /*
61 * FUNCTION: Completes a cancel request
62 * ARGUMENTS:
63 * Context = Pointer to context information (FILE_OBJECT)
64 */
65 {
66 /*KIRQL OldIrql;*/
67 PFILE_OBJECT FileObject;
68 PTRANSPORT_CONTEXT TranContext;
69
70 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
71
72 FileObject = (PFILE_OBJECT)Context;
73 TranContext = (PTRANSPORT_CONTEXT)FileObject->FsContext;
74
75 /* Set the cleanup event */
76 KeSetEvent(&TranContext->CleanupEvent, 0, FALSE);
77
78 /* We are expected to release the cancel spin lock */
79 /*IoReleaseCancelSpinLock(OldIrql);*/
80
81 TI_DbgPrint(DEBUG_IRP, ("Leaving.\n"));
82 }
83
84
85 VOID DispDataRequestComplete(
86 PVOID Context,
87 NTSTATUS Status,
88 ULONG Count)
89 /*
90 * FUNCTION: Completes a send/receive IRP
91 * ARGUMENTS:
92 * Context = Pointer to context information (IRP)
93 * Status = Status of the request
94 * Count = Number of bytes sent or received
95 */
96 {
97 PIRP Irp;
98 PIO_STACK_LOCATION IrpSp;
99 PTRANSPORT_CONTEXT TranContext;
100 KIRQL OldIrql;
101
102 TI_DbgPrint(DEBUG_IRP, ("Called for irp %x (%x, %d).\n",
103 Context, Status, Count));
104
105 Irp = Context;
106 IrpSp = IoGetCurrentIrpStackLocation(Irp);
107 TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
108
109 IoAcquireCancelSpinLock(&OldIrql);
110
111 IoSetCancelRoutine(Irp, NULL);
112
113 if (Irp->Cancel || TranContext->CancelIrps) {
114 /* The IRP has been cancelled */
115
116 TI_DbgPrint(DEBUG_IRP, ("IRP is cancelled.\n"));
117
118 Status = STATUS_CANCELLED;
119 Count = 0;
120 }
121
122 IoReleaseCancelSpinLock(OldIrql);
123
124 Irp->IoStatus.Status = Status;
125 Irp->IoStatus.Information = Count;
126
127 TI_DbgPrint(MID_TRACE, ("Irp->IoStatus.Status = %x\n",
128 Irp->IoStatus.Status));
129 TI_DbgPrint(MID_TRACE, ("Irp->IoStatus.Information = %d\n",
130 Irp->IoStatus.Information));
131 TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
132
133 IRPFinish(Irp, Irp->IoStatus.Status);
134
135 TI_DbgPrint(DEBUG_IRP, ("Done Completing IRP\n"));
136 }
137
138 typedef struct _DISCONNECT_TYPE {
139 UINT Type;
140 PVOID Context;
141 PIRP Irp;
142 PFILE_OBJECT FileObject;
143 } DISCONNECT_TYPE, *PDISCONNECT_TYPE;
144
145 VOID DispDoDisconnect( PVOID Data ) {
146 PDISCONNECT_TYPE DisType = (PDISCONNECT_TYPE)Data;
147
148 TI_DbgPrint(DEBUG_IRP, ("PostCancel: DoDisconnect\n"));
149 TCPDisconnect
150 ( DisType->Context,
151 DisType->Type,
152 NULL,
153 NULL,
154 DispDataRequestComplete,
155 DisType->Irp );
156 TI_DbgPrint(DEBUG_IRP, ("PostCancel: DoDisconnect done\n"));
157
158 DispDataRequestComplete(DisType->Irp, STATUS_CANCELLED, 0);
159
160 DispCancelComplete(DisType->FileObject);
161 }
162
163 VOID NTAPI DispCancelRequest(
164 PDEVICE_OBJECT Device,
165 PIRP Irp)
166 /*
167 * FUNCTION: Cancels an IRP
168 * ARGUMENTS:
169 * Device = Pointer to device object
170 * Irp = Pointer to an I/O request packet
171 */
172 {
173 PIO_STACK_LOCATION IrpSp;
174 PTRANSPORT_CONTEXT TranContext;
175 PFILE_OBJECT FileObject;
176 UCHAR MinorFunction;
177 DISCONNECT_TYPE DisType;
178 PVOID WorkItem;
179 /*NTSTATUS Status = STATUS_SUCCESS;*/
180
181 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
182
183 IrpSp = IoGetCurrentIrpStackLocation(Irp);
184 FileObject = IrpSp->FileObject;
185 TranContext = (PTRANSPORT_CONTEXT)FileObject->FsContext;
186 MinorFunction = IrpSp->MinorFunction;
187
188 TI_DbgPrint(DEBUG_IRP, ("IRP at (0x%X) MinorFunction (0x%X) IrpSp (0x%X).\n", Irp, MinorFunction, IrpSp));
189
190 Irp->IoStatus.Status = STATUS_PENDING;
191
192 #ifdef DBG
193 if (!Irp->Cancel)
194 TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
195 #endif
196
197 /* Try canceling the request */
198 switch(MinorFunction) {
199 case TDI_SEND:
200 case TDI_RECEIVE:
201 DisType.Type = TDI_DISCONNECT_RELEASE |
202 ((MinorFunction == TDI_RECEIVE) ? TDI_DISCONNECT_ABORT : 0);
203 DisType.Context = TranContext->Handle.ConnectionContext;
204 DisType.Irp = Irp;
205 DisType.FileObject = FileObject;
206
207 TCPRemoveIRP( TranContext->Handle.ConnectionContext, Irp );
208
209 if( !ChewCreate( &WorkItem, sizeof(DISCONNECT_TYPE),
210 DispDoDisconnect, &DisType ) )
211 ASSERT(0);
212 break;
213
214 case TDI_SEND_DATAGRAM:
215 Irp->IoStatus.Status = STATUS_CANCELLED;
216 if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
217 TI_DbgPrint(MIN_TRACE, ("TDI_SEND_DATAGRAM, but no address file.\n"));
218 break;
219 }
220
221 /*DGCancelSendRequest(TranContext->Handle.AddressHandle, Irp);*/
222 break;
223
224 case TDI_RECEIVE_DATAGRAM:
225 Irp->IoStatus.Status = STATUS_CANCELLED;
226 if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
227 TI_DbgPrint(MIN_TRACE, ("TDI_RECEIVE_DATAGRAM, but no address file.\n"));
228 break;
229 }
230
231 /*DGCancelReceiveRequest(TranContext->Handle.AddressHandle, Irp);*/
232 break;
233
234 default:
235 TI_DbgPrint(MIN_TRACE, ("Unknown IRP. MinorFunction (0x%X).\n", MinorFunction));
236 break;
237 }
238
239 if( Irp->IoStatus.Status == STATUS_PENDING )
240 IoMarkIrpPending(Irp);
241
242 IoReleaseCancelSpinLock(Irp->CancelIrql);
243
244 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
245 }
246
247
248 VOID NTAPI DispCancelListenRequest(
249 PDEVICE_OBJECT Device,
250 PIRP Irp)
251 /*
252 * FUNCTION: Cancels a listen IRP
253 * ARGUMENTS:
254 * Device = Pointer to device object
255 * Irp = Pointer to an I/O request packet
256 */
257 {
258 PIO_STACK_LOCATION IrpSp;
259 PTRANSPORT_CONTEXT TranContext;
260 PFILE_OBJECT FileObject;
261 PCONNECTION_ENDPOINT Connection;
262 /*NTSTATUS Status = STATUS_SUCCESS;*/
263
264 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
265
266 IrpSp = IoGetCurrentIrpStackLocation(Irp);
267 FileObject = IrpSp->FileObject;
268 TranContext = (PTRANSPORT_CONTEXT)FileObject->FsContext;
269 ASSERT( TDI_LISTEN == IrpSp->MinorFunction);
270
271 TI_DbgPrint(DEBUG_IRP, ("IRP at (0x%X).\n", Irp));
272
273 #ifdef DBG
274 if (!Irp->Cancel)
275 TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
276 #endif
277
278 /* Try canceling the request */
279 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
280 TCPAbortListenForSocket(
281 Connection->AddressFile->Listener,
282 Connection );
283
284 IoReleaseCancelSpinLock(Irp->CancelIrql);
285
286 DispDataRequestComplete(Irp, STATUS_CANCELLED, 0);
287
288 DispCancelComplete(FileObject);
289
290 TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
291 }
292
293
294 NTSTATUS DispTdiAccept(
295 PIRP Irp)
296 /*
297 * FUNCTION: TDI_ACCEPT handler
298 * ARGUMENTS:
299 * Irp = Pointer to an I/O request packet
300 * RETURNS:
301 * Status of operation
302 */
303 {
304 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
305
306 return STATUS_NOT_IMPLEMENTED;
307 }
308
309
310 NTSTATUS DispTdiAssociateAddress(
311 PIRP Irp)
312 /*
313 * FUNCTION: TDI_ASSOCIATE_ADDRESS handler
314 * ARGUMENTS:
315 * Irp = Pointer to an I/O request packet
316 * RETURNS:
317 * Status of operation
318 */
319 {
320 PTDI_REQUEST_KERNEL_ASSOCIATE Parameters;
321 PTRANSPORT_CONTEXT TranContext;
322 PIO_STACK_LOCATION IrpSp;
323 PCONNECTION_ENDPOINT Connection;
324 PFILE_OBJECT FileObject;
325 PADDRESS_FILE AddrFile = NULL;
326 NTSTATUS Status;
327
328 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
329
330 IrpSp = IoGetCurrentIrpStackLocation(Irp);
331
332 /* Get associated connection endpoint file object. Quit if none exists */
333
334 TranContext = IrpSp->FileObject->FsContext;
335 if (!TranContext) {
336 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
337 return STATUS_INVALID_PARAMETER;
338 }
339
340 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
341 if (!Connection) {
342 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
343 return STATUS_INVALID_PARAMETER;
344 }
345
346 if (Connection->AddressFile) {
347 TI_DbgPrint(MID_TRACE, ("An address file is already asscociated.\n"));
348 return STATUS_INVALID_PARAMETER;
349 }
350
351 Parameters = (PTDI_REQUEST_KERNEL_ASSOCIATE)&IrpSp->Parameters;
352
353 Status = ObReferenceObjectByHandle(
354 Parameters->AddressHandle,
355 0,
356 IoFileObjectType,
357 KernelMode,
358 (PVOID*)&FileObject,
359 NULL);
360 if (!NT_SUCCESS(Status)) {
361 TI_DbgPrint(MID_TRACE, ("Bad address file object handle (0x%X): %x.\n",
362 Parameters->AddressHandle, Status));
363 return STATUS_INVALID_PARAMETER;
364 }
365
366 if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
367 ObDereferenceObject(FileObject);
368 TI_DbgPrint(MID_TRACE, ("Bad address file object. Magic (0x%X).\n",
369 FileObject->FsContext2));
370 return STATUS_INVALID_PARAMETER;
371 }
372
373 /* Get associated address file object. Quit if none exists */
374
375 TranContext = FileObject->FsContext;
376 if (!TranContext) {
377 ObDereferenceObject(FileObject);
378 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
379 return STATUS_INVALID_PARAMETER;
380 }
381
382 AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
383 if (!AddrFile) {
384 ObDereferenceObject(FileObject);
385 TI_DbgPrint(MID_TRACE, ("No address file object.\n"));
386 return STATUS_INVALID_PARAMETER;
387 }
388
389 Connection->AddressFile = AddrFile;
390
391 /* Add connection endpoint to the address file */
392 AddrFile->Connection = Connection;
393
394 /* FIXME: Maybe do this in DispTdiDisassociateAddress() instead? */
395 ObDereferenceObject(FileObject);
396
397 return Status;
398 }
399
400
401 NTSTATUS DispTdiConnect(
402 PIRP Irp)
403 /*
404 * FUNCTION: TDI_CONNECT handler
405 * ARGUMENTS:
406 * Irp = Pointer to an I/O request packet
407 * RETURNS:
408 * Status of operation
409 */
410 {
411 PCONNECTION_ENDPOINT Connection;
412 PTDI_REQUEST_KERNEL Parameters;
413 PTRANSPORT_CONTEXT TranContext;
414 PIO_STACK_LOCATION IrpSp;
415 NTSTATUS Status;
416
417 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
418
419 IrpSp = IoGetCurrentIrpStackLocation(Irp);
420
421 /* Get associated connection endpoint file object. Quit if none exists */
422
423 TranContext = IrpSp->FileObject->FsContext;
424 if (!TranContext) {
425 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
426 return STATUS_INVALID_CONNECTION;
427 }
428
429 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
430 if (!Connection) {
431 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
432 return STATUS_INVALID_CONNECTION;
433 }
434
435 Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
436
437 Status = TCPConnect(
438 TranContext->Handle.ConnectionContext,
439 Parameters->RequestConnectionInformation,
440 Parameters->ReturnConnectionInformation,
441 DispDataRequestComplete,
442 Irp );
443
444 TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
445
446 return Status;
447 }
448
449
450 NTSTATUS DispTdiDisassociateAddress(
451 PIRP Irp)
452 /*
453 * FUNCTION: TDI_DISASSOCIATE_ADDRESS handler
454 * ARGUMENTS:
455 * Irp = Pointer to an I/O request packet
456 * RETURNS:
457 * Status of operation
458 */
459 {
460 PCONNECTION_ENDPOINT Connection;
461 PTRANSPORT_CONTEXT TranContext;
462 PIO_STACK_LOCATION IrpSp;
463
464 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
465
466 IrpSp = IoGetCurrentIrpStackLocation(Irp);
467
468 /* Get associated connection endpoint file object. Quit if none exists */
469
470 TranContext = IrpSp->FileObject->FsContext;
471 if (!TranContext) {
472 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
473 return STATUS_INVALID_PARAMETER;
474 }
475
476 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
477 if (!Connection) {
478 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
479 return STATUS_INVALID_PARAMETER;
480 }
481
482 if (!Connection->AddressFile) {
483 TI_DbgPrint(MID_TRACE, ("No address file is asscociated.\n"));
484 return STATUS_INVALID_PARAMETER;
485 }
486
487 return STATUS_SUCCESS;
488 }
489
490
491 NTSTATUS DispTdiDisconnect(
492 PIRP Irp)
493 /*
494 * FUNCTION: TDI_DISCONNECT handler
495 * ARGUMENTS:
496 * Irp = Pointer to an I/O request packet
497 * RETURNS:
498 * Status of operation
499 */
500 {
501 NTSTATUS Status;
502 PTDI_REQUEST_KERNEL_DISCONNECT DisReq;
503 PCONNECTION_ENDPOINT Connection;
504 PTRANSPORT_CONTEXT TranContext;
505 PIO_STACK_LOCATION IrpSp;
506
507 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
508
509 IrpSp = IoGetCurrentIrpStackLocation(Irp);
510 DisReq = (PTDI_REQUEST_KERNEL_DISCONNECT)&IrpSp->Parameters;
511
512 /* Get associated connection endpoint file object. Quit if none exists */
513
514 TranContext = IrpSp->FileObject->FsContext;
515 if (!TranContext) {
516 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
517 return STATUS_INVALID_CONNECTION;
518 }
519
520 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
521 if (!Connection) {
522 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
523 return STATUS_INVALID_CONNECTION;
524 }
525
526 Status = TCPDisconnect(
527 TranContext->Handle.ConnectionContext,
528 DisReq->RequestFlags,
529 DisReq->RequestConnectionInformation,
530 DisReq->ReturnConnectionInformation,
531 DispDataRequestComplete,
532 Irp );
533
534 TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
535
536 return Status;
537 }
538
539
540 NTSTATUS DispTdiListen(
541 PIRP Irp)
542 /*
543 * FUNCTION: TDI_LISTEN handler
544 * ARGUMENTS:
545 * Irp = Pointer to an I/O request packet
546 * RETURNS:
547 * Status of operation
548 */
549 {
550 PCONNECTION_ENDPOINT Connection;
551 PTDI_REQUEST_KERNEL Parameters;
552 PTRANSPORT_CONTEXT TranContext;
553 PIO_STACK_LOCATION IrpSp;
554 NTSTATUS Status = STATUS_SUCCESS;
555
556 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
557
558 IrpSp = IoGetCurrentIrpStackLocation(Irp);
559
560 /* Get associated connection endpoint file object. Quit if none exists */
561
562 TranContext = IrpSp->FileObject->FsContext;
563 if (TranContext == NULL)
564 {
565 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
566 return STATUS_INVALID_CONNECTION;
567 }
568
569 Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
570 if (Connection == NULL)
571 {
572 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
573 return STATUS_INVALID_CONNECTION;
574 }
575
576 Parameters = (PTDI_REQUEST_KERNEL)&IrpSp->Parameters;
577
578 TI_DbgPrint(MIN_TRACE, ("Connection->AddressFile: %x\n",
579 Connection->AddressFile ));
580 if( Connection->AddressFile ) {
581 TI_DbgPrint(MIN_TRACE, ("Connection->AddressFile->Listener: %x\n",
582 Connection->AddressFile->Listener));
583 }
584
585 /* Listening will require us to create a listening socket and store it in
586 * the address file. It will be signalled, and attempt to complete an irp
587 * when a new connection arrives. */
588 /* The important thing to note here is that the irp we'll complete belongs
589 * to the socket to be accepted onto, not the listener */
590 if( !Connection->AddressFile->Listener ) {
591 Connection->AddressFile->Listener =
592 TCPAllocateConnectionEndpoint( NULL );
593
594 if( !Connection->AddressFile->Listener )
595 Status = STATUS_NO_MEMORY;
596
597 if( NT_SUCCESS(Status) ) {
598 Connection->AddressFile->Listener->AddressFile =
599 Connection->AddressFile;
600
601 Status = TCPSocket( Connection->AddressFile->Listener,
602 Connection->AddressFile->Family,
603 SOCK_STREAM,
604 Connection->AddressFile->Protocol );
605 }
606
607 if( NT_SUCCESS(Status) )
608 Status = TCPListen( Connection->AddressFile->Listener, 1024 );
609 /* BACKLOG */
610 }
611 if( NT_SUCCESS(Status) ) {
612 Status = DispPrepareIrpForCancel
613 (TranContext->Handle.ConnectionContext,
614 Irp,
615 (PDRIVER_CANCEL)DispCancelListenRequest);
616 }
617
618 if( NT_SUCCESS(Status) ) {
619 Status = TCPAccept
620 ( (PTDI_REQUEST)Parameters,
621 Connection->AddressFile->Listener,
622 Connection,
623 DispDataRequestComplete,
624 Irp );
625 }
626
627 TI_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
628
629 return Status;
630 }
631
632
633 NTSTATUS DispTdiQueryInformation(
634 PDEVICE_OBJECT DeviceObject,
635 PIRP Irp)
636 /*
637 * FUNCTION: TDI_QUERY_INFORMATION handler
638 * ARGUMENTS:
639 * DeviceObject = Pointer to device object structure
640 * Irp = Pointer to an I/O request packet
641 * RETURNS:
642 * Status of operation
643 */
644 {
645 PTDI_REQUEST_KERNEL_QUERY_INFORMATION Parameters;
646 PTRANSPORT_CONTEXT TranContext;
647 PIO_STACK_LOCATION IrpSp;
648
649 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
650
651 IrpSp = IoGetCurrentIrpStackLocation(Irp);
652 Parameters = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION)&IrpSp->Parameters;
653
654 TranContext = IrpSp->FileObject->FsContext;
655 if (!TranContext) {
656 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
657 return STATUS_INVALID_CONNECTION;
658 }
659
660 switch (Parameters->QueryType)
661 {
662 case TDI_QUERY_ADDRESS_INFO:
663 {
664 PTDI_ADDRESS_INFO AddressInfo;
665 PADDRESS_FILE AddrFile;
666 PTA_IP_ADDRESS Address;
667
668 AddressInfo = (PTDI_ADDRESS_INFO)MmGetSystemAddressForMdl(Irp->MdlAddress);
669
670 switch ((ULONG)IrpSp->FileObject->FsContext2) {
671 case TDI_TRANSPORT_ADDRESS_FILE:
672 AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
673 break;
674
675 case TDI_CONNECTION_FILE:
676 AddrFile =
677 ((PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext)->
678 AddressFile;
679 break;
680
681 default:
682 TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
683 return STATUS_INVALID_PARAMETER;
684 }
685
686 if (!AddrFile) {
687 TI_DbgPrint(MID_TRACE, ("No address file object.\n"));
688 return STATUS_INVALID_PARAMETER;
689 }
690
691 if (MmGetMdlByteCount(Irp->MdlAddress) <
692 (FIELD_OFFSET(TDI_ADDRESS_INFO, Address.Address[0].Address) +
693 sizeof(TDI_ADDRESS_IP))) {
694 TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n"));
695 return STATUS_BUFFER_OVERFLOW;
696 }
697
698 Address = (PTA_IP_ADDRESS)&AddressInfo->Address;
699 Address->TAAddressCount = 1;
700 Address->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
701 Address->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
702 Address->Address[0].Address[0].sin_port = AddrFile->Port;
703 Address->Address[0].Address[0].in_addr =
704 AddrFile->Address.Address.IPv4Address;
705 RtlZeroMemory(
706 &Address->Address[0].Address[0].sin_zero,
707 sizeof(Address->Address[0].Address[0].sin_zero));
708
709 return STATUS_SUCCESS;
710 }
711
712 case TDI_QUERY_CONNECTION_INFO:
713 {
714 PTDI_CONNECTION_INFORMATION AddressInfo;
715 PADDRESS_FILE AddrFile;
716 PCONNECTION_ENDPOINT Endpoint = NULL;
717
718 AddressInfo = (PTDI_CONNECTION_INFORMATION)
719 MmGetSystemAddressForMdl(Irp->MdlAddress);
720
721 switch ((ULONG)IrpSp->FileObject->FsContext2) {
722 case TDI_TRANSPORT_ADDRESS_FILE:
723 AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
724 break;
725
726 case TDI_CONNECTION_FILE:
727 Endpoint =
728 (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
729 break;
730
731 default:
732 TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
733 return STATUS_INVALID_PARAMETER;
734 }
735
736 if (!Endpoint) {
737 TI_DbgPrint(MID_TRACE, ("No connection object.\n"));
738 return STATUS_INVALID_PARAMETER;
739 }
740
741 if (MmGetMdlByteCount(Irp->MdlAddress) <
742 (FIELD_OFFSET(TDI_CONNECTION_INFORMATION, RemoteAddress) +
743 sizeof(PVOID))) {
744 TI_DbgPrint(MID_TRACE, ("MDL buffer too small (ptr).\n"));
745 return STATUS_BUFFER_OVERFLOW;
746 }
747
748 return TCPGetPeerAddress( Endpoint, AddressInfo->RemoteAddress );
749 }
750 }
751
752 return STATUS_NOT_IMPLEMENTED;
753 }
754
755
756 NTSTATUS DispTdiReceive(
757 PIRP Irp)
758 /*
759 * FUNCTION: TDI_RECEIVE handler
760 * ARGUMENTS:
761 * Irp = Pointer to an I/O request packet
762 * RETURNS:
763 * Status of operation
764 */
765 {
766 PIO_STACK_LOCATION IrpSp;
767 PTDI_REQUEST_KERNEL_RECEIVE ReceiveInfo;
768 PTRANSPORT_CONTEXT TranContext;
769 NTSTATUS Status;
770 ULONG BytesReceived;
771
772 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
773
774 IrpSp = IoGetCurrentIrpStackLocation(Irp);
775 ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters);
776
777 TranContext = IrpSp->FileObject->FsContext;
778 if (TranContext == NULL)
779 {
780 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
781 return STATUS_INVALID_CONNECTION;
782 }
783
784 if (TranContext->Handle.ConnectionContext == NULL)
785 {
786 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
787 return STATUS_INVALID_CONNECTION;
788 }
789
790 /* Initialize a receive request */
791 Status = DispPrepareIrpForCancel
792 (TranContext->Handle.ConnectionContext,
793 Irp,
794 (PDRIVER_CANCEL)DispCancelRequest);
795
796 TI_DbgPrint(MID_TRACE,("TCPIP<<< Got an MDL: %x\n", Irp->MdlAddress));
797 if (NT_SUCCESS(Status))
798 {
799 Status = TCPReceiveData(
800 TranContext->Handle.ConnectionContext,
801 (PNDIS_BUFFER)Irp->MdlAddress,
802 ReceiveInfo->ReceiveLength,
803 &BytesReceived,
804 ReceiveInfo->ReceiveFlags,
805 DispDataRequestComplete,
806 Irp);
807 if (Status != STATUS_PENDING)
808 {
809 DispDataRequestComplete(Irp, Status, BytesReceived);
810 } else
811 IoMarkIrpPending(Irp);
812 }
813
814 TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
815
816 return Status;
817 }
818
819
820 NTSTATUS DispTdiReceiveDatagram(
821 PIRP Irp)
822 /*
823 * FUNCTION: TDI_RECEIVE_DATAGRAM handler
824 * ARGUMENTS:
825 * Irp = Pointer to an I/O request packet
826 * RETURNS:
827 * Status of operation
828 */
829 {
830 PIO_STACK_LOCATION IrpSp;
831 PTDI_REQUEST_KERNEL_RECEIVEDG DgramInfo;
832 PTRANSPORT_CONTEXT TranContext;
833 TDI_REQUEST Request;
834 NTSTATUS Status;
835 ULONG BytesReceived;
836
837 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
838
839 IrpSp = IoGetCurrentIrpStackLocation(Irp);
840 DgramInfo = (PTDI_REQUEST_KERNEL_RECEIVEDG)&(IrpSp->Parameters);
841
842 TranContext = IrpSp->FileObject->FsContext;
843 if (TranContext == NULL)
844 {
845 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
846 return STATUS_INVALID_ADDRESS;
847 }
848
849 /* Initialize a receive request */
850 Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
851 Request.RequestNotifyObject = DispDataRequestComplete;
852 Request.RequestContext = Irp;
853
854 Status = DispPrepareIrpForCancel(
855 IrpSp->FileObject->FsContext,
856 Irp,
857 (PDRIVER_CANCEL)DispCancelRequest);
858
859 if (NT_SUCCESS(Status))
860 {
861 PCHAR DataBuffer;
862 UINT BufferSize;
863
864 NdisQueryBuffer( (PNDIS_BUFFER)Irp->MdlAddress,
865 &DataBuffer,
866 &BufferSize );
867
868 Status = UDPReceiveDatagram(
869 Request.Handle.AddressHandle,
870 DgramInfo->ReceiveDatagramInformation,
871 DataBuffer,
872 DgramInfo->ReceiveLength,
873 DgramInfo->ReceiveFlags,
874 DgramInfo->ReturnDatagramInformation,
875 &BytesReceived,
876 (PDATAGRAM_COMPLETION_ROUTINE)DispDataRequestComplete,
877 Irp);
878 if (Status != STATUS_PENDING) {
879 DispDataRequestComplete(Irp, Status, BytesReceived);
880 } else
881 IoMarkIrpPending(Irp);
882 }
883
884 TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
885
886 return Status;
887 }
888
889
890 NTSTATUS DispTdiSend(
891 PIRP Irp)
892 /*
893 * FUNCTION: TDI_SEND handler
894 * ARGUMENTS:
895 * Irp = Pointer to an I/O request packet
896 * RETURNS:
897 * Status of operation
898 */
899 {
900 PIO_STACK_LOCATION IrpSp;
901 PTDI_REQUEST_KERNEL_SEND SendInfo;
902 PTRANSPORT_CONTEXT TranContext;
903 NTSTATUS Status;
904 ULONG BytesSent;
905
906 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
907
908 IrpSp = IoGetCurrentIrpStackLocation(Irp);
909 SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters);
910
911 TranContext = IrpSp->FileObject->FsContext;
912 if (TranContext == NULL)
913 {
914 TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
915 return STATUS_INVALID_CONNECTION;
916 }
917
918 if (TranContext->Handle.ConnectionContext == NULL)
919 {
920 TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
921 return STATUS_INVALID_CONNECTION;
922 }
923
924 Status = DispPrepareIrpForCancel(
925 IrpSp->FileObject->FsContext,
926 Irp,
927 (PDRIVER_CANCEL)DispCancelRequest);
928
929 TI_DbgPrint(MID_TRACE,("TCPIP<<< Got an MDL: %x\n", Irp->MdlAddress));
930 if (NT_SUCCESS(Status))
931 {
932 PCHAR Data;
933 UINT Len;
934
935 NdisQueryBuffer( Irp->MdlAddress, &Data, &Len );
936
937 TI_DbgPrint(MID_TRACE,("About to TCPSendData\n"));
938 Status = TCPSendData(
939 TranContext->Handle.ConnectionContext,
940 Data,
941 SendInfo->SendLength,
942 &BytesSent,
943 SendInfo->SendFlags,
944 DispDataRequestComplete,
945 Irp);
946 if (Status != STATUS_PENDING)
947 {
948 DispDataRequestComplete(Irp, Status, BytesSent);
949 } else
950 IoMarkIrpPending( Irp );
951 }
952
953 TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
954
955 return Status;
956 }
957
958
959 NTSTATUS DispTdiSendDatagram(
960 PIRP Irp)
961 /*
962 * FUNCTION: TDI_SEND_DATAGRAM handler
963 * ARGUMENTS:
964 * Irp = Pointer to an I/O request packet
965 * RETURNS:
966 * Status of operation
967 */
968 {
969 PIO_STACK_LOCATION IrpSp;
970 TDI_REQUEST Request;
971 PTDI_REQUEST_KERNEL_SENDDG DgramInfo;
972 PTRANSPORT_CONTEXT TranContext;
973 NTSTATUS Status;
974
975 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
976
977 IrpSp = IoGetCurrentIrpStackLocation(Irp);
978 DgramInfo = (PTDI_REQUEST_KERNEL_SENDDG)&(IrpSp->Parameters);
979 TranContext = IrpSp->FileObject->FsContext;
980
981 /* Initialize a send request */
982 Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
983 Request.RequestNotifyObject = DispDataRequestComplete;
984 Request.RequestContext = Irp;
985
986 Status = DispPrepareIrpForCancel(
987 IrpSp->FileObject->FsContext,
988 Irp,
989 (PDRIVER_CANCEL)DispCancelRequest);
990
991 if (NT_SUCCESS(Status)) {
992 PCHAR DataBuffer;
993 UINT BufferSize;
994
995 TI_DbgPrint(MID_TRACE,("About to query buffer %x\n", Irp->MdlAddress));
996
997 NdisQueryBuffer( (PNDIS_BUFFER)Irp->MdlAddress,
998 &DataBuffer,
999 &BufferSize );
1000
1001 /* FIXME: DgramInfo->SendDatagramInformation->RemoteAddress
1002 must be of type PTDI_ADDRESS_IP */
1003 TI_DbgPrint(MID_TRACE,
1004 ("About to call send routine %x\n",
1005 (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)));
1006
1007 if( (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send) )
1008 Status = (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)(
1009 Request.Handle.AddressHandle,
1010 DgramInfo->SendDatagramInformation,
1011 DataBuffer,
1012 BufferSize,
1013 &Irp->IoStatus.Information);
1014 else
1015 Status = STATUS_UNSUCCESSFUL;
1016
1017 if (Status != STATUS_PENDING) {
1018 DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information);
1019 /* Return STATUS_PENDING because DispPrepareIrpForCancel
1020 marks Irp as pending */
1021 Status = STATUS_PENDING;
1022 } else
1023 IoMarkIrpPending( Irp );
1024 }
1025
1026 TI_DbgPrint(DEBUG_IRP, ("Leaving.\n"));
1027
1028 return Status;
1029 }
1030
1031
1032 NTSTATUS DispTdiSetEventHandler(PIRP Irp)
1033 /*
1034 * FUNCTION: TDI_SET_EVENT_HANDER handler
1035 * ARGUMENTS:
1036 * Irp = Pointer to a I/O request packet
1037 * RETURNS:
1038 * Status of operation
1039 */
1040 {
1041 PTDI_REQUEST_KERNEL_SET_EVENT Parameters;
1042 PTRANSPORT_CONTEXT TranContext;
1043 PIO_STACK_LOCATION IrpSp;
1044 PADDRESS_FILE AddrFile;
1045 NTSTATUS Status;
1046 KIRQL OldIrql;
1047
1048 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1049
1050 IrpSp = IoGetCurrentIrpStackLocation(Irp);
1051
1052 /* Get associated address file object. Quit if none exists */
1053
1054 TranContext = IrpSp->FileObject->FsContext;
1055 if (!TranContext) {
1056 TI_DbgPrint(MIN_TRACE, ("Bad transport context.\n"));
1057 return STATUS_INVALID_PARAMETER;
1058 }
1059
1060 AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
1061 if (!AddrFile) {
1062 TI_DbgPrint(MIN_TRACE, ("No address file object.\n"));
1063 return STATUS_INVALID_PARAMETER;
1064 }
1065
1066 Parameters = (PTDI_REQUEST_KERNEL_SET_EVENT)&IrpSp->Parameters;
1067 Status = STATUS_SUCCESS;
1068
1069 TcpipAcquireSpinLock(&AddrFile->Lock, &OldIrql);
1070
1071 /* Set the event handler. if an event handler is associated with
1072 a specific event, it's flag (RegisteredXxxHandler) is TRUE.
1073 If an event handler is not used it's flag is FALSE */
1074 switch (Parameters->EventType) {
1075 case TDI_EVENT_CONNECT:
1076 if (!Parameters->EventHandler) {
1077 AddrFile->ConnectHandlerContext = NULL;
1078 AddrFile->RegisteredConnectHandler = FALSE;
1079 } else {
1080 AddrFile->ConnectHandler =
1081 (PTDI_IND_CONNECT)Parameters->EventHandler;
1082 AddrFile->ConnectHandlerContext = Parameters->EventContext;
1083 AddrFile->RegisteredConnectHandler = TRUE;
1084 }
1085 break;
1086
1087 case TDI_EVENT_DISCONNECT:
1088 if (!Parameters->EventHandler) {
1089 AddrFile->DisconnectHandlerContext = NULL;
1090 AddrFile->RegisteredDisconnectHandler = FALSE;
1091 } else {
1092 AddrFile->DisconnectHandler =
1093 (PTDI_IND_DISCONNECT)Parameters->EventHandler;
1094 AddrFile->DisconnectHandlerContext = Parameters->EventContext;
1095 AddrFile->RegisteredDisconnectHandler = TRUE;
1096 }
1097 break;
1098
1099 case TDI_EVENT_ERROR:
1100 if (Parameters->EventHandler == NULL) {
1101 AddrFile->ErrorHandlerContext = NULL;
1102 AddrFile->RegisteredErrorHandler = FALSE;
1103 } else {
1104 AddrFile->ErrorHandler =
1105 (PTDI_IND_ERROR)Parameters->EventHandler;
1106 AddrFile->ErrorHandlerContext = Parameters->EventContext;
1107 AddrFile->RegisteredErrorHandler = TRUE;
1108 }
1109 break;
1110
1111 case TDI_EVENT_RECEIVE:
1112 if (Parameters->EventHandler == NULL) {
1113 AddrFile->ReceiveHandlerContext = NULL;
1114 AddrFile->RegisteredReceiveHandler = FALSE;
1115 } else {
1116 AddrFile->ReceiveHandler =
1117 (PTDI_IND_RECEIVE)Parameters->EventHandler;
1118 AddrFile->ReceiveHandlerContext = Parameters->EventContext;
1119 AddrFile->RegisteredReceiveHandler = TRUE;
1120 }
1121 break;
1122
1123 case TDI_EVENT_RECEIVE_DATAGRAM:
1124 if (Parameters->EventHandler == NULL) {
1125 AddrFile->ReceiveDatagramHandlerContext = NULL;
1126 AddrFile->RegisteredReceiveDatagramHandler = FALSE;
1127 } else {
1128 AddrFile->ReceiveDatagramHandler =
1129 (PTDI_IND_RECEIVE_DATAGRAM)Parameters->EventHandler;
1130 AddrFile->ReceiveDatagramHandlerContext = Parameters->EventContext;
1131 AddrFile->RegisteredReceiveDatagramHandler = TRUE;
1132 }
1133 break;
1134
1135 case TDI_EVENT_RECEIVE_EXPEDITED:
1136 if (Parameters->EventHandler == NULL) {
1137 AddrFile->ExpeditedReceiveHandlerContext = NULL;
1138 AddrFile->RegisteredExpeditedReceiveHandler = FALSE;
1139 } else {
1140 AddrFile->ExpeditedReceiveHandler =
1141 (PTDI_IND_RECEIVE_EXPEDITED)Parameters->EventHandler;
1142 AddrFile->ExpeditedReceiveHandlerContext = Parameters->EventContext;
1143 AddrFile->RegisteredExpeditedReceiveHandler = TRUE;
1144 }
1145 break;
1146
1147 case TDI_EVENT_CHAINED_RECEIVE:
1148 if (Parameters->EventHandler == NULL) {
1149 AddrFile->ChainedReceiveHandlerContext = NULL;
1150 AddrFile->RegisteredChainedReceiveHandler = FALSE;
1151 } else {
1152 AddrFile->ChainedReceiveHandler =
1153 (PTDI_IND_CHAINED_RECEIVE)Parameters->EventHandler;
1154 AddrFile->ChainedReceiveHandlerContext = Parameters->EventContext;
1155 AddrFile->RegisteredChainedReceiveHandler = TRUE;
1156 }
1157 break;
1158
1159 case TDI_EVENT_CHAINED_RECEIVE_DATAGRAM:
1160 if (Parameters->EventHandler == NULL) {
1161 AddrFile->ChainedReceiveDatagramHandlerContext = NULL;
1162 AddrFile->RegisteredChainedReceiveDatagramHandler = FALSE;
1163 } else {
1164 AddrFile->ChainedReceiveDatagramHandler =
1165 (PTDI_IND_CHAINED_RECEIVE_DATAGRAM)Parameters->EventHandler;
1166 AddrFile->ChainedReceiveDatagramHandlerContext = Parameters->EventContext;
1167 AddrFile->RegisteredChainedReceiveDatagramHandler = TRUE;
1168 }
1169 break;
1170
1171 case TDI_EVENT_CHAINED_RECEIVE_EXPEDITED:
1172 if (Parameters->EventHandler == NULL) {
1173 AddrFile->ChainedReceiveExpeditedHandlerContext = NULL;
1174 AddrFile->RegisteredChainedReceiveExpeditedHandler = FALSE;
1175 } else {
1176 AddrFile->ChainedReceiveExpeditedHandler =
1177 (PTDI_IND_CHAINED_RECEIVE_EXPEDITED)Parameters->EventHandler;
1178 AddrFile->ChainedReceiveExpeditedHandlerContext = Parameters->EventContext;
1179 AddrFile->RegisteredChainedReceiveExpeditedHandler = TRUE;
1180 }
1181 break;
1182
1183 default:
1184 TI_DbgPrint(MIN_TRACE, ("Unknown event type (0x%X).\n",
1185 Parameters->EventType));
1186
1187 Status = STATUS_INVALID_PARAMETER;
1188 }
1189
1190 TcpipReleaseSpinLock(&AddrFile->Lock, OldIrql);
1191
1192 return Status;
1193 }
1194
1195
1196 NTSTATUS DispTdiSetInformation(
1197 PIRP Irp)
1198 /*
1199 * FUNCTION: TDI_SET_INFORMATION handler
1200 * ARGUMENTS:
1201 * Irp = Pointer to an I/O request packet
1202 * RETURNS:
1203 * Status of operation
1204 */
1205 {
1206 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1207
1208 return STATUS_NOT_IMPLEMENTED;
1209 }
1210
1211
1212 VOID DispTdiQueryInformationExComplete(
1213 PVOID Context,
1214 ULONG Status,
1215 UINT ByteCount)
1216 /*
1217 * FUNCTION: Completes a TDI QueryInformationEx request
1218 * ARGUMENTS:
1219 * Context = Pointer to the IRP for the request
1220 * Status = TDI status of the request
1221 * ByteCount = Number of bytes returned in output buffer
1222 */
1223 {
1224 PTI_QUERY_CONTEXT QueryContext;
1225 UINT Count = 0;
1226
1227 QueryContext = (PTI_QUERY_CONTEXT)Context;
1228 if (NT_SUCCESS(Status)) {
1229 Count = CopyBufferToBufferChain(
1230 QueryContext->InputMdl,
1231 FIELD_OFFSET(TCP_REQUEST_QUERY_INFORMATION_EX, Context),
1232 (PCHAR)&QueryContext->QueryInfo.Context,
1233 CONTEXT_SIZE);
1234 }
1235
1236 MmUnlockPages(QueryContext->InputMdl);
1237 IoFreeMdl(QueryContext->InputMdl);
1238 if( QueryContext->OutputMdl ) {
1239 MmUnlockPages(QueryContext->OutputMdl);
1240 IoFreeMdl(QueryContext->OutputMdl);
1241 }
1242
1243 QueryContext->Irp->IoStatus.Information = ByteCount;
1244 QueryContext->Irp->IoStatus.Status = Status;
1245
1246 ExFreePool(QueryContext);
1247 }
1248
1249
1250 NTSTATUS DispTdiQueryInformationEx(
1251 PIRP Irp,
1252 PIO_STACK_LOCATION IrpSp)
1253 /*
1254 * FUNCTION: TDI QueryInformationEx handler
1255 * ARGUMENTS:
1256 * Irp = Pointer to I/O request packet
1257 * IrpSp = Pointer to current stack location of Irp
1258 * RETURNS:
1259 * Status of operation
1260 */
1261 {
1262 PTCP_REQUEST_QUERY_INFORMATION_EX InputBuffer;
1263 PTRANSPORT_CONTEXT TranContext;
1264 PTI_QUERY_CONTEXT QueryContext;
1265 PVOID OutputBuffer;
1266 TDI_REQUEST Request;
1267 UINT Size;
1268 UINT InputBufferLength;
1269 UINT OutputBufferLength;
1270 BOOLEAN InputMdlLocked = FALSE;
1271 BOOLEAN OutputMdlLocked = FALSE;
1272 PMDL InputMdl = NULL;
1273 PMDL OutputMdl = NULL;
1274 NTSTATUS Status = STATUS_SUCCESS;
1275
1276 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1277
1278 TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
1279
1280 switch ((ULONG)IrpSp->FileObject->FsContext2) {
1281 case TDI_TRANSPORT_ADDRESS_FILE:
1282 Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
1283 break;
1284
1285 case TDI_CONNECTION_FILE:
1286 Request.Handle.ConnectionContext = TranContext->Handle.ConnectionContext;
1287 break;
1288
1289 case TDI_CONTROL_CHANNEL_FILE:
1290 Request.Handle.ControlChannel = TranContext->Handle.ControlChannel;
1291 break;
1292
1293 default:
1294 TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
1295 return STATUS_INVALID_PARAMETER;
1296 }
1297
1298 InputBufferLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
1299 OutputBufferLength = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
1300
1301 /* Validate parameters */
1302 if ((InputBufferLength == sizeof(TCP_REQUEST_QUERY_INFORMATION_EX)) &&
1303 (OutputBufferLength != 0)) {
1304
1305 InputBuffer = (PTCP_REQUEST_QUERY_INFORMATION_EX)
1306 IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
1307 OutputBuffer = Irp->UserBuffer;
1308
1309 QueryContext = ExAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
1310 if (QueryContext) {
1311 _SEH_TRY {
1312 InputMdl = IoAllocateMdl(InputBuffer,
1313 sizeof(TCP_REQUEST_QUERY_INFORMATION_EX),
1314 FALSE, TRUE, NULL);
1315
1316 OutputMdl = IoAllocateMdl(OutputBuffer,
1317 OutputBufferLength, FALSE, TRUE, NULL);
1318
1319 if (InputMdl && OutputMdl) {
1320
1321 MmProbeAndLockPages(InputMdl, Irp->RequestorMode,
1322 IoModifyAccess);
1323
1324 InputMdlLocked = TRUE;
1325
1326 MmProbeAndLockPages(OutputMdl, Irp->RequestorMode,
1327 IoWriteAccess);
1328
1329 OutputMdlLocked = TRUE;
1330
1331 RtlCopyMemory(&QueryContext->QueryInfo,
1332 InputBuffer, sizeof(TCP_REQUEST_QUERY_INFORMATION_EX));
1333 } else
1334 Status = STATUS_INSUFFICIENT_RESOURCES;
1335 } _SEH_HANDLE {
1336 Status = _SEH_GetExceptionCode();
1337 } _SEH_END;
1338
1339 if (NT_SUCCESS(Status)) {
1340 Size = MmGetMdlByteCount(OutputMdl);
1341
1342 QueryContext->Irp = Irp;
1343 QueryContext->InputMdl = InputMdl;
1344 QueryContext->OutputMdl = OutputMdl;
1345
1346 Request.RequestNotifyObject = DispTdiQueryInformationExComplete;
1347 Request.RequestContext = QueryContext;
1348 Status = InfoTdiQueryInformationEx(&Request,
1349 &QueryContext->QueryInfo.ID, OutputMdl,
1350 &Size, &QueryContext->QueryInfo.Context);
1351 DispTdiQueryInformationExComplete(QueryContext, Status, Size);
1352
1353 TI_DbgPrint(MAX_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1354
1355 return Status;
1356 }
1357
1358 /* An error occurred if we get here */
1359
1360 if (InputMdl) {
1361 if (InputMdlLocked)
1362 MmUnlockPages(InputMdl);
1363 IoFreeMdl(InputMdl);
1364 }
1365
1366 if (OutputMdl) {
1367 if (OutputMdlLocked)
1368 MmUnlockPages(OutputMdl);
1369 IoFreeMdl(OutputMdl);
1370 }
1371
1372 ExFreePool(QueryContext);
1373 } else
1374 Status = STATUS_INSUFFICIENT_RESOURCES;
1375 } else if( InputBufferLength ==
1376 sizeof(TCP_REQUEST_QUERY_INFORMATION_EX) ) {
1377 /* Handle the case where the user is probing the buffer for length */
1378 TI_DbgPrint(MAX_TRACE, ("InputBufferLength %d OutputBufferLength %d\n",
1379 InputBufferLength, OutputBufferLength));
1380 InputBuffer = (PTCP_REQUEST_QUERY_INFORMATION_EX)
1381 IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
1382
1383 Size = 0;
1384
1385 QueryContext = ExAllocatePool(NonPagedPool, sizeof(TI_QUERY_CONTEXT));
1386 if (!QueryContext) return STATUS_INSUFFICIENT_RESOURCES;
1387
1388 _SEH_TRY {
1389 InputMdl = IoAllocateMdl(InputBuffer,
1390 sizeof(TCP_REQUEST_QUERY_INFORMATION_EX),
1391 FALSE, TRUE, NULL);
1392
1393 MmProbeAndLockPages(InputMdl, Irp->RequestorMode,
1394 IoModifyAccess);
1395
1396 InputMdlLocked = TRUE;
1397 Status = STATUS_SUCCESS;
1398 } _SEH_HANDLE {
1399 TI_DbgPrint(MAX_TRACE, ("Failed to acquire client buffer\n"));
1400 Status = _SEH_GetExceptionCode();
1401 } _SEH_END;
1402
1403 if( !NT_SUCCESS(Status) || !InputMdl ) {
1404 if( InputMdl ) IoFreeMdl( InputMdl );
1405 ExFreePool(QueryContext);
1406 return Status;
1407 }
1408
1409 RtlCopyMemory(&QueryContext->QueryInfo,
1410 InputBuffer, sizeof(TCP_REQUEST_QUERY_INFORMATION_EX));
1411
1412 QueryContext->Irp = Irp;
1413 QueryContext->InputMdl = InputMdl;
1414 QueryContext->OutputMdl = NULL;
1415
1416 Request.RequestNotifyObject = DispTdiQueryInformationExComplete;
1417 Request.RequestContext = QueryContext;
1418 Status = InfoTdiQueryInformationEx(&Request,
1419 &QueryContext->QueryInfo.ID,
1420 NULL,
1421 &Size,
1422 &QueryContext->QueryInfo.Context);
1423 DispTdiQueryInformationExComplete(QueryContext, Status, Size);
1424 TI_DbgPrint(MAX_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1425 } else Status = STATUS_INVALID_PARAMETER;
1426
1427 TI_DbgPrint(MIN_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1428
1429 return Status;
1430 }
1431
1432
1433 NTSTATUS DispTdiSetInformationEx(
1434 PIRP Irp,
1435 PIO_STACK_LOCATION IrpSp)
1436 /*
1437 * FUNCTION: TDI SetInformationEx handler
1438 * ARGUMENTS:
1439 * Irp = Pointer to I/O request packet
1440 * IrpSp = Pointer to current stack location of Irp
1441 * RETURNS:
1442 * Status of operation
1443 */
1444 {
1445 PTRANSPORT_CONTEXT TranContext;
1446 PTCP_REQUEST_SET_INFORMATION_EX Info;
1447 TDI_REQUEST Request;
1448 TDI_STATUS Status;
1449 KIRQL OldIrql;
1450
1451 TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1452
1453 TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
1454 Info = (PTCP_REQUEST_SET_INFORMATION_EX)Irp->AssociatedIrp.SystemBuffer;
1455
1456 switch ((ULONG)IrpSp->FileObject->FsContext2) {
1457 case TDI_TRANSPORT_ADDRESS_FILE:
1458 Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
1459 break;
1460
1461 case TDI_CONNECTION_FILE:
1462 Request.Handle.ConnectionContext = TranContext->Handle.ConnectionContext;
1463 break;
1464
1465 case TDI_CONTROL_CHANNEL_FILE:
1466 Request.Handle.ControlChannel = TranContext->Handle.ControlChannel;
1467 break;
1468
1469 default:
1470 Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
1471 Irp->IoStatus.Information = 0;
1472
1473 TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
1474
1475 return IRPFinish(Irp, STATUS_INVALID_PARAMETER);
1476 }
1477
1478 Status = DispPrepareIrpForCancel(TranContext, Irp, NULL);
1479 if (NT_SUCCESS(Status)) {
1480 Request.RequestNotifyObject = DispDataRequestComplete;
1481 Request.RequestContext = Irp;
1482
1483 Status = InfoTdiSetInformationEx(&Request, &Info->ID,
1484 &Info->Buffer, Info->BufferSize);
1485
1486 if (Status != STATUS_PENDING) {
1487 IoAcquireCancelSpinLock(&OldIrql);
1488 IoSetCancelRoutine(Irp, NULL);
1489 IoReleaseCancelSpinLock(OldIrql);
1490 }
1491 }
1492
1493 return Status;
1494 }
1495
1496 /* TODO: Support multiple addresses per interface.
1497 * For now just set the nte context to the interface index.
1498 *
1499 * Later on, create an NTE context and NTE instance
1500 */
1501
1502 NTSTATUS DispTdiSetIPAddress( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
1503 NTSTATUS Status = STATUS_DEVICE_DOES_NOT_EXIST;
1504 PIP_SET_ADDRESS IpAddrChange =
1505 (PIP_SET_ADDRESS)Irp->AssociatedIrp.SystemBuffer;
1506 IF_LIST_ITER(IF);
1507
1508 ForEachInterface(IF) {
1509 if( IF->Unicast.Address.IPv4Address == IpAddrChange->Address ) {
1510 Status = STATUS_DUPLICATE_OBJECTID;
1511 break;
1512 }
1513 if( IF->Index == IpAddrChange->NteIndex ) {
1514 IPRemoveInterfaceRoute( IF );
1515
1516 IF->Unicast.Type = IP_ADDRESS_V4;
1517 IF->Unicast.Address.IPv4Address = IpAddrChange->Address;
1518 IF->Netmask.Type = IP_ADDRESS_V4;
1519 IF->Netmask.Address.IPv4Address = IpAddrChange->Netmask;
1520
1521 TI_DbgPrint(MID_TRACE,("New Unicast Address: %x\n",
1522 IF->Unicast.Address.IPv4Address));
1523 TI_DbgPrint(MID_TRACE,("New Netmask : %x\n",
1524 IF->Netmask.Address.IPv4Address));
1525
1526 IPAddInterfaceRoute( IF );
1527
1528 IpAddrChange->Address = IF->Index;
1529 Status = STATUS_SUCCESS;
1530 Irp->IoStatus.Information = IF->Index;
1531 break;
1532 }
1533 } EndFor(IF);
1534
1535 Irp->IoStatus.Status = Status;
1536 return Status;
1537 }
1538
1539 NTSTATUS DispTdiDeleteIPAddress( PIRP Irp, PIO_STACK_LOCATION IrpSp ) {
1540 NTSTATUS Status = STATUS_UNSUCCESSFUL;
1541 PUSHORT NteIndex = Irp->AssociatedIrp.SystemBuffer;
1542 IF_LIST_ITER(IF);
1543
1544 ForEachInterface(IF) {
1545 if( IF->Index == *NteIndex ) {
1546 IF->Unicast.Type = IP_ADDRESS_V4;
1547 IF->Unicast.Address.IPv4Address = 0;
1548 IF->Netmask.Type = IP_ADDRESS_V4;
1549 IF->Netmask.Address.IPv4Address = 0;
1550 Status = STATUS_SUCCESS;
1551 }
1552 } EndFor(IF);
1553
1554 Irp->IoStatus.Status = Status;
1555 return Status;
1556 }
1557
1558 /* EOF */