reactos/drivers/net/afd/afd/tdiconn.c

   1 /* $Id$
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * FILE:             drivers/net/afd/afd/tdiconn.c
   5  * PURPOSE:          Ancillary functions driver
   6  * PROGRAMMER:       Art Yerkes (ayerkes@speakeasy.net)
   7  * UPDATE HISTORY:
   8  * 20040708 Created
   9  */
  10 #include <afd.h>
  11 #include "debug.h"
  12 #include "tdiconn.h"
  13
  14 UINT TdiAddressSizeFromType( UINT AddressType ) {
  15     switch( AddressType ) {
  16     case AF_INET:
  17         return sizeof(TA_IP_ADDRESS);
  18     default:
  19         AFD_DbgPrint(MID_TRACE,("TdiAddressSizeFromType - invalid type: %x\n", AddressType));
  20         KeBugCheck( 0 );
  21     }
  22     return 0;
  23 }
  24
  25 UINT TaLengthOfAddress( PTA_ADDRESS Addr ) {
  26     UINT AddrLen = 2 * sizeof( USHORT ) + Addr->AddressLength;
  27     AFD_DbgPrint(MID_TRACE,("AddrLen %x\n", AddrLen));
  28     return AddrLen;
  29 }
  30
  31 UINT TaLengthOfTransportAddress( PTRANSPORT_ADDRESS Addr ) {
  32     UINT AddrLen = 2 * sizeof( ULONG ) + Addr->Address[0].AddressLength;
  33     AFD_DbgPrint(MID_TRACE,("AddrLen %x\n", AddrLen));
  34     return AddrLen;
  35 }
  36
  37 VOID TaCopyAddressInPlace( PTA_ADDRESS Target,
  38                            PTA_ADDRESS Source ) {
  39     UINT AddrLen = TaLengthOfAddress( Source );
  40     RtlCopyMemory( Target, Source, AddrLen );
  41 }
  42
  43 PTA_ADDRESS TaCopyAddress( PTA_ADDRESS Source ) {
  44     UINT AddrLen = TaLengthOfAddress( Source );
  45     PVOID Buffer = ExAllocatePool( NonPagedPool, AddrLen );
  46     RtlCopyMemory( Buffer, Source, AddrLen );
  47     return Buffer;
  48 }
  49
  50 VOID TaCopyTransportAddressInPlace( PTRANSPORT_ADDRESS Target,
  51                                     PTRANSPORT_ADDRESS Source ) {
  52     UINT AddrLen = TaLengthOfTransportAddress( Source );
  53     RtlCopyMemory( Target, Source, AddrLen );
  54 }
  55
  56 PTRANSPORT_ADDRESS TaCopyTransportAddress( PTRANSPORT_ADDRESS OtherAddress ) {
  57     UINT AddrLen;
  58     PTRANSPORT_ADDRESS A;
  59
  60     ASSERT(OtherAddress->TAAddressCount == 1);
  61     AddrLen = TaLengthOfTransportAddress( OtherAddress );
  62     A = ExAllocatePool( NonPagedPool, AddrLen );
  63
  64     if( A )
  65         TaCopyTransportAddressInPlace( A, OtherAddress );
  66
  67   return A;
  68 }
  69
  70 NTSTATUS TdiBuildNullConnectionInfoInPlace
  71 ( PTDI_CONNECTION_INFORMATION ConnInfo,
  72   ULONG Type )
  73 /*
  74  * FUNCTION: Builds a NULL TDI connection information structure
  75  * ARGUMENTS:
  76  *     ConnectionInfo = Address of buffer to place connection information
  77  *     Type           = TDI style address type (TDI_ADDRESS_TYPE_XXX).
  78  * RETURNS:
  79  *     Status of operation
  80  */
  81 {
  82   ULONG TdiAddressSize;
  83
  84   TdiAddressSize = TdiAddressSizeFromType(Type);
  85
  86   RtlZeroMemory(ConnInfo,
  87                 sizeof(TDI_CONNECTION_INFORMATION) +
  88                 TdiAddressSize);
  89
  90   ConnInfo->OptionsLength = sizeof(ULONG);
  91   ConnInfo->RemoteAddressLength = 0;
  92   ConnInfo->RemoteAddress = NULL;
  93
  94   return STATUS_SUCCESS;
  95 }
  96
  97 NTSTATUS TdiBuildNullConnectionInfo
  98 ( PTDI_CONNECTION_INFORMATION *ConnectionInfo,
  99   ULONG Type )
 100 /*
 101  * FUNCTION: Builds a NULL TDI connection information structure
 102  * ARGUMENTS:
 103  *     ConnectionInfo = Address of buffer pointer to allocate connection
 104  *                      information in
 105  *     Type           = TDI style address type (TDI_ADDRESS_TYPE_XXX).
 106  * RETURNS:
 107  *     Status of operation
 108  */
 109 {
 110   PTDI_CONNECTION_INFORMATION ConnInfo;
 111   ULONG TdiAddressSize;
 112   NTSTATUS Status;
 113
 114   TdiAddressSize = TdiAddressSizeFromType(Type);
 115
 116   ConnInfo = (PTDI_CONNECTION_INFORMATION)
 117     ExAllocatePool(NonPagedPool,
 118                    sizeof(TDI_CONNECTION_INFORMATION) +
 119                    TdiAddressSize);
 120   if (!ConnInfo)
 121     return STATUS_INSUFFICIENT_RESOURCES;
 122
 123   Status = TdiBuildNullConnectionInfoInPlace( ConnInfo, Type );
 124
 125   if (!NT_SUCCESS(Status))
 126       ExFreePool( ConnInfo );
 127   else
 128       *ConnectionInfo = ConnInfo;
 129
 130   ConnInfo->RemoteAddress = (PTA_ADDRESS)&ConnInfo[1];
 131   ConnInfo->RemoteAddressLength = TdiAddressSize;
 132
 133   return Status;
 134 }
 135
 136
 137 NTSTATUS
 138 TdiBuildConnectionInfoInPlace
 139 ( PTDI_CONNECTION_INFORMATION ConnectionInfo,
 140   PTRANSPORT_ADDRESS Address ) {
 141     NTSTATUS Status = STATUS_SUCCESS;
 142
 143     RtlCopyMemory( ConnectionInfo->RemoteAddress,
 144                    Address,
 145                    ConnectionInfo->RemoteAddressLength );
 146
 147     return Status;
 148 }
 149
 150
 151 NTSTATUS
 152 TdiBuildConnectionInfo
 153 ( PTDI_CONNECTION_INFORMATION *ConnectionInfo,
 154   PTRANSPORT_ADDRESS Address ) {
 155     NTSTATUS Status = TdiBuildNullConnectionInfo
 156         ( ConnectionInfo, Address->Address[0].AddressType );
 157
 158     if( NT_SUCCESS(Status) )
 159         TdiBuildConnectionInfoInPlace( *ConnectionInfo, Address );
 160
 161     return Status;
 162 }
 163
 164 NTSTATUS
 165 TdiBuildConnectionInfoPair
 166 ( PTDI_CONNECTION_INFO_PAIR ConnectionInfo,
 167   PTRANSPORT_ADDRESS From, PTRANSPORT_ADDRESS To )
 168     /*
 169      * FUNCTION: Fill a TDI_CONNECTION_INFO_PAIR struct will the two addresses
 170      *           given.
 171      * ARGUMENTS:
 172      *   ConnectionInfo: The pair
 173      *   From:           The from address
 174      *   To:             The to address
 175      * RETURNS:
 176      *   Status of the operation
 177      */
 178 {
 179     PCHAR LayoutFrame;
 180     UINT SizeOfEntry;
 181     ULONG TdiAddressSize;
 182
 183     /* FIXME: Get from socket information */
 184     TdiAddressSize = TdiAddressSizeFromType(From->Address[0].AddressType);
 185     SizeOfEntry = TdiAddressSize + sizeof(TDI_CONNECTION_INFORMATION);
 186
 187     LayoutFrame = (PCHAR)ExAllocatePool(NonPagedPool, 2 * SizeOfEntry);
 188
 189     if (!LayoutFrame) {
 190         AFD_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 191         return STATUS_INSUFFICIENT_RESOURCES;
 192     }
 193
 194     RtlZeroMemory( LayoutFrame, 2 * SizeOfEntry );
 195
 196     PTDI_CONNECTION_INFORMATION
 197         FromTdiConn = (PTDI_CONNECTION_INFORMATION)LayoutFrame,
 198         ToTdiConn = (PTDI_CONNECTION_INFORMATION)LayoutFrame + SizeOfEntry;
 199
 200     if (From != NULL) {
 201         TdiBuildConnectionInfoInPlace( FromTdiConn, From );
 202     } else {
 203         TdiBuildNullConnectionInfoInPlace( FromTdiConn,
 204                                            From->Address[0].AddressType );
 205     }
 206
 207     TdiBuildConnectionInfoInPlace( ToTdiConn, To );
 208
 209     return STATUS_SUCCESS;
 210 }
 211
 212 PTA_ADDRESS TdiGetRemoteAddress( PTDI_CONNECTION_INFORMATION TdiConn )
 213     /*
 214      * Convenience function that rounds out the abstraction of
 215      * the TDI_CONNECTION_INFORMATION struct.
 216      */
 217 {
 218     return TdiConn->RemoteAddress;
 219 }
 220