reactos/drivers/net/tcpip/tcpip/ninfo.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS TCP/IP protocol driver
   4  * FILE:        tcpip/ninfo.c
   5  * PURPOSE:     Network information
   6  * PROGRAMMERS: Art Yerkes
   7  * REVISIONS:
   8  *   CSH 01/08-2000 Created
   9  */
  10
  11 #include "precomp.h"
  12
  13 TDI_STATUS InfoTdiQueryGetAddrTable( PNDIS_BUFFER Buffer,
  14                                      PUINT BufferSize ) {
  15
  16     IF_LIST_ITER(CurrentIF);
  17     TDI_STATUS Status = TDI_INVALID_REQUEST;
  18     KIRQL OldIrql;
  19     UINT Count = 1; /* Start adapter indices at 1 */
  20     UINT IfCount = CountInterfaces();
  21     PIPADDR_ENTRY IpAddress =
  22         ExAllocatePool( NonPagedPool, sizeof( IPADDR_ENTRY ) * IfCount );
  23     PIPADDR_ENTRY IpCurrent = IpAddress;
  24
  25     TI_DbgPrint(MAX_TRACE, ("Called.\n"));
  26
  27     TcpipAcquireSpinLock(&InterfaceListLock, &OldIrql);
  28
  29     ForEachInterface(CurrentIF) {
  30         IpCurrent->Index     = Count;
  31         IpCurrent->Addr      = 0;
  32         IpCurrent->BcastAddr = 0;
  33         IpCurrent->Mask      = 0;
  34
  35         /* Locate the diffrent addresses and put them the right place */
  36         GetInterfaceIPv4Address( CurrentIF,
  37                                  ADE_UNICAST,
  38                                  &IpAddress->Addr );
  39         GetInterfaceIPv4Address( CurrentIF,
  40                                  ADE_MULTICAST,
  41                                  &IpAddress->BcastAddr );
  42         GetInterfaceIPv4Address( CurrentIF,
  43                                  ADE_ADDRMASK,
  44                                  &IpAddress->Mask );
  45         IpCurrent++;
  46         Count++;
  47     } EndFor(CurrentIF);
  48
  49     TcpipReleaseSpinLock(&InterfaceListLock, OldIrql);
  50
  51     Status = InfoCopyOut( (PCHAR)IpAddress, sizeof(*IpAddress) * Count,
  52                           Buffer, BufferSize );
  53
  54     ExFreePool( IpAddress );
  55
  56     TI_DbgPrint(MAX_TRACE, ("Returning %08x\n", Status));
  57
  58     return Status;
  59 }
  60
  61 /* Get IPRouteEntry s for each of the routes in the system */
  62 TDI_STATUS InfoTdiQueryGetRouteTable( PNDIS_BUFFER Buffer, PUINT BufferSize ) {
  63     TDI_STATUS Status;
  64     KIRQL OldIrql;
  65     UINT RtCount = CountFIBs(),
  66         Size = sizeof( IPROUTE_ENTRY ) * RtCount;
  67     PFIB_ENTRY RCache =
  68         ExAllocatePool( NonPagedPool, sizeof( FIB_ENTRY ) * RtCount ),
  69         RCacheCur = RCache;
  70     PIPROUTE_ENTRY RouteEntries = ExAllocatePool( NonPagedPool, Size ),
  71         RtCurrent = RouteEntries;
  72
  73     TI_DbgPrint(MAX_TRACE, ("Called, routes = %d, RCache = %08x\n",
  74                             RtCount, RCache));
  75
  76     if( !RCache || !RouteEntries ) {
  77         if( RCache ) ExFreePool( RCache );
  78         if( RouteEntries ) ExFreePool( RouteEntries );
  79         return STATUS_NO_MEMORY;
  80     }
  81
  82     RtlZeroMemory( RouteEntries, Size );
  83
  84     RtCount = CopyFIBs( RCache );
  85
  86     while( RtCurrent < RouteEntries + RtCount ) {
  87         /* Copy Desitnation */
  88         if( RCacheCur->NetworkAddress && RCacheCur->Netmask &&
  89             RCacheCur->Router ) {
  90             TI_DbgPrint(MAX_TRACE, ("%d: NA %08x NM %08x GW %08x MT %d\n",
  91                                     RtCurrent - RouteEntries,
  92                                     RCacheCur->NetworkAddress->Address,
  93                                     RCacheCur->Netmask->Address,
  94                                     RCacheCur->Router->Address.Address,
  95                                     RCacheCur->Metric));
  96
  97             RtlCopyMemory( &RtCurrent->Dest,
  98                            &RCacheCur->NetworkAddress->Address,
  99                            sizeof(RtCurrent->Dest) );
 100             RtlCopyMemory( &RtCurrent->Mask,
 101                            &RCacheCur->Netmask->Address,
 102                            sizeof(RtCurrent->Mask) );
 103             /* Currently, this address is stuffed into the pointer.
 104              * That probably is not intended. */
 105             RtlCopyMemory( &RtCurrent->Gw,
 106                            &RCacheCur->Router->Address.Address,
 107                            sizeof(RtCurrent->Gw) );
 108             RtCurrent->Metric1 = RCacheCur->Metric;
 109             RtCurrent->Type = 2 /* PF_INET */;
 110
 111             TcpipAcquireSpinLock(&EntityListLock, &OldIrql);
 112             for( RtCurrent->Index = EntityCount - 1;
 113                  RtCurrent->Index >= 0 &&
 114                      RCacheCur->Router->Interface !=
 115                      EntityList[RtCurrent->Index].context;
 116                  RtCurrent->Index-- );
 117             RtCurrent->Index = EntityList[RtCurrent->Index].tei_instance;
 118             TcpipReleaseSpinLock(&EntityListLock, OldIrql);
 119         } else {
 120             TI_DbgPrint(MAX_TRACE, ("%d: BAD: NA %08x NM %08x GW %08x MT %d\n",
 121                                     RtCurrent - RouteEntries,
 122                                     RCacheCur->NetworkAddress,
 123                                     RCacheCur->Netmask,
 124                                     RCacheCur->Router,
 125                                     RCacheCur->Router ?
 126                                     &RCacheCur->Router->Address : 0,
 127                                     RCacheCur->Metric));
 128         }
 129         RtCurrent++; RCacheCur++;
 130     }
 131
 132     Status = InfoCopyOut( (PCHAR)RouteEntries, Size, Buffer, BufferSize );
 133
 134     ExFreePool( RouteEntries );
 135     ExFreePool( RCache );
 136
 137     TI_DbgPrint(MAX_TRACE, ("Returning %08x\n", Status));
 138
 139     return Status;
 140 }
 141
 142 TDI_STATUS InfoTdiQueryGetIPSnmpInfo( PNDIS_BUFFER Buffer,
 143                                       PUINT BufferSize ) {
 144     KIRQL OldIrql;
 145     IF_LIST_ITER(CurrentIF);
 146     IPSNMP_INFO SnmpInfo;
 147     UINT IfCount = CountInterfaces();
 148     UINT AddrCount = 0;
 149     UINT RouteCount = CountRouteNodes( NULL );
 150     TDI_STATUS Status = TDI_INVALID_REQUEST;
 151
 152     TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 153
 154     RtlZeroMemory(&SnmpInfo, sizeof(IPSNMP_INFO));
 155
 156     /* Count number of addresses */
 157     AddrCount = 0;
 158     TcpipAcquireSpinLock(&InterfaceListLock, &OldIrql);
 159
 160     ForEachInterface(CurrentIF) {
 161         CurrentIF = CONTAINING_RECORD(CurrentIFEntry, IP_INTERFACE, ListEntry);
 162         AddrCount += CountInterfaceAddresses( CurrentIF );
 163     } EndFor(CurrentIF);
 164
 165     TcpipReleaseSpinLock(&InterfaceListLock, OldIrql);
 166
 167     SnmpInfo.NumIf = IfCount;
 168     SnmpInfo.NumAddr = AddrCount;
 169     SnmpInfo.NumRoutes = RouteCount;
 170
 171     Status = InfoCopyOut( (PCHAR)&SnmpInfo, sizeof(SnmpInfo),
 172                           Buffer, BufferSize );
 173
 174     TI_DbgPrint(MAX_TRACE, ("Returning %08x\n", Status));
 175
 176     return Status;
 177 }
 178
 179 TDI_STATUS InfoNetworkLayerTdiQueryEx( UINT InfoClass,
 180                                        UINT InfoType,
 181                                        UINT InfoId,
 182                                        PVOID Context,
 183                                        TDIEntityID *id,
 184                                        PNDIS_BUFFER Buffer,
 185                                        PUINT BufferSize ) {
 186     TDI_STATUS Status = TDI_INVALID_REQUEST;
 187
 188     TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 189
 190     switch( InfoClass ) {
 191     case INFO_CLASS_GENERIC:
 192         if( InfoType == INFO_TYPE_PROVIDER && InfoId == ENTITY_TYPE_ID ) {
 193             ULONG Return = CL_NL_IP;
 194             Status = InfoCopyOut( (PCHAR)&Return, sizeof(Return),
 195                                   Buffer, BufferSize );
 196         }
 197         break;
 198
 199     case INFO_CLASS_PROTOCOL:
 200         switch( InfoType ) {
 201         case INFO_TYPE_PROVIDER:
 202             switch( InfoId ) {
 203             case IP_MIB_ADDRTABLE_ENTRY_ID:
 204                 Status = InfoTdiQueryGetAddrTable( Buffer, BufferSize );
 205                 break;
 206
 207             case IP_MIB_ROUTETABLE_ENTRY_ID:
 208                 Status = InfoTdiQueryGetRouteTable( Buffer, BufferSize );
 209                 break;
 210
 211             case IP_MIB_STATS_ID:
 212                 Status = InfoTdiQueryGetIPSnmpInfo( Buffer, BufferSize );
 213                 break;
 214             }
 215             break;
 216         }
 217     }
 218
 219     TI_DbgPrint(MAX_TRACE, ("Returning %08x\n", Status));
 220
 221     return Status;
 222 }
 223
 224 TDI_STATUS InfoNetworkLayerTdiSetEx( UINT InfoClass,
 225                                      UINT InfoType,
 226                                      UINT InfoId,
 227                                      PVOID Context,
 228                                      TDIEntityID *id,
 229                                      PCHAR Buffer,
 230                                      UINT BufferSize ) {
 231     TDI_STATUS Status = TDI_INVALID_REQUEST;
 232     return Status;
 233 }