home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 186 / DPCS0803.ISO / Café / Dev-C++ / devcpp4980.exe / $INSTDIR / include / ddk / tdikrnl.h < prev    next >
Encoding:
C/C++ Source or Header  |  2003-05-15  |  35.7 KB  |  1,167 lines
  1. /*
  2.  * tdikrnl.h
  3.  *
  4.  * TDI kernel mode definitions
  5.  *
  6.  * This file is part of the w32api package.
  7.  *
  8.  * Contributors:
  9.  *   Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
  10.  *
  11.  * THIS SOFTWARE IS NOT COPYRIGHTED
  12.  *
  13.  * This source code is offered for use in the public domain. You may
  14.  * use, modify or distribute it freely.
  15.  *
  16.  * This code is distributed in the hope that it will be useful but
  17.  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
  18.  * DISCLAIMED. This includes but is not limited to warranties of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  20.  *
  21.  */
  22.  
  23. #ifndef __TDIKRNL_H
  24. #define __TDIKRNL_H
  25.  
  26. #if __GNUC__ >=3
  27. #pragma GCC system_header
  28. #endif
  29.  
  30. #ifdef __cplusplus
  31. extern "C" {
  32. #endif
  33.  
  34. #pragma pack(push,4)
  35.  
  36. #include "ntddk.h"
  37. #include "tdi.h"
  38.  
  39. #if defined(_TDI_)
  40.   #define TDIKRNLAPI DECLSPEC_EXPORT
  41. #else
  42.   #define TDIKRNLAPI DECLSPEC_IMPORT
  43. #endif
  44.  
  45.  
  46. typedef struct _TDI_REQUEST_KERNEL {
  47.   ULONG  RequestFlags;
  48.   PTDI_CONNECTION_INFORMATION  RequestConnectionInformation;
  49.   PTDI_CONNECTION_INFORMATION  ReturnConnectionInformation;
  50.   PVOID  RequestSpecific;
  51. } TDI_REQUEST_KERNEL, *PTDI_REQUEST_KERNEL;
  52.  
  53. /* Request codes */
  54. #define TDI_ASSOCIATE_ADDRESS             0x01
  55. #define TDI_DISASSOCIATE_ADDRESS          0x02
  56. #define TDI_CONNECT                       0x03
  57. #define TDI_LISTEN                        0x04
  58. #define TDI_ACCEPT                        0x05
  59. #define TDI_DISCONNECT                    0x06
  60. #define TDI_SEND                          0x07
  61. #define TDI_RECEIVE                       0x08
  62. #define TDI_SEND_DATAGRAM                 0x09
  63. #define TDI_RECEIVE_DATAGRAM              0x0A
  64. #define TDI_SET_EVENT_HANDLER             0x0B
  65. #define TDI_QUERY_INFORMATION             0x0C
  66. #define TDI_SET_INFORMATION               0x0D
  67. #define TDI_ACTION                        0x0E
  68.  
  69. #define TDI_DIRECT_SEND                   0x27
  70. #define TDI_DIRECT_SEND_DATAGRAM          0x29
  71.  
  72. #define TDI_TRANSPORT_ADDRESS_FILE        1
  73. #define TDI_CONNECTION_FILE               2
  74. #define TDI_CONTROL_CHANNEL_FILE          3
  75.  
  76. /* Internal TDI IOCTLS */
  77. #define IOCTL_TDI_QUERY_DIRECT_SEND_HANDLER   _TDI_CONTROL_CODE(0x80, METHOD_NEITHER)
  78. #define IOCTL_TDI_QUERY_DIRECT_SENDDG_HANDLER _TDI_CONTROL_CODE(0x81, METHOD_NEITHER)
  79.  
  80. /* TdiAssociateAddress */
  81. typedef struct _TDI_REQUEST_KERNEL_ASSOCIATE {
  82.   HANDLE  AddressHandle;
  83. } TDI_REQUEST_KERNEL_ASSOCIATE, *PTDI_REQUEST_KERNEL_ASSOCIATE;
  84.  
  85. /* TdiDisassociateAddress */
  86. typedef TDI_REQUEST_KERNEL TDI_REQUEST_KERNEL_DISASSOCIATE,
  87.   *PTDI_REQUEST_KERNEL_DISASSOCIATE;
  88.  
  89. /* TdiAccept */
  90. typedef struct _TDI_REQUEST_KERNEL_ACCEPT {
  91.   PTDI_CONNECTION_INFORMATION  RequestConnectionInformation;
  92.   PTDI_CONNECTION_INFORMATION  ReturnConnectionInformation;
  93. } TDI_REQUEST_KERNEL_ACCEPT, *PTDI_REQUEST_KERNEL_ACCEPT;
  94.  
  95. /* TdiConnect */
  96. typedef TDI_REQUEST_KERNEL TDI_REQUEST_KERNEL_CONNECT,
  97.   *PTDI_REQUEST_KERNEL_CONNECT;
  98.  
  99. /* TdiDisconnect */
  100. typedef TDI_REQUEST_KERNEL TDI_REQUEST_KERNEL_DISCONNECT,
  101.   *PTDI_REQUEST_KERNEL_DISCONNECT;
  102.  
  103. /* TdiListen */
  104. typedef TDI_REQUEST_KERNEL TDI_REQUEST_KERNEL_LISTEN,
  105.   *PTDI_REQUEST_KERNEL_LISTEN;
  106.  
  107. /* TdiReceive */
  108. typedef struct _TDI_REQUEST_KERNEL_RECEIVE {
  109.   ULONG  ReceiveLength;
  110.   ULONG  ReceiveFlags;
  111. } TDI_REQUEST_KERNEL_RECEIVE, *PTDI_REQUEST_KERNEL_RECEIVE;
  112.  
  113. /* TdiReceiveDatagram */
  114. typedef struct _TDI_REQUEST_KERNEL_RECEIVEDG {
  115.   ULONG  ReceiveLength;
  116.   PTDI_CONNECTION_INFORMATION  ReceiveDatagramInformation;
  117.   PTDI_CONNECTION_INFORMATION  ReturnDatagramInformation;
  118.   ULONG  ReceiveFlags;
  119. } TDI_REQUEST_KERNEL_RECEIVEDG, *PTDI_REQUEST_KERNEL_RECEIVEDG;
  120.  
  121. /* TdiSend */
  122. typedef struct _TDI_REQUEST_KERNEL_SEND {
  123.   ULONG  SendLength;
  124.   ULONG  SendFlags;
  125. } TDI_REQUEST_KERNEL_SEND, *PTDI_REQUEST_KERNEL_SEND;
  126.  
  127. /* TdiSendDatagram */
  128. typedef struct _TDI_REQUEST_KERNEL_SENDDG {
  129.   ULONG  SendLength;
  130.   PTDI_CONNECTION_INFORMATION  SendDatagramInformation;
  131. } TDI_REQUEST_KERNEL_SENDDG, *PTDI_REQUEST_KERNEL_SENDDG;
  132.  
  133. /* TdiSetEventHandler */
  134. typedef struct _TDI_REQUEST_KERNEL_SET_EVENT {
  135.   LONG  EventType;
  136.   PVOID  EventHandler;
  137.   PVOID  EventContext;
  138. } TDI_REQUEST_KERNEL_SET_EVENT, *PTDI_REQUEST_KERNEL_SET_EVENT;
  139.  
  140. /* TdiQueryInformation */
  141. typedef struct _TDI_REQUEST_KERNEL_QUERY_INFO {
  142.   LONG  QueryType;
  143.   PTDI_CONNECTION_INFORMATION  RequestConnectionInformation;
  144. } TDI_REQUEST_KERNEL_QUERY_INFORMATION, *PTDI_REQUEST_KERNEL_QUERY_INFORMATION;
  145.  
  146. /* TdiSetInformation */
  147. typedef struct _TDI_REQUEST_KERNEL_SET_INFO {
  148.   LONG  SetType;
  149.   PTDI_CONNECTION_INFORMATION  RequestConnectionInformation;
  150. } TDI_REQUEST_KERNEL_SET_INFORMATION, *PTDI_REQUEST_KERNEL_SET_INFORMATION;
  151.  
  152.  
  153. /* Event types */
  154. #define TDI_EVENT_CONNECT                   0
  155. #define TDI_EVENT_DISCONNECT                1
  156. #define TDI_EVENT_ERROR                     2
  157. #define TDI_EVENT_RECEIVE                   3
  158. #define TDI_EVENT_RECEIVE_DATAGRAM          4
  159. #define TDI_EVENT_RECEIVE_EXPEDITED         5
  160. #define TDI_EVENT_SEND_POSSIBLE             6
  161. #define TDI_EVENT_CHAINED_RECEIVE           7
  162. #define TDI_EVENT_CHAINED_RECEIVE_DATAGRAM  8
  163. #define TDI_EVENT_CHAINED_RECEIVE_EXPEDITED 9
  164. #define TDI_EVENT_ERROR_EX                  10
  165.  
  166. typedef NTSTATUS DDKAPI
  167. (*PTDI_IND_CONNECT)(
  168.   IN PVOID  TdiEventContext,
  169.   IN LONG  RemoteAddressLength,
  170.   IN PVOID  RemoteAddress,
  171.   IN LONG  UserDataLength,
  172.   IN PVOID  UserData,
  173.   IN LONG  OptionsLength,
  174.   IN PVOID  Options,
  175.   OUT CONNECTION_CONTEXT  *ConnectionContext,
  176.   OUT PIRP  *AcceptIrp);
  177.  
  178. TDIKRNLAPI
  179. NTSTATUS
  180. DDKAPI
  181. TdiDefaultConnectHandler(
  182.   IN PVOID  TdiEventContext,
  183.   IN LONG  RemoteAddressLength,
  184.   IN PVOID  RemoteAddress,
  185.   IN LONG  UserDataLength,
  186.   IN PVOID  UserData,
  187.   IN LONG  OptionsLength,
  188.   IN PVOID  Options,
  189.   OUT CONNECTION_CONTEXT *ConnectionContext,
  190.   OUT PIRP  *AcceptIrp);
  191.  
  192. typedef NTSTATUS DDKAPI
  193. (*PTDI_IND_DISCONNECT)(
  194.   IN PVOID  TdiEventContext,
  195.   IN CONNECTION_CONTEXT  ConnectionContext,
  196.   IN LONG  DisconnectDataLength,
  197.   IN PVOID  DisconnectData,
  198.   IN LONG  DisconnectInformationLength,
  199.   IN PVOID  DisconnectInformation,
  200.   IN ULONG  DisconnectFlags);
  201.  
  202. TDIKRNLAPI
  203. NTSTATUS
  204. DDKAPI
  205. TdiDefaultDisconnectHandler(
  206.   IN PVOID  TdiEventContext,
  207.   IN CONNECTION_CONTEXT  ConnectionContext,
  208.   IN LONG  DisconnectDataLength,
  209.   IN PVOID  DisconnectData,
  210.   IN LONG  DisconnectInformationLength,
  211.   IN PVOID  DisconnectInformation,
  212.   IN ULONG  DisconnectFlags);
  213.  
  214. typedef NTSTATUS DDKAPI
  215. (*PTDI_IND_ERROR)(
  216.   IN PVOID  TdiEventContext,
  217.   IN NTSTATUS  Status);
  218.  
  219. typedef NTSTATUS DDKAPI
  220. (*PTDI_IND_ERROR_EX)(
  221.   IN PVOID  TdiEventContext,
  222.   IN NTSTATUS  Status,
  223.   IN PVOID  Buffer);
  224.  
  225. TDIKRNLAPI
  226. NTSTATUS
  227. DDKAPI
  228. TdiDefaultErrorHandler(
  229.   IN PVOID  TdiEventContext,
  230.   IN NTSTATUS  Status);
  231.  
  232. typedef NTSTATUS DDKAPI
  233. (*PTDI_IND_RECEIVE)(
  234.   IN PVOID  TdiEventContext,
  235.   IN CONNECTION_CONTEXT  ConnectionContext,
  236.   IN ULONG  ReceiveFlags,
  237.   IN ULONG  BytesIndicated,
  238.   IN ULONG  BytesAvailable,
  239.   OUT ULONG  *BytesTaken,
  240.   IN PVOID  Tsdu,
  241.   OUT PIRP  *IoRequestPacket);
  242.  
  243. TDIKRNLAPI
  244. NTSTATUS
  245. DDKAPI
  246. TdiDefaultReceiveHandler(
  247.   IN PVOID  TdiEventContext,
  248.   IN CONNECTION_CONTEXT  ConnectionContext,
  249.   IN ULONG  ReceiveFlags,
  250.   IN ULONG  BytesIndicated,
  251.   IN ULONG  BytesAvailable,
  252.   OUT ULONG  *BytesTaken,
  253.   IN PVOID  Tsdu,
  254.   OUT PIRP  *IoRequestPacket);
  255.  
  256. typedef NTSTATUS DDKAPI
  257. (*PTDI_IND_RECEIVE_DATAGRAM)(
  258.   IN PVOID  TdiEventContext,
  259.   IN LONG  SourceAddressLength,
  260.   IN PVOID  SourceAddress,
  261.   IN LONG  OptionsLength,
  262.   IN PVOID  Options,
  263.   IN ULONG  ReceiveDatagramFlags,
  264.   IN ULONG  BytesIndicated,
  265.   IN ULONG  BytesAvailable,
  266.   OUT ULONG  *BytesTaken,
  267.   IN PVOID  Tsdu,
  268.   OUT PIRP  *IoRequestPacket);
  269.  
  270. TDIKRNLAPI
  271. NTSTATUS DDKAPI
  272. TdiDefaultRcvDatagramHandler(
  273.   IN PVOID  TdiEventContext,
  274.   IN LONG  SourceAddressLength,
  275.   IN PVOID  SourceAddress,
  276.   IN LONG  OptionsLength,
  277.   IN PVOID  Options,
  278.   IN ULONG  ReceiveDatagramFlags,
  279.   IN ULONG  BytesIndicated,
  280.   IN ULONG  BytesAvailable,
  281.   OUT ULONG  *BytesTaken,
  282.   IN PVOID  Tsdu,
  283.   OUT PIRP  *IoRequestPacket);
  284.  
  285. typedef NTSTATUS DDKAPI
  286. (*PTDI_IND_RECEIVE_EXPEDITED)(
  287.   IN PVOID  TdiEventContext,
  288.   IN CONNECTION_CONTEXT  ConnectionContext,
  289.   IN ULONG  ReceiveFlags,
  290.   IN ULONG  BytesIndicated,
  291.   IN ULONG  BytesAvailable,
  292.   OUT ULONG  *BytesTaken,
  293.   IN PVOID  Tsdu,
  294.   OUT PIRP  *IoRequestPacket);
  295.  
  296. TDIKRNLAPI
  297. NTSTATUS
  298. DDKAPI
  299. TdiDefaultRcvExpeditedHandler(
  300.   IN PVOID  TdiEventContext,
  301.   IN CONNECTION_CONTEXT  ConnectionContext,
  302.   IN ULONG  ReceiveFlags,
  303.   IN ULONG  BytesIndicated,
  304.   IN ULONG  BytesAvailable,
  305.   OUT ULONG  *BytesTaken,
  306.   IN PVOID  Tsdu,
  307.   OUT PIRP  *IoRequestPacket);
  308.  
  309. typedef NTSTATUS DDKAPI
  310. (*PTDI_IND_CHAINED_RECEIVE)(
  311.   IN PVOID  TdiEventContext,
  312.   IN CONNECTION_CONTEXT  ConnectionContext,
  313.   IN ULONG  ReceiveFlags,
  314.   IN ULONG  ReceiveLength,
  315.   IN ULONG  StartingOffset,
  316.   IN PMDL  Tsdu,
  317.   IN PVOID  TsduDescriptor);
  318.  
  319. TDIKRNLAPI
  320. NTSTATUS
  321. DDKAPI
  322. TdiDefaultChainedReceiveHandler(
  323.   IN PVOID  TdiEventContext,
  324.   IN CONNECTION_CONTEXT  ConnectionContext,
  325.   IN ULONG  ReceiveFlags,
  326.   IN ULONG  ReceiveLength,
  327.   IN ULONG  StartingOffset,
  328.   IN PMDL  Tsdu,
  329.   IN PVOID  TsduDescriptor);
  330.  
  331. typedef NTSTATUS DDKAPI
  332. (*PTDI_IND_CHAINED_RECEIVE_DATAGRAM)(
  333.   IN PVOID  TdiEventContext,
  334.   IN LONG  SourceAddressLength,
  335.   IN PVOID  SourceAddress,
  336.   IN LONG  OptionsLength,
  337.   IN PVOID  Options,
  338.   IN ULONG  ReceiveDatagramFlags,
  339.   IN ULONG  ReceiveDatagramLength,
  340.   IN ULONG  StartingOffset,
  341.   IN PMDL  Tsdu,
  342.   IN PVOID  TsduDescriptor);
  343.  
  344. TDIKRNLAPI
  345. NTSTATUS
  346. DDKAPI
  347. TdiDefaultChainedRcvDatagramHandler(
  348.   IN PVOID  TdiEventContext,
  349.   IN LONG  SourceAddressLength,
  350.   IN PVOID  SourceAddress,
  351.   IN LONG  OptionsLength,
  352.   IN PVOID  Options,
  353.   IN ULONG  ReceiveDatagramFlags,
  354.   IN ULONG  ReceiveDatagramLength,
  355.   IN ULONG  StartingOffset,
  356.   IN PMDL  Tsdu,
  357.   IN PVOID  TsduDescriptor);
  358.  
  359. typedef NTSTATUS DDKAPI
  360. (*PTDI_IND_CHAINED_RECEIVE_EXPEDITED)(
  361.   IN PVOID  TdiEventContext,
  362.   IN CONNECTION_CONTEXT  ConnectionContext,
  363.   IN ULONG  ReceiveFlags,
  364.   IN ULONG  ReceiveLength,
  365.   IN ULONG  StartingOffset,
  366.   IN PMDL  Tsdu,
  367.   IN PVOID  TsduDescriptor);
  368.  
  369. TDIKRNLAPI
  370. NTSTATUS
  371. DDKAPI
  372. TdiDefaultChainedRcvExpeditedHandler(
  373.   IN PVOID  TdiEventContext,
  374.   IN CONNECTION_CONTEXT  ConnectionContext,
  375.   IN ULONG  ReceiveFlags,
  376.   IN ULONG  ReceiveLength,
  377.   IN ULONG  StartingOffset,
  378.   IN PMDL  Tsdu,
  379.   IN PVOID  TsduDescriptor);
  380.  
  381. typedef NTSTATUS DDKAPI
  382. (*PTDI_IND_SEND_POSSIBLE)(
  383.   IN PVOID  TdiEventContext,
  384.   IN PVOID  ConnectionContext,
  385.   IN ULONG  BytesAvailable);
  386.  
  387. TDIKRNLAPI
  388. NTSTATUS
  389. DDKAPI
  390. TdiDefaultSendPossibleHandler(
  391.   IN PVOID  TdiEventContext,
  392.   IN PVOID  ConnectionContext,
  393.   IN ULONG  BytesAvailable);
  394.  
  395.  
  396.  
  397. /* Macros and functions to build IRPs */
  398.  
  399. #define TdiBuildBaseIrp(                                                  \
  400.   bIrp, bDevObj, bFileObj, bCompRoutine, bContxt, bIrpSp, bMinor)         \
  401. {                                                                         \
  402.   bIrpSp->MajorFunction = IRP_MJ_INTERNAL_DEVICE_CONTROL;                 \
  403.   bIrpSp->MinorFunction = (bMinor);                                       \
  404.   bIrpSp->DeviceObject  = (bDevObj);                                      \
  405.   bIrpSp->FileObject    = (bFileObj);                                     \
  406.   if (bCompRoutine)                                                       \
  407.     IoSetCompletionRoutine(bIrp, bCompRoutine, bContxt, TRUE, TRUE, TRUE) \
  408.   else                                                                    \
  409.     IoSetCompletionRoutine(bIrp, NULL, NULL, FALSE, FALSE, FALSE);        \
  410. }
  411.  
  412. /*
  413.  * VOID
  414.  * TdiBuildAccept(
  415.  *   IN PIRP  Irp,
  416.  *   IN PDEVICE_OBJECT  DevObj,
  417.  *   IN PFILE_OBJECT  FileObj,
  418.  *   IN PVOID  CompRoutine,
  419.  *   IN PVOID  Contxt,
  420.  *   IN PTDI_CONNECTION_INFORMATION  RequestConnectionInfo,
  421.  *   OUT PTDI_CONNECTION_INFORMATION  ReturnConnectionInfo);
  422.  */
  423. #define TdiBuildAccept(                                             \
  424.   Irp, DevObj, FileObj, CompRoutine, Contxt,                        \
  425.   RequestConnectionInfo, ReturnConnectionInfo)                      \
  426. {                                                                   \
  427.   PTDI_REQUEST_KERNEL_ACCEPT _Request;                              \
  428.   PIO_STACK_LOCATION _IrpSp;                                        \
  429.                                                                     \
  430.   _IrpSp = IoGetNextIrpStackLocation(Irp);                          \
  431.                                                                     \
  432.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                \
  433.                   Contxt, _IrpSp, TDI_ACCEPT);                      \
  434.                                                                     \
  435.   _Request = (PTDI_REQUEST_KERNEL_ACCEPT)&_IrpSp->Parameters;       \
  436.   _Request->RequestConnectionInformation = (RequestConnectionInfo); \
  437.   _Request->ReturnConnectionInformation  = (ReturnConnectionInfo);  \
  438. }
  439.  
  440. /*
  441.  * VOID
  442.  * TdiBuildAction(
  443.  *   IN PIRP  Irp,
  444.  *   IN PDEVICE_OBJECT  DevObj,
  445.  *   IN PFILE_OBJECT  FileObj,
  446.  *   IN PVOID  CompRoutine,
  447.  *   IN PVOID  Contxt,
  448.  *   IN PMDL  MdlAddr);
  449.  */
  450. #define TdiBuildAction(                               \
  451.   Irp, DevObj, FileObj, CompRoutine, Contxt, MdlAddr) \
  452. {                                                     \
  453.   PIO_STACK_LOCATION _IrpSp;                          \
  454.                                                       \
  455.   _IrpSp = IoGetNextIrpStackLocation(Irp);            \
  456.                                                       \
  457.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,  \
  458.                   Contxt, _IrpSp, TDI_ACTION);        \
  459.                                                       \
  460.   (Irp)->MdlAddress = (MdlAddr);                      \
  461. }
  462.  
  463. /*
  464.  * VOID
  465.  * TdiBuildAssociateAddress(
  466.  *   IN PIRP  Irp,
  467.  *   IN PDEVICE_OBJECT  DevObj,
  468.  *   IN PFILE_OBJECT  FileObj,
  469.  *   IN PVOID  CompRoutine,
  470.  *   IN PVOID  Contxt,
  471.  *   IN HANDLE  AddrHandle);
  472.  */
  473. #define TdiBuildAssociateAddress(                                \
  474.   Irp, DevObj, FileObj, CompRoutine, Contxt, AddrHandle)         \
  475. {                                                                \
  476.   PTDI_REQUEST_KERNEL_ASSOCIATE _Request;                        \
  477.   PIO_STACK_LOCATION _IrpSp;                                     \
  478.                                                                  \
  479.   _IrpSp = IoGetNextIrpStackLocation(Irp);                       \
  480.                                                                  \
  481.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,             \
  482.                   Contxt, _IrpSp, TDI_ASSOCIATE_ADDRESS);        \
  483.                                                                  \
  484.   _Request = (PTDI_REQUEST_KERNEL_ASSOCIATE)&_IrpSp->Parameters; \
  485.   _Request->AddressHandle = (HANDLE)(AddrHandle);                \
  486. }
  487.  
  488. /*
  489.  * VOID
  490.  * TdiBuildConnect(
  491.  *   IN PIRP  Irp,
  492.  *   IN PDEVICE_OBJECT  DevObj,
  493.  *   IN PFILE_OBJECT  FileObj,
  494.  *   IN PVOID  CompRoutine,
  495.  *   IN PVOID  Contxt,
  496.  *   IN PLARGE_INTEGER  Time,
  497.  *   IN PTDI_CONNECTION_INFORMATION  RequestConnectionInfo,
  498.  *   OUT PTDI_CONNECTION_INFORMATION  ReturnConnectionInfo); 
  499.  */
  500. #define TdiBuildConnect(                                            \
  501.   Irp, DevObj, FileObj, CompRoutine, Contxt,                        \
  502.   Time, RequestConnectionInfo, ReturnConnectionInfo)                \
  503. {                                                                   \
  504.   PTDI_REQUEST_KERNEL _Request;                                     \
  505.   PIO_STACK_LOCATION _IrpSp;                                        \
  506.                                                                     \
  507.   _IrpSp = IoGetNextIrpStackLocation(Irp);                          \
  508.                                                                     \
  509.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                \
  510.                   Contxt, _IrpSp, TDI_CONNECT);                     \
  511.                                                                     \
  512.   _Request = (PTDI_REQUEST_KERNEL)&_IrpSp->Parameters;              \
  513.   _Request->RequestConnectionInformation = (RequestConnectionInfo); \
  514.   _Request->ReturnConnectionInformation  = (ReturnConnectionInfo);  \
  515.   _Request->RequestSpecific              = (PVOID)(Time);           \
  516. }
  517.  
  518. /*
  519.  * VOID
  520.  * TdiBuildDisassociateAddress(
  521.  *   IN PIRP  Irp,
  522.  *   IN PDEVICE_OBJECT  DevObj,
  523.  *   IN PFILE_OBJECT  FileObj,
  524.  *   IN PVOID  CompRoutine,
  525.  *   IN PVOID  Contxt);
  526.  */
  527. #define TdiBuildDisassociateAddress(                                \
  528.   Irp, DevObj, FileObj, CompRoutine, Contxt)                        \
  529. {                                                                   \
  530.   PIO_STACK_LOCATION _IrpSp;                                        \
  531.                                                                     \
  532.   _IrpSp = IoGetNextIrpStackLocation(Irp);                          \
  533.                                                                     \
  534.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                \
  535.                   Contxt, _IrpSp, TDI_DISASSOCIATE_ADDRESS);        \
  536. }
  537.  
  538. /*
  539.  * VOID
  540.  * TdiBuildDisconnect(
  541.  *   IN PIRP  Irp,
  542.  *   IN PDEVICE_OBJECT  DevObj,
  543.  *   IN PFILE_OBJECT  FileObj,
  544.  *   IN PVOID  CompRoutine,
  545.  *   IN PVOID  Contxt,
  546.  *   IN PLARGE_INTEGER  Time,
  547.  *   IN PULONG  Flags,
  548.  *   IN PTDI_CONNECTION_INFORMATION  RequestConnectionInfo,
  549.  *   OUT PTDI_CONNECTION_INFORMATION  ReturnConnectionInfo); 
  550.  */
  551. #define TdiBuildDisconnect(                                         \
  552.   Irp, DevObj, FileObj, CompRoutine, Contxt, Time,                  \
  553.   Flags, RequestConnectionInfo, ReturnConnectionInfo)               \
  554. {                                                                   \
  555.   PTDI_REQUEST_KERNEL _Request;                                     \
  556.   PIO_STACK_LOCATION _IrpSp;                                        \
  557.                                                                     \
  558.   _IrpSp = IoGetNextIrpStackLocation(Irp);                          \
  559.                                                                     \
  560.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                \
  561.                   Contxt, _IrpSp, TDI_DISCONNECT);                  \
  562.                                                                     \
  563.   _Request = (PTDI_REQUEST_KERNEL)&_IrpSp->Parameters;              \
  564.   _Request->RequestConnectionInformation = (RequestConnectionInfo); \
  565.   _Request->ReturnConnectionInformation  = (ReturnConnectionInfo);  \
  566.   _Request->RequestSpecific = (PVOID)(Time);                        \
  567.   _Request->RequestFlags    = (Flags);                              \
  568. }
  569.  
  570. /*
  571.  * PIRP
  572.  * TdiBuildInternalDeviceControlIrp(
  573.  *   IN CCHAR IrpSubFunction,
  574.  *   IN PDEVICE_OBJECT DeviceObject,
  575.  *   IN PFILE_OBJECT FileObject,
  576.  *   IN PKEVENT Event,
  577.  *   IN PIO_STATUS_BLOCK IoStatusBlock);
  578.  */
  579. #define TdiBuildInternalDeviceControlIrp( \
  580.   IrpSubFunction, DeviceObject,           \
  581.   FileObject, Event, IoStatusBlock)       \
  582.   IoBuildDeviceIoControlRequest(          \
  583.         0x00000003, DeviceObject,             \
  584.         NULL, 0, NULL, 0,                     \
  585.         TRUE, Event, IoStatusBlock)
  586.  
  587. /*
  588.  * VOID
  589.  * TdiBuildListen(
  590.  *   IN PIRP  Irp,
  591.  *   IN PDEVICE_OBJECT  DevObj,
  592.  *   IN PFILE_OBJECT  FileObj,
  593.  *   IN PVOID  CompRoutine,
  594.  *   IN PVOID  Contxt,
  595.  *   IN ULONG  Flags,
  596.  *   IN PTDI_CONNECTION_INFORMATION  RequestConnectionInfo,
  597.  *   OUT PTDI_CONNECTION_INFORMATION  ReturnConnectionInfo); 
  598.  */
  599. #define TdiBuildListen(                                             \
  600.   Irp, DevObj, FileObj, CompRoutine, Contxt,                        \
  601.   Flags, RequestConnectionInfo, ReturnConnectionInfo)               \
  602. {                                                                   \
  603.   PTDI_REQUEST_KERNEL _Request;                                     \
  604.   PIO_STACK_LOCATION _IrpSp;                                        \
  605.                                                                     \
  606.   _IrpSp = IoGetNextIrpStackLocation(Irp);                          \
  607.                                                                     \
  608.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                \
  609.                   Contxt, _IrpSp, TDI_LISTEN);                      \
  610.                                                                     \
  611.   _Request = (PTDI_REQUEST_KERNEL)&_IrpSp->Parameters;              \
  612.   _Request->RequestConnectionInformation = (RequestConnectionInfo); \
  613.   _Request->ReturnConnectionInformation  = (ReturnConnectionInfo);  \
  614.   _Request->RequestFlags = (Flags);                                 \
  615. }
  616.  
  617. TDIKRNLAPI
  618. VOID
  619. DDKAPI
  620. TdiBuildNetbiosAddress(
  621.     IN PUCHAR  NetbiosName,
  622.     IN BOOLEAN  IsGroupName,
  623.     IN OUT PTA_NETBIOS_ADDRESS  NetworkName);
  624.  
  625. TDIKRNLAPI
  626. NTSTATUS
  627. DDKAPI
  628. TdiBuildNetbiosAddressEa(
  629.   IN PUCHAR  Buffer,
  630.   IN BOOLEAN  IsGroupName,
  631.   IN PUCHAR  NetbiosName);
  632.  
  633. /*
  634.  * VOID
  635.  * TdiBuildQueryInformation(
  636.  *   IN PIRP  Irp,
  637.  *   IN PDEVICE_OBJECT  DevObj,
  638.  *   IN PFILE_OBJECT  FileObj,
  639.  *   IN PVOID  CompRoutine,
  640.  *   IN PVOID  Contxt,
  641.  *   IN UINT  QType,
  642.  *   IN PMDL  MdlAddr);
  643.  */
  644. #define TdiBuildQueryInformation(                                        \
  645.   Irp, DevObj, FileObj, CompRoutine, Contxt, QType, MdlAddr)             \
  646. {                                                                        \
  647.   PTDI_REQUEST_KERNEL_QUERY_INFORMATION _Request;                        \
  648.   PIO_STACK_LOCATION _IrpSp;                                             \
  649.                                                                          \
  650.   _IrpSp = IoGetNextIrpStackLocation(Irp);                               \
  651.                                                                          \
  652.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                     \
  653.                   Contxt, _IrpSp, TDI_QUERY_INFORMATION);                \
  654.                                                                          \
  655.   _Request = (PTDI_REQUEST_KERNEL_QUERY_INFORMATION)&_IrpSp->Parameters; \
  656.   _Request->RequestConnectionInformation = NULL;                         \
  657.   _Request->QueryType = (ULONG)(QType);                                  \
  658.   (Irp)->MdlAddress   = (MdlAddr);                                       \
  659. }
  660.  
  661. /*
  662.  * VOID
  663.  * TdiBuildReceive(
  664.  *   IN PIRP  Irp,
  665.  *   IN PDEVICE_OBJECT  DevObj,
  666.  *   IN PFILE_OBJECT  FileObj,
  667.  *   IN PVOID  CompRoutine,
  668.  *   IN PVOID  Contxt,
  669.  *   IN PMDL  MdlAddr,
  670.  *   IN ULONG  InFlags, 
  671.  *   IN ULONG  ReceiveLen); 
  672.  */
  673. #define TdiBuildReceive(                                       \
  674.   Irp, DevObj, FileObj, CompRoutine, Contxt,                   \
  675.   MdlAddr, InFlags, ReceiveLen)                                \
  676. {                                                              \
  677.   PTDI_REQUEST_KERNEL_RECEIVE _Request;                        \
  678.   PIO_STACK_LOCATION _IrpSp;                                   \
  679.                                                                \
  680.   _IrpSp = IoGetNextIrpStackLocation(Irp);                     \
  681.                                                                \
  682.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,           \
  683.                   Contxt, _IrpSp, TDI_RECEIVE);                \
  684.                                                                \
  685.   _Request = (PTDI_REQUEST_KERNEL_RECEIVE)&_IrpSp->Parameters; \
  686.   _Request->ReceiveFlags  = (InFlags);                         \
  687.   _Request->ReceiveLength = (ReceiveLen);                      \
  688.   (Irp)->MdlAddress       = (MdlAddr);                         \
  689. }
  690.  
  691. /*
  692.  * VOID
  693.  * TdiBuildReceiveDatagram(
  694.  *   IN PIRP  Irp,
  695.  *   IN PDEVICE_OBJECT  DevObj,
  696.  *   IN PFILE_OBJECT  FileObj,
  697.  *   IN PVOID  CompRoutine,
  698.  *   IN PVOID  Contxt,
  699.  *   IN PMDL  MdlAddr,
  700.  *   IN ULONG  ReceiveLen,
  701.  *   IN PTDI_CONNECTION_INFORMATION  ReceiveDatagramInfo,
  702.  *   OUT PTDI_CONNECTION_INFORMATION  ReturnInfo,
  703.  *   ULONG InFlags); 
  704.  */
  705. #define TdiBuildReceiveDatagram(                                 \
  706.   Irp, DevObj, FileObj, CompRoutine, Contxt, MdlAddr,            \
  707.   ReceiveLen, ReceiveDatagramInfo, ReturnInfo, InFlags)          \
  708. {                                                                \
  709.   PTDI_REQUEST_KERNEL_RECEIVEDG _Request;                        \
  710.   PIO_STACK_LOCATION _IrpSp;                                     \
  711.                                                                  \
  712.   _IrpSp = IoGetNextIrpStackLocation(Irp);                       \
  713.                                                                  \
  714.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,             \
  715.                   Contxt, _IrpSp, TDI_RECEIVE_DATAGRAM);         \
  716.                                                                  \
  717.   _Request = (PTDI_REQUEST_KERNEL_RECEIVEDG)&_IrpSp->Parameters; \
  718.   _Request->ReceiveDatagramInformation = (ReceiveDatagramInfo);  \
  719.   _Request->ReturnDatagramInformation  = (ReturnInfo);           \
  720.   _Request->ReceiveLength = (ReceiveLen);                        \
  721.   _Request->ReceiveFlags  = (InFlags);                           \
  722.   (Irp)->MdlAddress       = (MdlAddr);                           \
  723. }
  724.  
  725. /*
  726.  * VOID
  727.  * TdiBuildSend(
  728.  *   IN PIRP  Irp,
  729.  *   IN PDEVICE_OBJECT  DevObj,
  730.  *   IN PFILE_OBJECT  FileObj,
  731.  *   IN PVOID  CompRoutine,
  732.  *   IN PVOID  Contxt,
  733.  *   IN PMDL  MdlAddr,
  734.  *   IN ULONG  InFlags,
  735.  *   IN ULONG  SendLen);
  736.  */
  737. #define TdiBuildSend(                                       \
  738.   Irp, DevObj, FileObj, CompRoutine, Contxt,                \
  739.   MdlAddr, InFlags, SendLen)                                \
  740. {                                                           \
  741.   PTDI_REQUEST_KERNEL_SEND _Request;                        \
  742.   PIO_STACK_LOCATION _IrpSp;                                \
  743.                                                             \
  744.   _IrpSp = IoGetNextIrpStackLocation(Irp);                  \
  745.                                                             \
  746.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,        \
  747.                   Contxt, _IrpSp, TDI_SEND);                \
  748.                                                             \
  749.   _Request = (PTDI_REQUEST_KERNEL_SEND)&_IrpSp->Parameters; \
  750.   _Request->SendFlags  = (InFlags);                         \
  751.   _Request->SendLength = (SendLen);                         \
  752.   (Irp)->MdlAddress    = (MdlAddr);                         \
  753. }
  754.  
  755. /*
  756.  * VOID
  757.  * TdiBuildSendDatagram(
  758.  *   IN PIRP  Irp,
  759.  *   IN PDEVICE_OBJECT  DevObj,
  760.  *   IN PFILE_OBJECT  FileObj,
  761.  *   IN PVOID  CompRoutine,
  762.  *   IN PVOID  Contxt,
  763.  *   IN PMDL  MdlAddr,
  764.  *   IN ULONG  SendLen,
  765.  *   IN PTDI_CONNECTION_INFORMATION  SendDatagramInfo); 
  766.  */
  767. #define TdiBuildSendDatagram(                                 \
  768.   Irp, DevObj, FileObj, CompRoutine, Contxt,                  \
  769.   MdlAddr, SendLen, SendDatagramInfo)                         \
  770. {                                                             \
  771.   PTDI_REQUEST_KERNEL_SENDDG _Request;                        \
  772.   PIO_STACK_LOCATION _IrpSp;                                  \
  773.                                                               \
  774.   _IrpSp = IoGetNextIrpStackLocation(Irp);                    \
  775.                                                               \
  776.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,          \
  777.                   Contxt, _IrpSp, TDI_SEND_DATAGRAM);         \
  778.                                                               \
  779.   _Request = (PTDI_REQUEST_KERNEL_SENDDG)&_IrpSp->Parameters; \
  780.   _Request->SendDatagramInformation = (SendDatagramInfo);     \
  781.   _Request->SendLength = (SendLen);                           \
  782.   (Irp)->MdlAddress    = (MdlAddr);                           \
  783. }
  784.  
  785. /*
  786.  * VOID
  787.  * TdiBuildSetEventHandler(
  788.  *   IN PIRP  Irp,
  789.  *   IN PDEVICE_OBJECT  DevObj,
  790.  *   IN PFILE_OBJECT  FileObj,
  791.  *   IN PVOID  CompRoutine,
  792.  *   IN PVOID  Contxt,
  793.  *   IN INT  InEventType,
  794.  *   IN PVOID  InEventHandler,
  795.  *   IN PVOID  InEventContext);
  796.  */
  797. #define TdiBuildSetEventHandler(                                 \
  798.   Irp, DevObj, FileObj, CompRoutine, Contxt,                     \
  799.   InEventType, InEventHandler, InEventContext)                   \
  800. {                                                                \
  801.   PTDI_REQUEST_KERNEL_SET_EVENT _Request;                        \
  802.   PIO_STACK_LOCATION _IrpSp;                                     \
  803.                                                                  \
  804.   _IrpSp = IoGetNextIrpStackLocation(Irp);                       \
  805.                                                                  \
  806.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,             \
  807.                   Contxt, _IrpSp, TDI_SET_EVENT_HANDLER);        \
  808.                                                                  \
  809.   _Request = (PTDI_REQUEST_KERNEL_SET_EVENT)&_IrpSp->Parameters; \
  810.   _Request->EventType    = (InEventType);                        \
  811.   _Request->EventHandler = (PVOID)(InEventHandler);              \
  812.   _Request->EventContext = (PVOID)(InEventContext);              \
  813. }
  814.  
  815. /*
  816.  * VOID
  817.  * TdiBuildSetInformation(
  818.  *   IN PIRP  Irp,
  819.  *   IN PDEVICE_OBJECT  DevObj,
  820.  *   IN PFILE_OBJECT  FileObj,
  821.  *   IN PVOID  CompRoutine,
  822.  *   IN PVOID  Contxt,
  823.  *   IN UINT  SType,
  824.  *   IN PMDL  MdlAddr);
  825.  */
  826. #define TdiBuildSetInformation(                                        \
  827.   Irp, DevObj, FileObj, CompRoutine, Contxt, SType, MdlAddr)           \
  828. {                                                                      \
  829.   PTDI_REQUEST_KERNEL_SET_INFORMATION _Request;                        \
  830.   PIO_STACK_LOCATION _IrpSp;                                           \
  831.                                                                        \
  832.   _IrpSp = IoGetNextIrpStackLocation(Irp);                             \
  833.                                                                        \
  834.   TdiBuildBaseIrp(Irp, DevObj, FileObj, CompRoutine,                   \
  835.                   Contxt, _IrpSp, TDI_SET_INFORMATION);                \
  836.                                                                        \
  837.   _Request = (PTDI_REQUEST_KERNEL_SET_INFORMATION)&_IrpSp->Parameters; \
  838.   _Request->RequestConnectionInformation = NULL;                       \
  839.   _Request->SetType = (ULONG)(SType);                                  \
  840.   (Irp)->MdlAddress = (MdlAddr);                                       \
  841. }
  842.  
  843. /* TDI20_CLIENT_INTERFACE_INFO.TdiVersion constants */
  844. #define TDI_CURRENT_MAJOR_VERSION         2
  845. #define TDI_CURRENT_MINOR_VERSION         0
  846.  
  847. #define TDI_CURRENT_VERSION ((TDI_CURRENT_MINOR_VERSION) << 8 \
  848.   | (TDI_CURRENT_MAJOR_VERSION))
  849.  
  850. #define TDI_VERSION_ONE                   0x0001
  851.  
  852. typedef enum _TDI_PNP_OPCODE {
  853.   TDI_PNP_OP_MIN,
  854.   TDI_PNP_OP_ADD,
  855.   TDI_PNP_OP_DEL,
  856.   TDI_PNP_OP_UPDATE,
  857.   TDI_PNP_OP_PROVIDERREADY,
  858.   TDI_PNP_OP_NETREADY,
  859.   TDI_PNP_OP_ADD_IGNORE_BINDING,
  860.   TDI_PNP_OP_DELETE_IGNORE_BINDING,
  861.   TDI_PNP_OP_MAX,
  862. } TDI_PNP_OPCODE;
  863.  
  864. /* TDI_PNP_CONTEXT.ContextType */
  865. #define TDI_PNP_CONTEXT_TYPE_IF_NAME            0x1
  866. #define TDI_PNP_CONTEXT_TYPE_IF_ADDR            0x2
  867. #define TDI_PNP_CONTEXT_TYPE_PDO                0x3
  868. #define TDI_PNP_CONTEXT_TYPE_FIRST_OR_LAST_IF   0x4
  869.  
  870. typedef struct _TDI_PNP_CONTEXT {
  871.   USHORT  ContextSize;
  872.   USHORT  ContextType;
  873.   UCHAR  ContextData[1];
  874. } TDI_PNP_CONTEXT, *PTDI_PNP_CONTEXT;
  875.  
  876. typedef VOID DDKAPI
  877. (*TDI_ADD_ADDRESS_HANDLER)(
  878.   IN PTA_ADDRESS  Address);
  879.  
  880. typedef VOID DDKAPI
  881. (*TDI_ADD_ADDRESS_HANDLER_V2)(
  882.   IN PTA_ADDRESS  Address,
  883.   IN PUNICODE_STRING  DeviceName,
  884.   IN PTDI_PNP_CONTEXT  Context);
  885.  
  886. typedef VOID DDKAPI
  887. (*TDI_BINDING_HANDLER)(
  888.   IN TDI_PNP_OPCODE  PnPOpcode,
  889.   IN PUNICODE_STRING  DeviceName,
  890.   IN PWSTR  MultiSZBindList);
  891.  
  892. typedef VOID DDKAPI
  893. (*TDI_BIND_HANDLER)(
  894.   IN PUNICODE_STRING  DeviceName);
  895.  
  896. typedef VOID DDKAPI
  897. (*TDI_DEL_ADDRESS_HANDLER)(
  898.   IN PTA_ADDRESS  Address);
  899.  
  900. typedef VOID DDKAPI
  901. (*TDI_DEL_ADDRESS_HANDLER_V2)(
  902.   IN PTA_ADDRESS  Address,
  903.   IN PUNICODE_STRING  DeviceName,
  904.   IN PTDI_PNP_CONTEXT  Context);
  905.  
  906. typedef NTSTATUS DDKAPI
  907. (*TDI_PNP_POWER_HANDLER)(
  908.   IN PUNICODE_STRING  DeviceName,
  909.   IN PNET_PNP_EVENT  PowerEvent,
  910.   IN PTDI_PNP_CONTEXT  Context1,
  911.   IN PTDI_PNP_CONTEXT  Context2);
  912.  
  913. typedef VOID DDKAPI
  914. (*TDI_UNBIND_HANDLER)(
  915.   IN PUNICODE_STRING  DeviceName);
  916.  
  917. typedef VOID DDKAPI
  918. (*ProviderPnPPowerComplete)(
  919.   IN PNET_PNP_EVENT  NetEvent,
  920.   IN NTSTATUS  ProviderStatus);
  921.  
  922. typedef struct _TDI20_CLIENT_INTERFACE_INFO {
  923.   union {
  924.     struct {
  925.       UCHAR  MajorTdiVersion;
  926.       UCHAR  MinorTdiVersion;
  927.     };
  928.     USHORT TdiVersion;
  929.   };
  930.   USHORT  Unused;
  931.   PUNICODE_STRING  ClientName;
  932.   TDI_PNP_POWER_HANDLER  PnPPowerHandler;
  933.   union {
  934.     TDI_BINDING_HANDLER  BindingHandler;
  935.     struct {
  936.       TDI_BIND_HANDLER  BindHandler;
  937.       TDI_UNBIND_HANDLER  UnBindHandler;
  938.     };
  939.   };
  940.   union {
  941.     struct {
  942.       TDI_ADD_ADDRESS_HANDLER_V2  AddAddressHandlerV2;
  943.       TDI_DEL_ADDRESS_HANDLER_V2  DelAddressHandlerV2;
  944.     };
  945.     struct {
  946.       TDI_ADD_ADDRESS_HANDLER  AddAddressHandler;
  947.       TDI_DEL_ADDRESS_HANDLER  DelAddressHandler;
  948.     };
  949.   };
  950. } TDI20_CLIENT_INTERFACE_INFO, *PTDI20_CLIENT_INTERFACE_INFO;
  951.  
  952. typedef TDI20_CLIENT_INTERFACE_INFO TDI_CLIENT_INTERFACE_INFO;
  953. typedef TDI_CLIENT_INTERFACE_INFO *PTDI_CLIENT_INTERFACE_INFO;
  954.  
  955.  
  956. /* TDI functions */
  957.  
  958. /*
  959.  * VOID
  960.  * TdiCompleteRequest(
  961.  *   IN PIRP Irp,
  962.  *   IN NTSTATUS Status);
  963.  */
  964. #define TdiCompleteRequest(Irp, Status)           \
  965. {                                                 \
  966.   (Irp)->IoStatus.Status = (Status);              \
  967.   IoCompleteRequest((Irp), IO_NETWORK_INCREMENT); \
  968. }
  969.  
  970. TDIKRNLAPI
  971. NTSTATUS
  972. DDKAPI
  973. TdiCopyBufferToMdl(
  974.   IN PVOID  SourceBuffer,
  975.   IN ULONG  SourceOffset,
  976.   IN ULONG  SourceBytesToCopy,
  977.   IN PMDL  DestinationMdlChain,
  978.   IN ULONG  DestinationOffset,
  979.   IN PULONG  BytesCopied);
  980.  
  981. /*
  982.  * VOID
  983.  * TdiCopyLookaheadData(
  984.  *   IN PVOID  Destination,
  985.  *   IN PVOID  Source,
  986.  *   IN ULONG  Length,
  987.  *   IN ULONG  ReceiveFlags);
  988.  */
  989. #define TdiCopyLookaheadData(Destination, Source, Length, ReceiveFlags) \
  990.   RtlCopyMemory(Destination, Source, Length)
  991.  
  992. TDIKRNLAPI
  993. NTSTATUS
  994. DDKAPI
  995. TdiCopyMdlChainToMdlChain (
  996.   IN PMDL  SourceMdlChain,
  997.   IN ULONG  SourceOffset,
  998.   IN PMDL  DestinationMdlChain,
  999.   IN ULONG  DestinationOffset,
  1000.   OUT PULONG  BytesCopied);
  1001.  
  1002. TDIKRNLAPI
  1003. NTSTATUS
  1004. DDKAPI
  1005. TdiCopyMdlToBuffer(
  1006.   IN PMDL  SourceMdlChain,
  1007.   IN ULONG  SourceOffset,
  1008.   IN PVOID  DestinationBuffer,
  1009.   IN ULONG  DestinationOffset,
  1010.   IN ULONG  DestinationBufferSize,
  1011.   OUT PULONG  BytesCopied);
  1012.  
  1013. TDIKRNLAPI
  1014. NTSTATUS
  1015. DDKAPI
  1016. TdiDeregisterAddressChangeHandler(
  1017.   IN HANDLE  BindingHandle);
  1018.  
  1019. TDIKRNLAPI
  1020. NTSTATUS
  1021. DDKAPI
  1022. TdiDeregisterDeviceObject(
  1023.   IN HANDLE  DevRegistrationHandle);
  1024.  
  1025. TDIKRNLAPI
  1026. NTSTATUS
  1027. DDKAPI
  1028. TdiDeregisterNetAddress(
  1029.   IN HANDLE  AddrRegistrationHandle);
  1030.  
  1031. TDIKRNLAPI
  1032. NTSTATUS
  1033. DDKAPI
  1034. TdiDeregisterPnPHandlers(
  1035.   IN HANDLE  BindingHandle);
  1036.  
  1037. TDIKRNLAPI
  1038. NTSTATUS
  1039. DDKAPI
  1040. TdiDeregisterProvider(
  1041.   IN HANDLE  ProviderHandle);
  1042.  
  1043. TDIKRNLAPI
  1044. NTSTATUS
  1045. DDKAPI
  1046. TdiEnumerateAddresses(
  1047.   IN HANDLE  BindingHandle);
  1048.  
  1049. TDIKRNLAPI
  1050. VOID
  1051. DDKAPI
  1052. TdiInitialize(
  1053.   VOID);
  1054.  
  1055. TDIKRNLAPI
  1056. VOID
  1057. DDKAPI
  1058. TdiMapBuffer(
  1059.   IN PMDL  MdlChain);
  1060.  
  1061. TDIKRNLAPI
  1062. NTSTATUS
  1063. DDKAPI
  1064. TdiMapUserRequest(
  1065.   IN PDEVICE_OBJECT  DeviceObject,
  1066.   IN PIRP  Irp,
  1067.   IN PIO_STACK_LOCATION  IrpSp);
  1068.  
  1069. TDIKRNLAPI
  1070. BOOLEAN
  1071. DDKAPI
  1072. TdiMatchPdoWithChainedReceiveContext(
  1073.   IN PVOID TsduDescriptor,
  1074.   IN PVOID PDO);
  1075.  
  1076. TDIKRNLAPI
  1077. VOID
  1078. DDKAPI
  1079. TdiPnPPowerComplete(
  1080.   IN HANDLE  BindingHandle,
  1081.   IN PNET_PNP_EVENT  PowerEvent,
  1082.   IN NTSTATUS  Status);
  1083.  
  1084. TDIKRNLAPI
  1085. NTSTATUS
  1086. DDKAPI
  1087. TdiPnPPowerRequest(
  1088.   IN PUNICODE_STRING  DeviceName,
  1089.   IN PNET_PNP_EVENT  PowerEvent,
  1090.   IN PTDI_PNP_CONTEXT  Context1,
  1091.   IN PTDI_PNP_CONTEXT  Context2,
  1092.   IN ProviderPnPPowerComplete  ProtocolCompletionHandler);
  1093.  
  1094. TDIKRNLAPI
  1095. NTSTATUS
  1096. DDKAPI
  1097. TdiProviderReady(
  1098.   IN HANDLE  ProviderHandle);
  1099.  
  1100. TDIKRNLAPI
  1101. NTSTATUS
  1102. DDKAPI
  1103. TdiRegisterAddressChangeHandler(
  1104.   IN TDI_ADD_ADDRESS_HANDLER  AddHandler,
  1105.   IN TDI_DEL_ADDRESS_HANDLER  DeleteHandler,
  1106.   OUT HANDLE  *BindingHandle);
  1107.  
  1108. TDIKRNLAPI
  1109. NTSTATUS
  1110. DDKAPI
  1111. TdiRegisterDeviceObject(
  1112.   IN PUNICODE_STRING  DeviceName,
  1113.   OUT HANDLE  *DevRegistrationHandle);
  1114.  
  1115. TDIKRNLAPI
  1116. NTSTATUS
  1117. DDKAPI
  1118. TdiRegisterNetAddress(
  1119.   IN PTA_ADDRESS  Address,
  1120.   IN PUNICODE_STRING  DeviceName,
  1121.   IN PTDI_PNP_CONTEXT  Context,
  1122.   OUT HANDLE  *AddrRegistrationHandle);
  1123.  
  1124. TDIKRNLAPI
  1125. NTSTATUS
  1126. DDKAPI
  1127. TdiRegisterNotificationHandler(
  1128.   IN TDI_BIND_HANDLER  BindHandler,
  1129.   IN TDI_UNBIND_HANDLER  UnbindHandler,
  1130.   OUT HANDLE  *BindingHandle);
  1131.  
  1132. TDIKRNLAPI
  1133. NTSTATUS
  1134. DDKAPI
  1135. TdiRegisterPnPHandlers(
  1136.   IN PTDI_CLIENT_INTERFACE_INFO  ClientInterfaceInfo,
  1137.   IN ULONG  InterfaceInfoSize,
  1138.   OUT HANDLE  *BindingHandle);
  1139.  
  1140. TDIKRNLAPI
  1141. NTSTATUS
  1142. DDKAPI
  1143. TdiRegisterProvider(
  1144.   IN PUNICODE_STRING  ProviderName,
  1145.   OUT HANDLE  *ProviderHandle);
  1146.  
  1147. TDIKRNLAPI
  1148. VOID
  1149. DDKAPI
  1150. TdiReturnChainedReceives(
  1151.   IN PVOID  *TsduDescriptors,
  1152.   IN ULONG   NumberOfTsdus);
  1153.  
  1154. TDIKRNLAPI
  1155. VOID
  1156. DDKAPI
  1157. TdiUnmapBuffer(
  1158.   IN PMDL  MdlChain);
  1159.  
  1160. #pragma pack(pop)
  1161.  
  1162. #ifdef __cplusplus
  1163. }
  1164. #endif
  1165.  
  1166. #endif /* __TDIKRNL_H */
  1167.