ReactOS  0.4.14-dev-98-gb0d4763
dispatch.c
Go to the documentation of this file.
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 
14 #include <datagram.h>
15 #include <pseh/pseh2.h>
16 
17 typedef struct _QUERY_HW_WORK_ITEM {
25 
27  KIRQL OldIrql;
28 
29  if (Status != STATUS_PENDING) {
30  Irp->IoStatus.Status = Status;
34 
36  }
37 
38  return Status;
39 }
40 
43  PIRP Irp,
45 /*
46  * FUNCTION: Prepare an IRP for cancellation
47  * ARGUMENTS:
48  * Context = Pointer to context information
49  * Irp = Pointer to an I/O request packet
50  * CancelRoutine = Routine to be called when I/O request is cancelled
51  * RETURNS:
52  * Status of operation
53  */
54 {
55  KIRQL OldIrql;
57  PTRANSPORT_CONTEXT TransContext;
58 
59  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
60 
62  TransContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
63 
65 
66  if (!Irp->Cancel && !TransContext->CancelIrps) {
69 
70  TI_DbgPrint(DEBUG_IRP, ("Leaving (IRP at 0x%X can now be cancelled).\n", Irp));
71 
72  return STATUS_SUCCESS;
73  }
74 
75  /* IRP has already been cancelled */
76 
78 
79  Irp->IoStatus.Status = STATUS_CANCELLED;
80  Irp->IoStatus.Information = 0;
81 
82  TI_DbgPrint(DEBUG_IRP, ("Leaving (IRP was already cancelled).\n"));
83 
84  return Irp->IoStatus.Status;
85 }
86 
88  PVOID Context,
90  ULONG Count)
91 /*
92  * FUNCTION: Completes a send/receive IRP
93  * ARGUMENTS:
94  * Context = Pointer to context information (IRP)
95  * Status = Status of the request
96  * Count = Number of bytes sent or received
97  */
98 {
99  PIRP Irp = Context;
100 
101  TI_DbgPrint(DEBUG_IRP, ("Called for irp %x (%x, %d).\n",
102  Irp, Status, Count));
103 
104  Irp->IoStatus.Status = Status;
105  Irp->IoStatus.Information = Count;
106 
107  TI_DbgPrint(MID_TRACE, ("Irp->IoStatus.Status = %x\n",
108  Irp->IoStatus.Status));
109  TI_DbgPrint(MID_TRACE, ("Irp->IoStatus.Information = %d\n",
110  Irp->IoStatus.Information));
111  TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
112 
113  IRPFinish(Irp, Status);
114 
115  TI_DbgPrint(DEBUG_IRP, ("Done Completing IRP\n"));
116 }
117 
120  PIRP Irp)
121 /*
122  * FUNCTION: Cancels an IRP
123  * ARGUMENTS:
124  * Device = Pointer to device object
125  * Irp = Pointer to an I/O request packet
126  */
127 {
129  PTRANSPORT_CONTEXT TranContext;
132  PCONNECTION_ENDPOINT Connection;
133  BOOLEAN DequeuedIrp = TRUE;
134 
135  IoReleaseCancelSpinLock(Irp->CancelIrql);
136 
137  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
138 
141  TranContext = (PTRANSPORT_CONTEXT)FileObject->FsContext;
143 
144  TI_DbgPrint(DEBUG_IRP, ("IRP at (0x%X) MinorFunction (0x%X) IrpSp (0x%X).\n", Irp, MinorFunction, IrpSp));
145 
146  Irp->IoStatus.Status = STATUS_CANCELLED;
147  Irp->IoStatus.Information = 0;
148 
149 #if DBG
150  if (!Irp->Cancel)
151  TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
152 #endif
153 
154  /* Try canceling the request */
155  switch(MinorFunction) {
156  case TDI_SEND:
157  case TDI_RECEIVE:
158  DequeuedIrp = TCPRemoveIRP( TranContext->Handle.ConnectionContext, Irp );
159  break;
160 
161  case TDI_SEND_DATAGRAM:
162  if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
163  TI_DbgPrint(MIN_TRACE, ("TDI_SEND_DATAGRAM, but no address file.\n"));
164  break;
165  }
166 
167  DequeuedIrp = DGRemoveIRP(TranContext->Handle.AddressHandle, Irp);
168  break;
169 
171  if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
172  TI_DbgPrint(MIN_TRACE, ("TDI_RECEIVE_DATAGRAM, but no address file.\n"));
173  break;
174  }
175 
176  DequeuedIrp = DGRemoveIRP(TranContext->Handle.AddressHandle, Irp);
177  break;
178 
179  case TDI_CONNECT:
180  DequeuedIrp = TCPRemoveIRP(TranContext->Handle.ConnectionContext, Irp);
181  break;
182 
183  case TDI_DISCONNECT:
184  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
185 
186  DequeuedIrp = TCPRemoveIRP(TranContext->Handle.ConnectionContext, Irp);
187  if (DequeuedIrp)
188  {
189  if (KeCancelTimer(&Connection->DisconnectTimer))
190  {
191  DereferenceObject(Connection);
192  }
193  }
194  break;
195 
196  default:
197  TI_DbgPrint(MIN_TRACE, ("Unknown IRP. MinorFunction (0x%X).\n", MinorFunction));
198  ASSERT(FALSE);
199  break;
200  }
201 
202  if (DequeuedIrp)
204 
205  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
206 }
207 
208 
211  PIRP Irp)
212 /*
213  * FUNCTION: Cancels a listen IRP
214  * ARGUMENTS:
215  * Device = Pointer to device object
216  * Irp = Pointer to an I/O request packet
217  */
218 {
220  PTRANSPORT_CONTEXT TranContext;
222  PCONNECTION_ENDPOINT Connection;
223 
224  IoReleaseCancelSpinLock(Irp->CancelIrql);
225 
226  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
227 
230  TranContext = (PTRANSPORT_CONTEXT)FileObject->FsContext;
232 
233  TI_DbgPrint(DEBUG_IRP, ("IRP at (0x%X).\n", Irp));
234 
235 #if DBG
236  if (!Irp->Cancel)
237  TI_DbgPrint(MIN_TRACE, ("Irp->Cancel is FALSE, should be TRUE.\n"));
238 #endif
239 
240  /* Try canceling the request */
241  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
242 
244  Connection))
245  {
246  Irp->IoStatus.Information = 0;
248  }
249 
250  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
251 }
252 
253 
255  PIRP Irp)
256 /*
257  * FUNCTION: TDI_ACCEPT handler
258  * ARGUMENTS:
259  * Irp = Pointer to an I/O request packet
260  * RETURNS:
261  * Status of operation
262  */
263 {
264  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
265 
266  return STATUS_NOT_IMPLEMENTED;
267 }
268 
269 
271  PIRP Irp)
272 /*
273  * FUNCTION: TDI_ASSOCIATE_ADDRESS handler
274  * ARGUMENTS:
275  * Irp = Pointer to an I/O request packet
276  * RETURNS:
277  * Status of operation
278  */
279 {
281  PTRANSPORT_CONTEXT TranContext;
283  PCONNECTION_ENDPOINT Connection, LastConnection;
285  PADDRESS_FILE AddrFile = NULL;
287  KIRQL OldIrql;
288 
289  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
290 
292 
293  /* Get associated connection endpoint file object. Quit if none exists */
294 
295  TranContext = IrpSp->FileObject->FsContext;
296  if (!TranContext) {
297  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
299  }
300 
301  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
302  if (!Connection) {
303  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
305  }
306 
308 
310  Parameters->AddressHandle,
311  0,
313  KernelMode,
314  (PVOID*)&FileObject,
315  NULL);
316  if (!NT_SUCCESS(Status)) {
317  TI_DbgPrint(MID_TRACE, ("Bad address file object handle (0x%X): %x.\n",
318  Parameters->AddressHandle, Status));
320  }
321 
322  LockObject(Connection, &OldIrql);
323 
324  if (Connection->AddressFile) {
326  UnlockObject(Connection, OldIrql);
327  TI_DbgPrint(MID_TRACE, ("An address file is already associated.\n"));
329  }
330 
331  if (FileObject->FsContext2 != (PVOID)TDI_TRANSPORT_ADDRESS_FILE) {
333  UnlockObject(Connection, OldIrql);
334  TI_DbgPrint(MID_TRACE, ("Bad address file object. Magic (0x%X).\n",
335  FileObject->FsContext2));
337  }
338 
339  /* Get associated address file object. Quit if none exists */
340 
341  TranContext = FileObject->FsContext;
342  if (!TranContext) {
344  UnlockObject(Connection, OldIrql);
345  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
347  }
348 
349  AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
350  if (!AddrFile) {
351  UnlockObject(Connection, OldIrql);
353  TI_DbgPrint(MID_TRACE, ("No address file object.\n"));
355  }
356 
357  LockObjectAtDpcLevel(AddrFile);
358 
359  ReferenceObject(AddrFile);
360  Connection->AddressFile = AddrFile;
361 
362  /* Add connection endpoint to the address file */
363  ReferenceObject(Connection);
364  if (AddrFile->Connection == NULL)
365  AddrFile->Connection = Connection;
366  else
367  {
368  LastConnection = AddrFile->Connection;
369  while (LastConnection->Next != NULL)
370  LastConnection = LastConnection->Next;
371  LastConnection->Next = Connection;
372  }
373 
375 
376  UnlockObjectFromDpcLevel(AddrFile);
377  UnlockObject(Connection, OldIrql);
378 
379  return STATUS_SUCCESS;
380 }
381 
382 
384  PIRP Irp)
385 /*
386  * FUNCTION: TDI_CONNECT handler
387  * ARGUMENTS:
388  * Irp = Pointer to an I/O request packet
389  * RETURNS:
390  * Status of operation
391  */
392 {
393  PCONNECTION_ENDPOINT Connection;
395  PTRANSPORT_CONTEXT TranContext;
398 
399  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
400 
402 
404 
405  /* Get associated connection endpoint file object. Quit if none exists */
406 
407  TranContext = IrpSp->FileObject->FsContext;
408  if (!TranContext) {
409  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
411  goto done;
412  }
413 
414  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
415  if (!Connection) {
416  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
418  goto done;
419  }
420 
422 
424  Irp,
426 
427  if (NT_SUCCESS(Status)) {
428  Status = TCPConnect(
429  TranContext->Handle.ConnectionContext,
430  Parameters->RequestConnectionInformation,
431  Parameters->ReturnConnectionInformation,
433  Irp );
434  }
435 
436 done:
437  if (Status != STATUS_PENDING) {
439  }
440 
441  TI_DbgPrint(MAX_TRACE, ("TCP Connect returned %08x\n", Status));
442 
443  return STATUS_PENDING;
444 }
445 
446 
448  PIRP Irp)
449 /*
450  * FUNCTION: TDI_DISASSOCIATE_ADDRESS handler
451  * ARGUMENTS:
452  * Irp = Pointer to an I/O request packet
453  * RETURNS:
454  * Status of operation
455  */
456 {
457  PCONNECTION_ENDPOINT Connection;
458  PTRANSPORT_CONTEXT TranContext;
460 
461  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
462 
464 
465  /* Get associated connection endpoint file object. Quit if none exists */
466 
467  TranContext = IrpSp->FileObject->FsContext;
468  if (!TranContext) {
469  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
471  }
472 
473  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
474  if (!Connection) {
475  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
477  }
478 
479  /* NO-OP because we need the address to deallocate the port when the connection closes */
480 
481  return STATUS_SUCCESS;
482 }
483 
484 
486  PIRP Irp)
487 /*
488  * FUNCTION: TDI_DISCONNECT handler
489  * ARGUMENTS:
490  * Irp = Pointer to an I/O request packet
491  * RETURNS:
492  * Status of operation
493  */
494 {
497  PCONNECTION_ENDPOINT Connection;
498  PTRANSPORT_CONTEXT TranContext;
500 
501  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
502 
505 
507 
508  /* Get associated connection endpoint file object. Quit if none exists */
509 
510  TranContext = IrpSp->FileObject->FsContext;
511  if (!TranContext) {
512  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
514  goto done;
515  }
516 
517  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
518  if (!Connection) {
519  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
521  goto done;
522  }
523 
525  (TranContext->Handle.ConnectionContext,
526  Irp,
528 
529  if (NT_SUCCESS(Status))
530  {
532  DisReq->RequestFlags,
533  DisReq->RequestSpecific,
537  Irp);
538  }
539 
540 done:
541  if (Status != STATUS_PENDING) {
543  }
544 
545  TI_DbgPrint(MAX_TRACE, ("TCP Disconnect returned %08x\n", Status));
546 
547  return STATUS_PENDING;
548 }
549 
550 
552  PIRP Irp)
553 /*
554  * FUNCTION: TDI_LISTEN handler
555  * ARGUMENTS:
556  * Irp = Pointer to an I/O request packet
557  * RETURNS:
558  * Status of operation
559  */
560 {
561  PCONNECTION_ENDPOINT Connection;
563  PTRANSPORT_CONTEXT TranContext;
566  KIRQL OldIrql;
567 
568  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
569 
571 
573 
574  /* Get associated connection endpoint file object. Quit if none exists */
575 
576  TranContext = IrpSp->FileObject->FsContext;
577  if (TranContext == NULL)
578  {
579  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
581  goto done;
582  }
583 
584  Connection = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
585  if (Connection == NULL)
586  {
587  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
589  goto done;
590  }
591 
593 
595  (TranContext->Handle.ConnectionContext,
596  Irp,
598 
599  LockObject(Connection, &OldIrql);
600 
601  if (Connection->AddressFile == NULL)
602  {
603  TI_DbgPrint(MID_TRACE, ("No associated address file\n"));
604  UnlockObject(Connection, OldIrql);
606  goto done;
607  }
608 
609  LockObjectAtDpcLevel(Connection->AddressFile);
610 
611  /* Listening will require us to create a listening socket and store it in
612  * the address file. It will be signalled, and attempt to complete an irp
613  * when a new connection arrives. */
614  /* The important thing to note here is that the irp we'll complete belongs
615  * to the socket to be accepted onto, not the listener */
616  if( NT_SUCCESS(Status) && !Connection->AddressFile->Listener ) {
617  Connection->AddressFile->Listener =
619 
620  if( !Connection->AddressFile->Listener )
622 
623  if( NT_SUCCESS(Status) ) {
624  ReferenceObject(Connection->AddressFile);
625  Connection->AddressFile->Listener->AddressFile =
626  Connection->AddressFile;
627 
628  Status = TCPSocket( Connection->AddressFile->Listener,
629  Connection->AddressFile->Family,
630  SOCK_STREAM,
631  Connection->AddressFile->Protocol );
632  }
633 
634  if( NT_SUCCESS(Status) ) {
635  ReferenceObject(Connection->AddressFile->Listener);
636  Status = TCPListen( Connection->AddressFile->Listener, 1024 );
637  /* BACKLOG */
638  }
639  }
640 
641  if( NT_SUCCESS(Status) ) {
642  Status = TCPAccept
644  Connection->AddressFile->Listener,
645  Connection,
647  Irp );
648  }
649 
651  UnlockObject(Connection, OldIrql);
652 
653 done:
654  if (Status != STATUS_PENDING) {
656  }
657 
658  TI_DbgPrint(MID_TRACE,("Leaving %x\n", Status));
659 
660  return STATUS_PENDING;
661 }
662 
663 
666  PIRP Irp)
667 /*
668  * FUNCTION: TDI_QUERY_INFORMATION handler
669  * ARGUMENTS:
670  * DeviceObject = Pointer to device object structure
671  * Irp = Pointer to an I/O request packet
672  * RETURNS:
673  * Status of operation
674  */
675 {
677  PTRANSPORT_CONTEXT TranContext;
679 
680  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
681 
684 
685  TranContext = IrpSp->FileObject->FsContext;
686  if (!TranContext) {
687  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
689  }
690 
691  switch (Parameters->QueryType)
692  {
694  {
695  PTDI_ADDRESS_INFO AddressInfo;
696  PADDRESS_FILE AddrFile;
698  PCONNECTION_ENDPOINT Endpoint = NULL;
699 
700 
701  if (MmGetMdlByteCount(Irp->MdlAddress) <
702  (FIELD_OFFSET(TDI_ADDRESS_INFO, Address.Address[0].Address) +
703  sizeof(TDI_ADDRESS_IP))) {
704  TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n"));
706  }
707 
708  AddressInfo = (PTDI_ADDRESS_INFO)MmGetSystemAddressForMdl(Irp->MdlAddress);
709  Address = (PTA_IP_ADDRESS)&AddressInfo->Address;
710 
711  switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
713  AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
714 
715  Address->TAAddressCount = 1;
716  Address->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
717  Address->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
718  Address->Address[0].Address[0].sin_port = AddrFile->Port;
719  Address->Address[0].Address[0].in_addr = AddrFile->Address.Address.IPv4Address;
721  &Address->Address[0].Address[0].sin_zero,
722  sizeof(Address->Address[0].Address[0].sin_zero));
723  return STATUS_SUCCESS;
724 
725  case TDI_CONNECTION_FILE:
726  Endpoint =
728 
729  Address->TAAddressCount = 1;
730  Address->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
731  Address->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
732  Address->Address[0].Address[0].sin_port = Endpoint->AddressFile->Port;
733  Address->Address[0].Address[0].in_addr = Endpoint->AddressFile->Address.Address.IPv4Address;
735  &Address->Address[0].Address[0].sin_zero,
736  sizeof(Address->Address[0].Address[0].sin_zero));
737  return STATUS_SUCCESS;
738 
739  default:
740  TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
742  }
743  }
744 
746  {
747  PTDI_CONNECTION_INFO ConnectionInfo;
748  //PCONNECTION_ENDPOINT Endpoint;
749 
750  if (MmGetMdlByteCount(Irp->MdlAddress) < sizeof(*ConnectionInfo)) {
751  TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n"));
753  }
754 
755  ConnectionInfo = (PTDI_CONNECTION_INFO)
756  MmGetSystemAddressForMdl(Irp->MdlAddress);
757 
758  switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
759  case TDI_CONNECTION_FILE:
760  //Endpoint = (PCONNECTION_ENDPOINT)TranContext->Handle.ConnectionContext;
761  RtlZeroMemory(ConnectionInfo, sizeof(*ConnectionInfo));
762  return STATUS_SUCCESS;
763 
764  default:
765  TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
767  }
768  }
769 
771  {
772  PTDI_MAX_DATAGRAM_INFO MaxDatagramInfo;
773 
774  if (MmGetMdlByteCount(Irp->MdlAddress) < sizeof(*MaxDatagramInfo)) {
775  TI_DbgPrint(MID_TRACE, ("MDL buffer too small.\n"));
777  }
778 
779  MaxDatagramInfo = (PTDI_MAX_DATAGRAM_INFO)
780  MmGetSystemAddressForMdl(Irp->MdlAddress);
781 
782  MaxDatagramInfo->MaxDatagramSize = 0xFFFF;
783 
784  return STATUS_SUCCESS;
785  }
786  }
787 
788  return STATUS_NOT_IMPLEMENTED;
789 }
790 
791 
793  PIRP Irp)
794 /*
795  * FUNCTION: TDI_RECEIVE handler
796  * ARGUMENTS:
797  * Irp = Pointer to an I/O request packet
798  * RETURNS:
799  * Status of operation
800  */
801 {
803  PTDI_REQUEST_KERNEL_RECEIVE ReceiveInfo;
804  PTRANSPORT_CONTEXT TranContext;
806  ULONG BytesReceived = 0;
807 
808  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
809 
811  ReceiveInfo = (PTDI_REQUEST_KERNEL_RECEIVE)&(IrpSp->Parameters);
812 
814 
815  TranContext = IrpSp->FileObject->FsContext;
816  if (TranContext == NULL)
817  {
818  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
820  goto done;
821  }
822 
823  if (TranContext->Handle.ConnectionContext == NULL)
824  {
825  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
827  goto done;
828  }
829 
830  /* Initialize a receive request */
832  (TranContext->Handle.ConnectionContext,
833  Irp,
835 
836  TI_DbgPrint(MID_TRACE,("TCPIP<<< Got an MDL: %x\n", Irp->MdlAddress));
837  if (NT_SUCCESS(Status))
838  {
840  TranContext->Handle.ConnectionContext,
841  (PNDIS_BUFFER)Irp->MdlAddress,
842  ReceiveInfo->ReceiveLength,
843  &BytesReceived,
844  ReceiveInfo->ReceiveFlags,
846  Irp);
847  }
848 
849 done:
850  if (Status != STATUS_PENDING) {
851  DispDataRequestComplete(Irp, Status, BytesReceived);
852  }
853 
854  TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
855 
856  return STATUS_PENDING;
857 }
858 
859 
861  PIRP Irp)
862 /*
863  * FUNCTION: TDI_RECEIVE_DATAGRAM handler
864  * ARGUMENTS:
865  * Irp = Pointer to an I/O request packet
866  * RETURNS:
867  * Status of operation
868  */
869 {
872  PTRANSPORT_CONTEXT TranContext;
875  ULONG BytesReceived = 0;
876 
877  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
878 
881 
883 
884  TranContext = IrpSp->FileObject->FsContext;
885  if (TranContext == NULL)
886  {
887  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
889  goto done;
890  }
891 
892  /* Initialize a receive request */
893  Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
894  Request.RequestNotifyObject = DispDataRequestComplete;
895  Request.RequestContext = Irp;
896 
898  IrpSp->FileObject->FsContext,
899  Irp,
901 
902  if (NT_SUCCESS(Status))
903  {
904  PVOID DataBuffer;
906 
907  NdisQueryBuffer( (PNDIS_BUFFER)Irp->MdlAddress,
908  &DataBuffer,
909  &BufferSize );
910 
912  Request.Handle.AddressHandle,
913  DgramInfo->ReceiveDatagramInformation,
914  DataBuffer,
915  DgramInfo->ReceiveLength,
916  DgramInfo->ReceiveFlags,
917  DgramInfo->ReturnDatagramInformation,
918  &BytesReceived,
920  Irp,
921  Irp);
922  }
923 
924 done:
925  if (Status != STATUS_PENDING) {
926  DispDataRequestComplete(Irp, Status, BytesReceived);
927  }
928 
929  TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
930 
931  return STATUS_PENDING;
932 }
933 
934 
936  PIRP Irp)
937 /*
938  * FUNCTION: TDI_SEND handler
939  * ARGUMENTS:
940  * Irp = Pointer to an I/O request packet
941  * RETURNS:
942  * Status of operation
943  */
944 {
946  PTDI_REQUEST_KERNEL_SEND SendInfo;
947  PTRANSPORT_CONTEXT TranContext;
949  ULONG BytesSent = 0;
950 
951  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
952 
954  SendInfo = (PTDI_REQUEST_KERNEL_SEND)&(IrpSp->Parameters);
955 
957 
958  TranContext = IrpSp->FileObject->FsContext;
959  if (TranContext == NULL)
960  {
961  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
963  goto done;
964  }
965 
966  if (TranContext->Handle.ConnectionContext == NULL)
967  {
968  TI_DbgPrint(MID_TRACE, ("No connection endpoint file object.\n"));
970  goto done;
971  }
972 
974  IrpSp->FileObject->FsContext,
975  Irp,
977 
978  TI_DbgPrint(MID_TRACE,("TCPIP<<< Got an MDL: %x\n", Irp->MdlAddress));
979  if (NT_SUCCESS(Status))
980  {
981  PVOID Data;
982  UINT Len;
983 
984  NdisQueryBuffer( Irp->MdlAddress, &Data, &Len );
985 
986  TI_DbgPrint(MID_TRACE,("About to TCPSendData\n"));
988  TranContext->Handle.ConnectionContext,
989  Data,
990  SendInfo->SendLength,
991  &BytesSent,
992  SendInfo->SendFlags,
994  Irp);
995  }
996 
997 done:
998  if (Status != STATUS_PENDING) {
999  DispDataRequestComplete(Irp, Status, BytesSent);
1000  }
1001 
1002  TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
1003 
1004  return STATUS_PENDING;
1005 }
1006 
1007 
1009  PIRP Irp)
1010 /*
1011  * FUNCTION: TDI_SEND_DATAGRAM handler
1012  * ARGUMENTS:
1013  * Irp = Pointer to an I/O request packet
1014  * RETURNS:
1015  * Status of operation
1016  */
1017 {
1020  PTDI_REQUEST_KERNEL_SENDDG DgramInfo;
1021  PTRANSPORT_CONTEXT TranContext;
1022  NTSTATUS Status;
1023 
1024  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1025 
1027  DgramInfo = (PTDI_REQUEST_KERNEL_SENDDG)&(IrpSp->Parameters);
1028 
1030 
1031  TranContext = IrpSp->FileObject->FsContext;
1032  if (TranContext == NULL)
1033  {
1034  TI_DbgPrint(MID_TRACE, ("Bad transport context.\n"));
1036  goto done;
1037  }
1038 
1039  /* Initialize a send request */
1040  Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
1041  Request.RequestNotifyObject = DispDataRequestComplete;
1042  Request.RequestContext = Irp;
1043 
1045  IrpSp->FileObject->FsContext,
1046  Irp,
1048 
1049  if (NT_SUCCESS(Status)) {
1050  PVOID DataBuffer;
1051  UINT BufferSize;
1052 
1053  TI_DbgPrint(MID_TRACE,("About to query buffer %x\n", Irp->MdlAddress));
1054 
1055  NdisQueryBuffer( (PNDIS_BUFFER)Irp->MdlAddress,
1056  &DataBuffer,
1057  &BufferSize );
1058 
1059  /* FIXME: DgramInfo->SendDatagramInformation->RemoteAddress
1060  must be of type PTDI_ADDRESS_IP */
1062  ("About to call send routine %x\n",
1063  (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)));
1064 
1065  if( (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send != NULL) )
1066  {
1067  ULONG DataUsed = 0;
1068  Status = (*((PADDRESS_FILE)Request.Handle.AddressHandle)->Send)(
1069  Request.Handle.AddressHandle,
1070  DgramInfo->SendDatagramInformation,
1071  DataBuffer,
1072  BufferSize,
1073  &DataUsed);
1074  Irp->IoStatus.Information = DataUsed;
1075  }
1076  else {
1078  ASSERT(FALSE);
1079  }
1080  }
1081 
1082 done:
1083  if (Status != STATUS_PENDING) {
1084  DispDataRequestComplete(Irp, Status, Irp->IoStatus.Information);
1085  }
1086 
1087  TI_DbgPrint(DEBUG_IRP, ("Leaving.\n"));
1088 
1089  return STATUS_PENDING;
1090 }
1091 
1092 
1094 /*
1095  * FUNCTION: TDI_SET_EVENT_HANDER handler
1096  * ARGUMENTS:
1097  * Irp = Pointer to a I/O request packet
1098  * RETURNS:
1099  * Status of operation
1100  */
1101 {
1103  PTRANSPORT_CONTEXT TranContext;
1105  PADDRESS_FILE AddrFile;
1106  NTSTATUS Status;
1107  KIRQL OldIrql;
1108 
1109  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1110 
1112 
1113  /* Get associated address file object. Quit if none exists */
1114 
1115  TranContext = IrpSp->FileObject->FsContext;
1116  if (!TranContext) {
1117  TI_DbgPrint(MIN_TRACE, ("Bad transport context.\n"));
1118  return STATUS_INVALID_PARAMETER;
1119  }
1120 
1121  AddrFile = (PADDRESS_FILE)TranContext->Handle.AddressHandle;
1122  if (!AddrFile) {
1123  TI_DbgPrint(MIN_TRACE, ("No address file object.\n"));
1124  return STATUS_INVALID_PARAMETER;
1125  }
1126 
1129 
1130  LockObject(AddrFile, &OldIrql);
1131 
1132  /* Set the event handler. if an event handler is associated with
1133  a specific event, it's flag (RegisteredXxxHandler) is TRUE.
1134  If an event handler is not used it's flag is FALSE */
1135  switch (Parameters->EventType) {
1136  case TDI_EVENT_CONNECT:
1137  if (!Parameters->EventHandler) {
1138  AddrFile->ConnectHandlerContext = NULL;
1139  AddrFile->RegisteredConnectHandler = FALSE;
1140  } else {
1141  AddrFile->ConnectHandler =
1142  (PTDI_IND_CONNECT)Parameters->EventHandler;
1143  AddrFile->ConnectHandlerContext = Parameters->EventContext;
1144  AddrFile->RegisteredConnectHandler = TRUE;
1145  }
1146  break;
1147 
1148  case TDI_EVENT_DISCONNECT:
1149  if (!Parameters->EventHandler) {
1150  AddrFile->DisconnectHandlerContext = NULL;
1151  AddrFile->RegisteredDisconnectHandler = FALSE;
1152  } else {
1153  AddrFile->DisconnectHandler =
1154  (PTDI_IND_DISCONNECT)Parameters->EventHandler;
1155  AddrFile->DisconnectHandlerContext = Parameters->EventContext;
1156  AddrFile->RegisteredDisconnectHandler = TRUE;
1157  }
1158  break;
1159 
1160  case TDI_EVENT_ERROR:
1161  if (Parameters->EventHandler == NULL) {
1162  AddrFile->ErrorHandlerContext = NULL;
1163  AddrFile->RegisteredErrorHandler = FALSE;
1164  } else {
1165  AddrFile->ErrorHandler =
1166  (PTDI_IND_ERROR)Parameters->EventHandler;
1167  AddrFile->ErrorHandlerContext = Parameters->EventContext;
1168  AddrFile->RegisteredErrorHandler = TRUE;
1169  }
1170  break;
1171 
1172  case TDI_EVENT_RECEIVE:
1173  if (Parameters->EventHandler == NULL) {
1174  AddrFile->ReceiveHandlerContext = NULL;
1175  AddrFile->RegisteredReceiveHandler = FALSE;
1176  } else {
1177  AddrFile->ReceiveHandler =
1178  (PTDI_IND_RECEIVE)Parameters->EventHandler;
1179  AddrFile->ReceiveHandlerContext = Parameters->EventContext;
1180  AddrFile->RegisteredReceiveHandler = TRUE;
1181  }
1182  break;
1183 
1185  if (Parameters->EventHandler == NULL) {
1186  AddrFile->ReceiveDatagramHandlerContext = NULL;
1188  } else {
1189  AddrFile->ReceiveDatagramHandler =
1190  (PTDI_IND_RECEIVE_DATAGRAM)Parameters->EventHandler;
1191  AddrFile->ReceiveDatagramHandlerContext = Parameters->EventContext;
1193  }
1194  break;
1195 
1197  if (Parameters->EventHandler == NULL) {
1200  } else {
1201  AddrFile->ExpeditedReceiveHandler =
1202  (PTDI_IND_RECEIVE_EXPEDITED)Parameters->EventHandler;
1203  AddrFile->ExpeditedReceiveHandlerContext = Parameters->EventContext;
1205  }
1206  break;
1207 
1209  if (Parameters->EventHandler == NULL) {
1210  AddrFile->ChainedReceiveHandlerContext = NULL;
1212  } else {
1213  AddrFile->ChainedReceiveHandler =
1214  (PTDI_IND_CHAINED_RECEIVE)Parameters->EventHandler;
1215  AddrFile->ChainedReceiveHandlerContext = Parameters->EventContext;
1217  }
1218  break;
1219 
1221  if (Parameters->EventHandler == NULL) {
1224  } else {
1225  AddrFile->ChainedReceiveDatagramHandler =
1227  AddrFile->ChainedReceiveDatagramHandlerContext = Parameters->EventContext;
1229  }
1230  break;
1231 
1233  if (Parameters->EventHandler == NULL) {
1236  } else {
1237  AddrFile->ChainedReceiveExpeditedHandler =
1239  AddrFile->ChainedReceiveExpeditedHandlerContext = Parameters->EventContext;
1241  }
1242  break;
1243 
1244  default:
1245  TI_DbgPrint(MIN_TRACE, ("Unknown event type (0x%X).\n",
1246  Parameters->EventType));
1247 
1249  }
1250 
1251  UnlockObject(AddrFile, OldIrql);
1252 
1253  return Status;
1254 }
1255 
1256 
1258  PIRP Irp)
1259 /*
1260  * FUNCTION: TDI_SET_INFORMATION handler
1261  * ARGUMENTS:
1262  * Irp = Pointer to an I/O request packet
1263  * RETURNS:
1264  * Status of operation
1265  */
1266 {
1267  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1268 
1269  return STATUS_NOT_IMPLEMENTED;
1270 }
1271 
1272 
1274  PVOID Context,
1275  ULONG Status,
1276  UINT ByteCount)
1277 /*
1278  * FUNCTION: Completes a TDI QueryInformationEx request
1279  * ARGUMENTS:
1280  * Context = Pointer to the IRP for the request
1281  * Status = TDI status of the request
1282  * ByteCount = Number of bytes returned in output buffer
1283  */
1284 {
1285  PTI_QUERY_CONTEXT QueryContext;
1286 
1287  QueryContext = (PTI_QUERY_CONTEXT)Context;
1288  if (NT_SUCCESS(Status)) {
1290  QueryContext->InputMdl,
1292  (PCHAR)&QueryContext->QueryInfo.Context,
1293  CONTEXT_SIZE);
1294  }
1295 
1296  MmUnlockPages(QueryContext->InputMdl);
1297  IoFreeMdl(QueryContext->InputMdl);
1298  if( QueryContext->OutputMdl ) {
1299  MmUnlockPages(QueryContext->OutputMdl);
1300  IoFreeMdl(QueryContext->OutputMdl);
1301  }
1302 
1303  QueryContext->Irp->IoStatus.Information = ByteCount;
1304  QueryContext->Irp->IoStatus.Status = Status;
1305 
1306  ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
1307 }
1308 
1309 
1311  PIRP Irp,
1313 /*
1314  * FUNCTION: TDI QueryInformationEx handler
1315  * ARGUMENTS:
1316  * Irp = Pointer to I/O request packet
1317  * IrpSp = Pointer to current stack location of Irp
1318  * RETURNS:
1319  * Status of operation
1320  */
1321 {
1323  PTRANSPORT_CONTEXT TranContext;
1324  PTI_QUERY_CONTEXT QueryContext;
1327  UINT Size;
1330  BOOLEAN InputMdlLocked = FALSE;
1331  BOOLEAN OutputMdlLocked = FALSE;
1332  PMDL InputMdl = NULL;
1333  PMDL OutputMdl = NULL;
1335 
1336  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1337 
1338  TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
1339 
1340  switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
1342  Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
1343  break;
1344 
1345  case TDI_CONNECTION_FILE:
1346  Request.Handle.ConnectionContext = TranContext->Handle.ConnectionContext;
1347  break;
1348 
1350  Request.Handle.ControlChannel = TranContext->Handle.ControlChannel;
1351  break;
1352 
1353  default:
1354  TI_DbgPrint(MIN_TRACE, ("Invalid transport context\n"));
1355  return STATUS_INVALID_PARAMETER;
1356  }
1357 
1358  InputBufferLength = IrpSp->Parameters.DeviceIoControl.InputBufferLength;
1359  OutputBufferLength = IrpSp->Parameters.DeviceIoControl.OutputBufferLength;
1360 
1361  /* Validate parameters */
1363  (OutputBufferLength != 0)) {
1364 
1366  IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
1367  OutputBuffer = Irp->UserBuffer;
1368 
1370  if (QueryContext) {
1371  _SEH2_TRY {
1372  InputMdl = IoAllocateMdl(InputBuffer,
1374  FALSE, TRUE, NULL);
1375 
1376  OutputMdl = IoAllocateMdl(OutputBuffer,
1378 
1379  if (InputMdl && OutputMdl) {
1380 
1381  MmProbeAndLockPages(InputMdl, Irp->RequestorMode,
1382  IoModifyAccess);
1383 
1384  InputMdlLocked = TRUE;
1385 
1386  MmProbeAndLockPages(OutputMdl, Irp->RequestorMode,
1387  IoWriteAccess);
1388 
1389  OutputMdlLocked = TRUE;
1390 
1391  RtlCopyMemory(&QueryContext->QueryInfo,
1393  } else
1397  } _SEH2_END;
1398 
1399  if (NT_SUCCESS(Status)) {
1400  Size = MmGetMdlByteCount(OutputMdl);
1401 
1402  QueryContext->Irp = Irp;
1403  QueryContext->InputMdl = InputMdl;
1404  QueryContext->OutputMdl = OutputMdl;
1405 
1406  Request.RequestNotifyObject = DispTdiQueryInformationExComplete;
1407  Request.RequestContext = QueryContext;
1409  &QueryContext->QueryInfo.ID, OutputMdl,
1410  &Size, &QueryContext->QueryInfo.Context);
1412 
1413  TI_DbgPrint(MAX_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1414 
1415  return Status;
1416  }
1417 
1418  /* An error occurred if we get here */
1419 
1420  if (InputMdl) {
1421  if (InputMdlLocked)
1422  MmUnlockPages(InputMdl);
1423  IoFreeMdl(InputMdl);
1424  }
1425 
1426  if (OutputMdl) {
1427  if (OutputMdlLocked)
1428  MmUnlockPages(OutputMdl);
1429  IoFreeMdl(OutputMdl);
1430  }
1431 
1432  ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
1433  } else
1435  } else if( InputBufferLength ==
1437  /* Handle the case where the user is probing the buffer for length */
1438  TI_DbgPrint(MAX_TRACE, ("InputBufferLength %d OutputBufferLength %d\n",
1441  IrpSp->Parameters.DeviceIoControl.Type3InputBuffer;
1442 
1443  Size = 0;
1444 
1446  if (!QueryContext) return STATUS_INSUFFICIENT_RESOURCES;
1447 
1448  _SEH2_TRY {
1449  InputMdl = IoAllocateMdl(InputBuffer,
1451  FALSE, TRUE, NULL);
1452 
1453  MmProbeAndLockPages(InputMdl, Irp->RequestorMode,
1454  IoModifyAccess);
1455 
1456  InputMdlLocked = TRUE;
1459  TI_DbgPrint(MAX_TRACE, ("Failed to acquire client buffer\n"));
1461  } _SEH2_END;
1462 
1463  if( !NT_SUCCESS(Status) || !InputMdl ) {
1464  if( InputMdl ) IoFreeMdl( InputMdl );
1465  ExFreePoolWithTag(QueryContext, QUERY_CONTEXT_TAG);
1466  return Status;
1467  }
1468 
1469  RtlCopyMemory(&QueryContext->QueryInfo,
1471 
1472  QueryContext->Irp = Irp;
1473  QueryContext->InputMdl = InputMdl;
1474  QueryContext->OutputMdl = NULL;
1475 
1476  Request.RequestNotifyObject = DispTdiQueryInformationExComplete;
1477  Request.RequestContext = QueryContext;
1479  &QueryContext->QueryInfo.ID,
1480  NULL,
1481  &Size,
1482  &QueryContext->QueryInfo.Context);
1484  TI_DbgPrint(MAX_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1486 
1487  TI_DbgPrint(MIN_TRACE, ("Leaving. Status = (0x%X)\n", Status));
1488 
1489  return Status;
1490 }
1491 
1492 
1494  PIRP Irp,
1496 /*
1497  * FUNCTION: TDI SetInformationEx handler
1498  * ARGUMENTS:
1499  * Irp = Pointer to I/O request packet
1500  * IrpSp = Pointer to current stack location of Irp
1501  * RETURNS:
1502  * Status of operation
1503  */
1504 {
1505  PTRANSPORT_CONTEXT TranContext;
1509 
1510  TI_DbgPrint(DEBUG_IRP, ("Called.\n"));
1511 
1512  TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
1513  Info = (PTCP_REQUEST_SET_INFORMATION_EX)Irp->AssociatedIrp.SystemBuffer;
1514 
1515  switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
1517  Request.Handle.AddressHandle = TranContext->Handle.AddressHandle;
1518  break;
1519 
1520  case TDI_CONNECTION_FILE:
1521  Request.Handle.ConnectionContext = TranContext->Handle.ConnectionContext;
1522  break;
1523 
1525  Request.Handle.ControlChannel = TranContext->Handle.ControlChannel;
1526  break;
1527 
1528  default:
1529  Irp->IoStatus.Status = STATUS_INVALID_PARAMETER;
1530  Irp->IoStatus.Information = 0;
1531 
1532  TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
1533 
1534  return Irp->IoStatus.Status;
1535  }
1536 
1537  Request.RequestNotifyObject = NULL;
1538  Request.RequestContext = NULL;
1539 
1541  &Info->Buffer, Info->BufferSize);
1542 
1543  return Status;
1544 }
1545 
1546 /* TODO: Support multiple addresses per interface.
1547  * For now just set the nte context to the interface index.
1548  *
1549  * Later on, create an NTE context and NTE instance
1550  */
1551 
1554  PIP_SET_ADDRESS IpAddrChange =
1555  (PIP_SET_ADDRESS)Irp->AssociatedIrp.SystemBuffer;
1556  IF_LIST_ITER(IF);
1557 
1558  TI_DbgPrint(MID_TRACE,("Setting IP Address for adapter %d\n",
1559  IpAddrChange->NteIndex));
1560 
1561  ForEachInterface(IF) {
1562  TI_DbgPrint(MID_TRACE,("Looking at adapter %d\n", IF->Index));
1563 
1564  if( IF->Unicast.Address.IPv4Address == IpAddrChange->Address ) {
1566  break;
1567  }
1568  if( IF->Index == IpAddrChange->NteIndex ) {
1569  IPRemoveInterfaceRoute( IF );
1570 
1571  IF->Unicast.Type = IP_ADDRESS_V4;
1572  IF->Unicast.Address.IPv4Address = IpAddrChange->Address;
1573 
1574  IF->Netmask.Type = IP_ADDRESS_V4;
1575  IF->Netmask.Address.IPv4Address = IpAddrChange->Netmask;
1576 
1577  IF->Broadcast.Type = IP_ADDRESS_V4;
1578  IF->Broadcast.Address.IPv4Address =
1579  IF->Unicast.Address.IPv4Address |
1580  ~IF->Netmask.Address.IPv4Address;
1581 
1582  TI_DbgPrint(MID_TRACE,("New Unicast Address: %x\n",
1583  IF->Unicast.Address.IPv4Address));
1584  TI_DbgPrint(MID_TRACE,("New Netmask : %x\n",
1585  IF->Netmask.Address.IPv4Address));
1586 
1587  IPAddInterfaceRoute( IF );
1588 
1589  IpAddrChange->Address = IF->Index;
1591  Irp->IoStatus.Information = IF->Index;
1592  break;
1593  }
1594  } EndFor(IF);
1595 
1596  Irp->IoStatus.Status = Status;
1597  return Status;
1598 }
1599 
1602  PUSHORT NteIndex = Irp->AssociatedIrp.SystemBuffer;
1603  IF_LIST_ITER(IF);
1604 
1605  ForEachInterface(IF) {
1606  if( IF->Index == *NteIndex ) {
1607  IPRemoveInterfaceRoute( IF );
1608  IF->Unicast.Type = IP_ADDRESS_V4;
1609  IF->Unicast.Address.IPv4Address = 0;
1610 
1611  IF->Netmask.Type = IP_ADDRESS_V4;
1612  IF->Netmask.Address.IPv4Address = 0;
1613 
1614  IF->Broadcast.Type = IP_ADDRESS_V4;
1615  IF->Broadcast.Address.IPv4Address = 0;
1616 
1618  }
1619  } EndFor(IF);
1620 
1621  Irp->IoStatus.Status = Status;
1622  return Status;
1623 }
1624 
1625 VOID NTAPI
1631  PIRP Irp;
1634 
1635  IoFreeWorkItem(WorkItem->WorkItem);
1636  Irp = WorkItem->Irp;
1637  AddrInitIPv4(&Remote, WorkItem->RemoteIP);
1639  while (Now.QuadPart - WorkItem->StartTime.QuadPart < 10000 * 1000 && !Irp->Cancel) {
1640  NCE = NBLocateNeighbor(&Remote, WorkItem->Interface);
1641  if (NCE && !(NCE->State & NUD_INCOMPLETE)) {
1642  break;
1643  }
1644 
1645  NCE = NULL;
1646  Wait.QuadPart = -10000;
1649  }
1650 
1651  if (NCE) {
1653 
1654  if (NCE->LinkAddressLength > WorkItem->IrpSp->Parameters.DeviceIoControl.OutputBufferLength) {
1656  } else {
1657  OutputBuffer = Irp->AssociatedIrp.SystemBuffer;
1659  Irp->IoStatus.Information = NCE->LinkAddressLength;
1661  }
1662  }
1663 
1665  if (Irp->Flags & IRP_SYNCHRONOUS_API) {
1666  Irp->IoStatus.Status = Status;
1667  } else {
1668  IRPFinish(Irp, Status);
1669  }
1670 }
1671 
1673  NTSTATUS Status;
1674  PULONG IPs;
1675  IP_ADDRESS Remote, Local;
1678  PQUERY_HW_WORK_ITEM WorkItem;
1679 
1680  Irp->IoStatus.Information = 0;
1681 
1682  if (IrpSp->Parameters.DeviceIoControl.InputBufferLength < 2 * sizeof(ULONG) ||
1683  IrpSp->Parameters.DeviceIoControl.OutputBufferLength == 0) {
1685  goto Exit;
1686  }
1687 
1688  IPs = (PULONG)Irp->AssociatedIrp.SystemBuffer;
1689  AddrInitIPv4(&Remote, IPs[0]);
1690  AddrInitIPv4(&Local, IPs[1]);
1691 
1692  if (AddrIsUnspecified(&Remote)) {
1694  goto Exit;
1695  }
1696 
1698  if (Interface) {
1700 
1701  if (Interface->AddressLength > IrpSp->Parameters.DeviceIoControl.OutputBufferLength) {
1703  goto Exit;
1704  }
1705 
1706  OutputBuffer = Irp->AssociatedIrp.SystemBuffer;
1707  RtlCopyMemory(OutputBuffer, Interface->Address, Interface->AddressLength);
1708  Irp->IoStatus.Information = Interface->AddressLength;
1710  goto Exit;
1711  }
1712 
1713  if (AddrIsUnspecified(&Local)) {
1715  if (NCE == NULL) {
1717  goto Exit;
1718  }
1719 
1720  Interface = NCE->Interface;
1721  }
1722  else {
1723  Interface = AddrLocateInterface(&Local);
1724  if (Interface == NULL) {
1726  if (Interface == NULL) {
1728  goto Exit;
1729  }
1730  }
1731  }
1732 
1734  if (WorkItem == NULL) {
1736  goto Exit;
1737  }
1738 
1740  if (WorkItem->WorkItem == NULL) {
1743  goto Exit;
1744  }
1745 
1746  WorkItem->Irp = Irp;
1747  WorkItem->IrpSp = IrpSp;
1748  WorkItem->Interface = Interface;
1749  WorkItem->RemoteIP = IPs[0];
1750  KeQuerySystemTime(&WorkItem->StartTime);
1751 
1753  if (NCE != NULL) {
1754  if (NCE->LinkAddressLength > IrpSp->Parameters.DeviceIoControl.OutputBufferLength) {
1755  IoFreeWorkItem(WorkItem->WorkItem);
1758  goto Exit;
1759  }
1760 
1761  if (!(NCE->State & NUD_INCOMPLETE)) {
1763  if (LinkAddress == NULL) {
1764  IoFreeWorkItem(WorkItem->WorkItem);
1767  goto Exit;
1768  }
1769  memset(LinkAddress, 0xff, NCE->LinkAddressLength);
1770  NBUpdateNeighbor(NCE, LinkAddress, NUD_INCOMPLETE);
1771  ExFreePoolWithTag(LinkAddress, QUERY_CONTEXT_TAG);
1772  }
1773  }
1774 
1775  if (!ARPTransmit(&Remote, NULL, Interface)) {
1776  IoFreeWorkItem(WorkItem->WorkItem);
1779  goto Exit;
1780  }
1781 
1782  if (Irp->Flags & IRP_SYNCHRONOUS_API) {
1783  WaitForHwAddress(DeviceObject, WorkItem);
1784  Status = Irp->IoStatus.Status;
1785  } else {
1789  }
1790 
1791 Exit:
1792  return Status;
1793 }
1794 
1795 /* EOF */
#define KeQuerySystemTime(t)
Definition: env_spec_w32.h:570
NTSTATUS TCPConnect(PCONNECTION_ENDPOINT Connection, PTDI_CONNECTION_INFORMATION ConnInfo, PTDI_CONNECTION_INFORMATION ReturnInfo, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
Definition: tcp.c:277
UINT CopyBufferToBufferChain(PNDIS_BUFFER DstBuffer, UINT DstOffset, PUCHAR SrcData, UINT Length)
Definition: buffer.c:54
BOOLEAN AddrIsUnspecified(PIP_ADDRESS Address)
Definition: address.c:113
NTSTATUS DispTdiAccept(PIRP Irp)
Definition: dispatch.c:254
signed char * PCHAR
Definition: retypes.h:7
VOID NTAPI WaitForHwAddress(PDEVICE_OBJECT DeviceObject, PVOID Context)
Definition: dispatch.c:1626
#define TI_DbgPrint(_t_, _x_)
Definition: debug.h:45
VOID NTAPI DispCancelListenRequest(PDEVICE_OBJECT Device, PIRP Irp)
Definition: dispatch.c:209
#define STATUS_DEVICE_DOES_NOT_EXIST
Definition: ntstatus.h:414
PTDI_IND_DISCONNECT DisconnectHandler
Definition: titypes.h:168
PTDI_CONNECTION_INFORMATION ReturnConnectionInformation
Definition: tdikrnl.h:42
PVOID ChainedReceiveExpeditedHandlerContext
Definition: titypes.h:198
VOID DispDataRequestComplete(PVOID Context, NTSTATUS Status, ULONG Count)
Definition: dispatch.c:87
IPv4_RAW_ADDRESS IPv4Address
Definition: ip.h:26
DRIVER_CANCEL * PDRIVER_CANCEL
Definition: iotypes.h:2405
struct _TDI_REQUEST_KERNEL_RECEIVEDG * PTDI_REQUEST_KERNEL_RECEIVEDG
IPv4_RAW_ADDRESS Netmask
Definition: ip.h:176
#define TDI_QUERY_CONNECTION_INFO
Definition: tdi.h:182
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
BOOLEAN RegisteredReceiveDatagramHandler
Definition: titypes.h:183
struct _TDI_REQUEST_KERNEL_ASSOCIATE * PTDI_REQUEST_KERNEL_ASSOCIATE
#define MID_TRACE
Definition: debug.h:15
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
struct png_info_def **typedef void(__cdecl typeof(png_destroy_read_struct))(struct png_struct_def **
Definition: typeof.h:49
#define TDI_LISTEN
Definition: tdikrnl.h:50
NTSTATUS(NTAPI * PTDI_IND_CHAINED_RECEIVE_EXPEDITED)(_In_opt_ PVOID TdiEventContext, _In_opt_ CONNECTION_CONTEXT ConnectionContext, _In_ ULONG ReceiveFlags, _In_ ULONG ReceiveLength, _In_ ULONG StartingOffset, _In_ PMDL Tsdu, _In_ PVOID TsduDescriptor)
Definition: tdikrnl.h:352
PVOID ChainedReceiveDatagramHandlerContext
Definition: titypes.h:194
NTSTATUS(NTAPI * PTDI_IND_DISCONNECT)(_In_opt_ PVOID TdiEventContext, _In_opt_ CONNECTION_CONTEXT ConnectionContext, _In_ LONG DisconnectDataLength, _In_reads_bytes_opt_(DisconnectDataLength) PVOID DisconnectData, _In_ LONG DisconnectInformationLength, _In_reads_bytes_opt_(DisconnectInformationLength) PVOID DisconnectInformation, _In_ ULONG DisconnectFlags)
Definition: tdikrnl.h:185
TDI_STATUS InfoTdiQueryInformationEx(PTDI_REQUEST Request, TDIObjectID *ID, PNDIS_BUFFER Buffer, PUINT BufferSize, PVOID Context)
Definition: info.c:215
HANDLE ControlChannel
Definition: titypes.h:313
_In_ PIRP _In_ PDEVICE_OBJECT Device
Definition: fatprocs.h:2020
struct _TDI_REQUEST_KERNEL_SET_EVENT * PTDI_REQUEST_KERNEL_SET_EVENT
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
NTSTATUS TCPListen(PCONNECTION_ENDPOINT Connection, UINT Backlog)
Definition: accept.c:47
Definition: neighbor.h:28
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
ULONG MaxDatagramSize
Definition: tdi.h:230
NTSTATUS TCPReceiveData(PCONNECTION_ENDPOINT Connection, PNDIS_BUFFER Buffer, ULONG ReceiveLength, PULONG BytesReceived, ULONG ReceiveFlags, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
Definition: tcp.c:476
MDL * PNDIS_BUFFER
Definition: ndis.h:343
ULONG_PTR Context[CONTEXT_SIZE/sizeof(ULONG_PTR)]
Definition: tdiinfo.h:84
struct _TDI_REQUEST_KERNEL_QUERY_INFO * PTDI_REQUEST_KERNEL_QUERY_INFORMATION
PIO_WORKITEM WorkItem
Definition: dispatch.c:18
struct _IP_SET_ADDRESS * PIP_SET_ADDRESS
struct _TA_ADDRESS_IP * PTA_IP_ADDRESS
BOOLEAN RegisteredExpeditedReceiveHandler
Definition: titypes.h:187
LONG NTSTATUS
Definition: precomp.h:26
USHORT Protocol
Definition: titypes.h:138
#define TDI_EVENT_RECEIVE_EXPEDITED
Definition: tdikrnl.h:151
NTSTATUS TCPSendData(PCONNECTION_ENDPOINT Connection, PCHAR Buffer, ULONG DataSize, PULONG DataUsed, ULONG Flags, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
Definition: tcp.c:525
struct _CONNECTION_ENDPOINT * PCONNECTION_ENDPOINT
#define TDI_EVENT_DISCONNECT
Definition: tdikrnl.h:147
BOOLEAN TCPAbortListenForSocket(PCONNECTION_ENDPOINT Listener, PCONNECTION_ENDPOINT Connection)
Definition: accept.c:104
VOID NTAPI IoAcquireCancelSpinLock(OUT PKIRQL Irql)
Definition: util.c:56
PVOID ReceiveHandlerContext
Definition: titypes.h:178
PTDI_IND_RECEIVE ReceiveHandler
Definition: titypes.h:177
#define TDI_CONNECTION_FILE
Definition: tdikrnl.h:66
#define LockObjectAtDpcLevel(Object)
Definition: titypes.h:44
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG _In_ ULONG OutputBufferLength
Definition: fltkernel.h:1374
NTSTATUS DispTdiReceive(PIRP Irp)
Definition: dispatch.c:792
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
NTSTATUS TCPSocket(PCONNECTION_ENDPOINT Connection, UINT Family, UINT Type, UINT Proto)
Definition: tcp.c:125
VOID NTAPI MmUnlockPages(IN PMDL Mdl)
Definition: mdlsup.c:1439
LONG TDI_STATUS
Definition: tdi.h:36
PNEIGHBOR_CACHE_ENTRY RouteGetRouteToDestination(PIP_ADDRESS Destination)
Definition: router.c:300
#define IF_LIST_ITER(n)
Definition: tilists.h:5
PNEIGHBOR_CACHE_ENTRY NBLocateNeighbor(PIP_ADDRESS Address, PIP_INTERFACE Interface)
Definition: neighbor.c:417
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
NTSTATUS(NTAPI * PTDI_IND_CHAINED_RECEIVE_DATAGRAM)(_In_opt_ PVOID TdiEventContext, _In_ LONG SourceAddressLength, _In_reads_bytes_(SourceAddressLength) PVOID SourceAddress, _In_ LONG OptionsLength, _In_reads_bytes_opt_(OptionsLength) PVOID Options, _In_ ULONG ReceiveDatagramFlags, _In_ ULONG ReceiveDatagramLength, _In_ ULONG StartingOffset, _In_ PMDL Tsdu, _In_ PVOID TsduDescriptor)
Definition: tdikrnl.h:324
IoSetCancelRoutine(Irp, CancelRoutine)
ULONG NteIndex
Definition: ip.h:174
PIO_WORKITEM NTAPI IoAllocateWorkItem(IN PDEVICE_OBJECT DeviceObject)
Definition: iowork.c:75
VOID NTAPI IoFreeWorkItem(IN PIO_WORKITEM IoWorkItem)
Definition: iowork.c:64
union _TRANSPORT_CONTEXT::@997 Handle
NTSTATUS DispTdiQueryIpHwAddress(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: dispatch.c:1672
struct TraceInfo Info
CHAR InputBuffer[80]
Definition: conmgr.c:33
UINT LinkAddressLength
Definition: neighbor.h:34
#define DereferenceObject(Object)
Definition: titypes.h:24
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
NTSTATUS(NTAPI * PTDI_IND_ERROR)(_In_opt_ PVOID TdiEventContext, _In_ NTSTATUS Status)
Definition: tdikrnl.h:207
_SEH2_TRY
Definition: create.c:4250
HANDLE AddressHandle
Definition: titypes.h:311
uint32_t ULONG_PTR
Definition: typedefs.h:63
struct _CONNECTION_ENDPOINT * Next
Definition: titypes.h:289
#define LockObject(Object, Irql)
Definition: titypes.h:34
Definition: ip.h:23
#define TDI_QUERY_ADDRESS_INFO
Definition: tdi.h:181
_In_ NDIS_HANDLE _In_ PNDIS_REQUEST Request
Definition: ndis.h:5173
PADDRESS_FILE AddressFile
Definition: titypes.h:268
UCHAR KIRQL
Definition: env_spec_w32.h:591
BOOLEAN RegisteredErrorHandler
Definition: titypes.h:175
#define TDI_EVENT_RECEIVE
Definition: tdikrnl.h:149
#define TDI_DISCONNECT
Definition: tdikrnl.h:52
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:496
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define IP_ADDRESS_V4
Definition: ip.h:32
NTSTATUS DispTdiSetInformation(PIRP Irp)
Definition: dispatch.c:1257
NTSTATUS DispTdiSetIPAddress(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: dispatch.c:1552
BOOLEAN RegisteredChainedReceiveDatagramHandler
Definition: titypes.h:195
struct _TDI_REQUEST_KERNEL_SEND * PTDI_REQUEST_KERNEL_SEND
NTSTATUS TCPAccept(PTDI_REQUEST Request, PCONNECTION_ENDPOINT Listener, PCONNECTION_ENDPOINT Connection, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
Definition: accept.c:136
BOOLEAN ARPTransmit(PIP_ADDRESS Address, PVOID LinkAddress, PIP_INTERFACE Interface)
Definition: arp.c:111
#define UnlockObject(Object, OldIrql)
Definition: titypes.h:54
NTSTATUS DispTdiDisconnect(PIRP Irp)
Definition: dispatch.c:485
NTSTATUS NTAPI KeDelayExecutionThread(IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Interval OPTIONAL)
Definition: wait.c:283
TDI_REQUEST_KERNEL * PTDI_REQUEST_KERNEL_DISCONNECT
Definition: tdikrnl.h:93
struct _ADDRESS_FILE * PADDRESS_FILE
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
_In_opt_ PDRIVER_CANCEL CancelRoutine
Definition: iofuncs.h:2696
#define TDI_CONNECT
Definition: tdikrnl.h:49
unsigned char BOOLEAN
struct _QUERY_HW_WORK_ITEM * PQUERY_HW_WORK_ITEM
DATAGRAM_COMPLETION_ROUTINE PDATAGRAM_COMPLETION_ROUTINE
Definition: titypes.h:92
smooth NULL
Definition: ftsmooth.c:416
#define ForEachInterface(n)
Definition: tilists.h:9
static WCHAR Address[46]
Definition: ping.c:68
_In_ LPGUID _In_ PVOID Data
Definition: classpnp.h:778
#define IoCompleteRequest
Definition: irp.c:1240
UCHAR State
Definition: neighbor.h:30
#define TDI_RECEIVE_DATAGRAM
Definition: tdikrnl.h:56
#define TDI_EVENT_CHAINED_RECEIVE
Definition: tdikrnl.h:153
_Must_inspect_result_ __drv_aliasesMem _In_ PDEVICE_OBJECT _In_opt_ PVOID _In_ ULONG _Out_opt_ PVOID OutputBuffer
Definition: iofuncs.h:713
switch(r->id)
Definition: btrfs.c:2932
#define QUERY_CONTEXT_TAG
Definition: tags.h:17
NTSTATUS DispTdiReceiveDatagram(PIRP Irp)
Definition: dispatch.c:860
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
#define DEBUG_IRP
Definition: debug.h:19
PTDI_IND_RECEIVE_DATAGRAM ReceiveDatagramHandler
Definition: titypes.h:181
BOOLEAN RegisteredChainedReceiveHandler
Definition: titypes.h:191
BOOLEAN RegisteredConnectHandler
Definition: titypes.h:166
#define IO_NETWORK_INCREMENT
Definition: tcpip.h:43
PVOID ReceiveDatagramHandlerContext
Definition: titypes.h:182
PVOID LinkAddress
Definition: neighbor.h:35
struct _TDI_CONNECTION_INFO * PTDI_CONNECTION_INFO
#define STATUS_INVALID_BUFFER_SIZE
Definition: ntstatus.h:636
NTSTATUS DispPrepareIrpForCancel(PTRANSPORT_CONTEXT Context, PIRP Irp, PDRIVER_CANCEL CancelRoutine)
Definition: dispatch.c:41
BOOLEAN CancelIrps
Definition: titypes.h:315
VOID NBUpdateNeighbor(PNEIGHBOR_CACHE_ENTRY NCE, PVOID LinkAddress, UCHAR State)
Definition: neighbor.c:346
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
#define TDI_RECEIVE
Definition: tdikrnl.h:54
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206
NTSTATUS DGReceiveDatagram(PADDRESS_FILE AddrFile, PTDI_CONNECTION_INFORMATION ConnInfo, PCHAR Buffer, ULONG ReceiveLength, ULONG ReceiveFlags, PTDI_CONNECTION_INFORMATION ReturnInfo, PULONG BytesReceived, PDATAGRAM_COMPLETION_ROUTINE Complete, PVOID Context, PIRP Irp)
Definition: datagram.c:220
struct _QUERY_HW_WORK_ITEM QUERY_HW_WORK_ITEM
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
static void Exit(void)
Definition: sock.c:1331
#define AddrInitIPv4(IPAddress, RawAddress)
Definition: address.h:16
#define TDI_EVENT_CONNECT
Definition: tdikrnl.h:146
PTDI_IND_ERROR ErrorHandler
Definition: titypes.h:172
BOOLEAN RegisteredChainedReceiveExpeditedHandler
Definition: titypes.h:199
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
#define BufferSize
Definition: classpnp.h:419
struct _TCP_REQUEST_QUERY_INFORMATION_EX * PTCP_REQUEST_QUERY_INFORMATION_EX
#define Len
Definition: deflate.h:82
PVOID RequestSpecific
Definition: tdikrnl.h:43
union IP_ADDRESS::@979 Address
#define NUD_INCOMPLETE
Definition: neighbor.h:41
* PFILE_OBJECT
Definition: iotypes.h:1955
VOID NTAPI IoFreeMdl(PMDL Mdl)
Definition: iomdl.c:146
NTSTATUS(NTAPI * PTDI_IND_CHAINED_RECEIVE)(_In_opt_ PVOID TdiEventContext, _In_opt_ CONNECTION_CONTEXT ConnectionContext, _In_ ULONG ReceiveFlags, _In_ ULONG ReceiveLength, _In_ ULONG StartingOffset, _In_ PMDL Tsdu, _In_ PVOID TsduDescriptor)
Definition: tdikrnl.h:302
VOID IPAddInterfaceRoute(PIP_INTERFACE IF)
Definition: ip.c:266
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
NTSTATUS(NTAPI * PTDI_IND_RECEIVE_DATAGRAM)(_In_opt_ PVOID TdiEventContext, _In_ LONG SourceAddressLength, _In_reads_bytes_(SourceAddressLength) PVOID SourceAddress, _In_ LONG OptionsLength, _In_reads_bytes_opt_(OptionsLength) PVOID Options, _In_ ULONG ReceiveDatagramFlags, _In_ ULONG BytesIndicated, _In_ ULONG BytesAvailable, _Out_ ULONG *BytesTaken, _In_ PVOID Tsdu, _Out_opt_ PIRP *IoRequestPacket)
Definition: tdikrnl.h:249
NTSTATUS(NTAPI * PTDI_IND_CONNECT)(_In_opt_ PVOID TdiEventContext, _In_ LONG RemoteAddressLength, _In_reads_bytes_(RemoteAddressLength) PVOID RemoteAddress, _In_ LONG UserDataLength, _In_reads_bytes_opt_(UserDataLength) PVOID UserData, _In_ LONG OptionsLength, _In_reads_bytes_opt_(OptionsLength) PVOID Options, _Out_ CONNECTION_CONTEXT *ConnectionContext, _Out_ PIRP *AcceptIrp)
Definition: tdikrnl.h:159
unsigned char UCHAR
Definition: xmlstorage.h:181
PTDI_IND_CHAINED_RECEIVE_DATAGRAM ChainedReceiveDatagramHandler
Definition: titypes.h:193
NTSTATUS DispTdiSend(PIRP Irp)
Definition: dispatch.c:935
#define UnlockObjectFromDpcLevel(Object)
Definition: titypes.h:63
_In_ PPCI_DEVICE_PRESENCE_PARAMETERS Parameters
Definition: iotypes.h:872
TRANSPORT_ADDRESS Address
Definition: tdi.h:388
_Requires_lock_held_ Interrupt _Releases_lock_ Interrupt _In_ _IRQL_restores_ KIRQL OldIrql
Definition: kefuncs.h:803
PTDI_IND_CHAINED_RECEIVE_EXPEDITED ChainedReceiveExpeditedHandler
Definition: titypes.h:197
KTIMER DisconnectTimer
Definition: titypes.h:280
#define CONTEXT_SIZE
Definition: tdiinfo.h:80
NTSTATUS DispTdiAssociateAddress(PIRP Irp)
Definition: dispatch.c:270
NTSTATUS DispTdiQueryInformationEx(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: dispatch.c:1310
TCP_REQUEST_QUERY_INFORMATION_EX QueryInfo
Definition: titypes.h:323
struct tm * Now
Definition: output.c:19
#define TDI_TRANSPORT_ADDRESS_FILE
Definition: tdikrnl.h:65
#define TDI_ADDRESS_TYPE_IP
Definition: tdi.h:345
NTSTATUS DispTdiDeleteIPAddress(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: dispatch.c:1600
NTSTATUS DispTdiSetEventHandler(PIRP Irp)
Definition: dispatch.c:1093
#define ReferenceObject(Object)
Definition: titypes.h:14
NTSTATUS DispTdiSetInformationEx(PIRP Irp, PIO_STACK_LOCATION IrpSp)
Definition: dispatch.c:1493
#define TDI_EVENT_RECEIVE_DATAGRAM
Definition: tdikrnl.h:150
PIP_INTERFACE Interface
Definition: dispatch.c:21
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
struct _CONNECTION_ENDPOINT * Listener
Definition: titypes.h:153
struct _TDI_REQUEST_KERNEL_SENDDG * PTDI_REQUEST_KERNEL_SENDDG
_In_ UCHAR MinorFunction
Definition: pofuncs.h:42
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
IPv4_RAW_ADDRESS Address
Definition: ip.h:175
PIO_STACK_LOCATION IrpSp
Definition: dispatch.c:20
_Must_inspect_result_ _In_ PFILE_OBJECT _In_ ULONG _In_ ULONG InputBufferLength
Definition: fltkernel.h:1372
PVOID ExpeditedReceiveHandlerContext
Definition: titypes.h:186
#define TDI_EVENT_CHAINED_RECEIVE_DATAGRAM
Definition: tdikrnl.h:154
struct _TI_QUERY_CONTEXT * PTI_QUERY_CONTEXT
VOID NTAPI IoReleaseCancelSpinLock(IN KIRQL Irql)
Definition: util.c:150
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _In_ LARGE_INTEGER ByteCount
Definition: iotypes.h:1061
Status
Definition: gdiplustypes.h:24
PVOID ConnectHandlerContext
Definition: titypes.h:165
PTDI_IND_CHAINED_RECEIVE ChainedReceiveHandler
Definition: titypes.h:189
BOOLEAN RegisteredDisconnectHandler
Definition: titypes.h:170
PMDL NTAPI IoAllocateMdl(IN PVOID VirtualAddress, IN ULONG Length, IN BOOLEAN SecondaryBuffer, IN BOOLEAN ChargeQuota, IN PIRP Irp)
Definition: iomdl.c:22
PTDI_IND_CONNECT ConnectHandler
Definition: titypes.h:164
PVOID ErrorHandlerContext
Definition: titypes.h:173
VOID NTAPI IoQueueWorkItem(IN PIO_WORKITEM IoWorkItem, IN PIO_WORKITEM_ROUTINE WorkerRoutine, IN WORK_QUEUE_TYPE QueueType, IN PVOID Context)
Definition: iowork.c:40
PTDI_CONNECTION_INFORMATION RequestConnectionInformation
Definition: tdikrnl.h:41
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
PVOID ChainedReceiveHandlerContext
Definition: titypes.h:190
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
VOID NTAPI DispCancelRequest(PDEVICE_OBJECT Device, PIRP Irp)
Definition: dispatch.c:118
PIP_INTERFACE Interface
Definition: neighbor.h:33
LARGE_INTEGER StartTime
Definition: dispatch.c:22
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
_SEH2_END
Definition: create.c:4424
#define TDI_SEND
Definition: tdikrnl.h:53
PIP_INTERFACE AddrLocateInterface(PIP_ADDRESS MatchAddress)
Definition: interface.c:89
#define EndFor(n)
Definition: tilists.h:20
BOOLEAN DGRemoveIRP(PADDRESS_FILE AddrFile, PIRP Irp)
Definition: datagram.c:13
NTSTATUS(NTAPI * PTDI_IND_RECEIVE_EXPEDITED)(_In_opt_ PVOID TdiEventContext, _In_opt_ CONNECTION_CONTEXT ConnectionContext, _In_ ULONG ReceiveFlags, _In_ ULONG BytesIndicated, _In_ ULONG BytesAvailable, _Out_ ULONG *BytesTaken, _In_ PVOID Tsdu, _Out_opt_ PIRP *IoRequestPacket)
Definition: tdikrnl.h:278
#define MAX_TRACE
Definition: debug.h:16
VOID NTAPI MmProbeAndLockPages(IN PMDL Mdl, IN KPROCESSOR_MODE AccessMode, IN LOCK_OPERATION Operation)
Definition: mdlsup.c:935
NTSTATUS TCPDisconnect(PCONNECTION_ENDPOINT Connection, UINT Flags, PLARGE_INTEGER Timeout, PTDI_CONNECTION_INFORMATION ConnInfo, PTDI_CONNECTION_INFORMATION ReturnInfo, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
Definition: tcp.c:387
PTDI_CONNECTION_INFORMATION ReceiveDatagramInformation
Definition: tdikrnl.h:109
CONNECTION_CONTEXT ConnectionContext
Definition: titypes.h:312
IP_ADDRESS Address
Definition: titypes.h:136
_In_ PIO_STACK_LOCATION IrpSp
Definition: create.c:4157
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
VOID IPRemoveInterfaceRoute(PIP_INTERFACE IF)
Definition: ip.c:335
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
#define MmGetMdlByteCount(_Mdl)
unsigned int * PULONG
Definition: retypes.h:1
#define TDI_EVENT_CHAINED_RECEIVE_EXPEDITED
Definition: tdikrnl.h:155
unsigned int UINT
Definition: ndis.h:50
struct _TDI_REQUEST_KERNEL_RECEIVE * PTDI_REQUEST_KERNEL_RECEIVE
struct _TDI_ADDRESS_INFO * PTDI_ADDRESS_INFO
PVOID DisconnectHandlerContext
Definition: titypes.h:169
BOOLEAN TCPRemoveIRP(PCONNECTION_ENDPOINT Connection, PIRP Irp)
Definition: tcp.c:640
NTSTATUS DispTdiListen(PIRP Irp)
Definition: dispatch.c:551
VOID EXPORT NdisQueryBuffer(IN PNDIS_BUFFER Buffer, OUT PVOID *VirtualAddress OPTIONAL, OUT PUINT Length)
Definition: buffer.c:953
#define TDI_SEND_DATAGRAM
Definition: tdikrnl.h:55
PIP_INTERFACE GetDefaultInterface(VOID)
Definition: interface.c:156
struct _TRANSPORT_CONTEXT * PTRANSPORT_CONTEXT
struct tagContext Context
Definition: acpixf.h:1024
unsigned int ULONG
Definition: retypes.h:1
#define MmGetSystemAddressForMdl(Mdl)
USHORT Family
Definition: titypes.h:137
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define MIN_TRACE
Definition: debug.h:14
#define IRP_SYNCHRONOUS_API
struct _CONNECTION_ENDPOINT * Connection
Definition: titypes.h:151
PTDI_CONNECTION_INFORMATION ReturnDatagramInformation
Definition: tdikrnl.h:110
USHORT Port
Definition: titypes.h:139
struct _TDI_MAX_DATAGRAM_INFO * PTDI_MAX_DATAGRAM_INFO
TDI_STATUS InfoTdiSetInformationEx(PTDI_REQUEST Request, TDIObjectID *ID, PVOID Buffer, UINT BufferSize)
Definition: info.c:383
NTSTATUS DispTdiConnect(PIRP Irp)
Definition: dispatch.c:383
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
NTSTATUS DispTdiSendDatagram(PIRP Irp)
Definition: dispatch.c:1008
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
#define TDI_ADDRESS_LENGTH_IP
Definition: tdi.h:413
#define SOCK_STREAM
Definition: tcpip.h:118
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
PTDI_IND_RECEIVE_EXPEDITED ExpeditedReceiveHandler
Definition: titypes.h:185
return STATUS_SUCCESS
Definition: btrfs.c:2966
BOOLEAN RegisteredReceiveHandler
Definition: titypes.h:179
NTSTATUS(NTAPI * PTDI_IND_RECEIVE)(_In_opt_ PVOID TdiEventContext, _In_opt_ CONNECTION_CONTEXT ConnectionContext, _In_ ULONG ReceiveFlags, _In_ ULONG BytesIndicated, _In_ ULONG BytesAvailable, _Out_ ULONG *BytesTaken, _In_ PVOID Tsdu, _Out_opt_ PIRP *IoRequestPacket)
Definition: tdikrnl.h:225
IoMarkIrpPending(Irp)
#define STATUS_NETWORK_UNREACHABLE
Definition: ntstatus.h:690
#define memset(x, y, z)
Definition: compat.h:39
struct _TDI_REQUEST_KERNEL * PTDI_REQUEST_KERNEL
VOID DispTdiQueryInformationExComplete(PVOID Context, ULONG Status, UINT ByteCount)
Definition: dispatch.c:1273
PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint(PVOID ClientContext)
Definition: tcp.c:86
NTSTATUS DispTdiQueryInformation(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: dispatch.c:664
#define TDI_QUERY_MAX_DATAGRAM_INFO
Definition: tdi.h:187
unsigned short * PUSHORT
Definition: retypes.h:2
#define STATUS_DUPLICATE_OBJECTID
Definition: ntstatus.h:672
ULONG RequestFlags
Definition: tdikrnl.h:40
NTSTATUS IRPFinish(PIRP Irp, NTSTATUS Status)
Definition: dispatch.c:26
LONGLONG QuadPart
Definition: typedefs.h:112
IN BOOLEAN Wait
Definition: fatprocs.h:1529
NTSTATUS DispTdiDisassociateAddress(PIRP Irp)
Definition: dispatch.c:447
#define TDI_EVENT_ERROR
Definition: tdikrnl.h:148
#define TDI_CONTROL_CHANNEL_FILE
Definition: tdikrnl.h:67