dlls/ndis.sys/main.c

   1 /*
   2  * ndis.sys
   3  *
   4  * Copyright 2014 Austin English
   5  * Copyright 2016 André Hentschel
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23
  24 #define NONAMELESSUNION
  25 #include "ntstatus.h"
  26 #define WIN32_NO_STATUS
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "winternl.h"
  30 #include "winioctl.h"
  31 #include "winsock2.h"
  32 #include "ws2ipdef.h"
  33 #include "iphlpapi.h"
  34 #include "netioapi.h"
  35 #include "ntddndis.h"
  36 #include "ddk/wdm.h"
  37 #include "ddk/ndis.h"
  38 #include "winreg.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ndis);
  42
  43 static void query_global_stats(IRP *irp, const MIB_IF_ROW2 *netdev)
  44 {
  45     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
  46     void *response = MmGetSystemAddressForMdlSafe( irp->MdlAddress, NormalPagePriority );
  47     DWORD len = irpsp->Parameters.DeviceIoControl.OutputBufferLength;
  48     DWORD oid;
  49
  50     if (irpsp->Parameters.DeviceIoControl.InputBufferLength != sizeof(oid))
  51     {
  52         irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
  53         return;
  54     }
  55     oid = *(DWORD *)irp->AssociatedIrp.SystemBuffer;
  56
  57     switch (oid)
  58     {
  59     case OID_GEN_MEDIA_SUPPORTED:
  60     case OID_GEN_MEDIA_IN_USE:
  61     {
  62         if (len < sizeof(NDIS_MEDIUM))
  63         {
  64             irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
  65             break;
  66         }
  67         *(NDIS_MEDIUM *)response = netdev->MediaType;
  68         irp->IoStatus.Information = sizeof(netdev->MediaType);
  69         irp->IoStatus.u.Status = STATUS_SUCCESS;
  70         break;
  71     }
  72     case OID_802_3_PERMANENT_ADDRESS:
  73     {
  74         irp->IoStatus.Information = netdev->PhysicalAddressLength;
  75         if (len < netdev->PhysicalAddressLength)
  76             irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
  77         else
  78             memcpy( response, netdev->PermanentPhysicalAddress, sizeof(netdev->PermanentPhysicalAddress) );
  79         break;
  80     }
  81     case OID_802_3_CURRENT_ADDRESS:
  82     {
  83         irp->IoStatus.Information = netdev->PhysicalAddressLength;
  84         if (len < netdev->PhysicalAddressLength)
  85             irp->IoStatus.u.Status = STATUS_INVALID_PARAMETER;
  86         else
  87             memcpy( response, netdev->PhysicalAddress, sizeof(netdev->PhysicalAddress) );
  88         break;
  89
  90     }
  91     default:
  92         FIXME( "Unsupported OID %x\n", oid );
  93         irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
  94         break;
  95     }
  96 }
  97
  98 static NTSTATUS WINAPI ndis_ioctl(DEVICE_OBJECT *device, IRP *irp)
  99 {
 100     IO_STACK_LOCATION *irpsp = IoGetCurrentIrpStackLocation( irp );
 101     MIB_IF_ROW2 *netdev = device->DeviceExtension;
 102
 103     TRACE( "ioctl %x insize %u outsize %u\n",
 104            irpsp->Parameters.DeviceIoControl.IoControlCode,
 105            irpsp->Parameters.DeviceIoControl.InputBufferLength,
 106            irpsp->Parameters.DeviceIoControl.OutputBufferLength );
 107
 108     switch (irpsp->Parameters.DeviceIoControl.IoControlCode)
 109     {
 110     case IOCTL_NDIS_QUERY_GLOBAL_STATS:
 111         query_global_stats(irp, netdev);
 112         break;
 113     default:
 114         FIXME( "ioctl %x not supported\n", irpsp->Parameters.DeviceIoControl.IoControlCode );
 115         irp->IoStatus.u.Status = STATUS_NOT_SUPPORTED;
 116         break;
 117     }
 118
 119     IoCompleteRequest( irp, IO_NO_INCREMENT );
 120     return STATUS_SUCCESS;
 121 }
 122
 123 static void add_key(const WCHAR *guidstrW, const MIB_IF_ROW2 *netdev)
 124 {
 125     HKEY card_key;
 126     WCHAR keynameW[100];
 127
 128     swprintf( keynameW, ARRAY_SIZE(keynameW), L"Software\\Microsoft\\Windows NT\\CurrentVersion\\NetworkCards\\%d", netdev->InterfaceIndex );
 129     if (RegCreateKeyExW( HKEY_LOCAL_MACHINE, keynameW, 0, NULL,
 130                  REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &card_key, NULL ) == ERROR_SUCCESS)
 131     {
 132         RegSetValueExW( card_key, L"Description", 0, REG_SZ, (BYTE *)netdev->Description, (lstrlenW(netdev->Description) + 1) * sizeof(WCHAR) );
 133         RegSetValueExW( card_key, L"ServiceName", 0, REG_SZ, (BYTE *)guidstrW, (lstrlenW(guidstrW) + 1) * sizeof(WCHAR) );
 134         RegCloseKey( card_key );
 135     }
 136 }
 137
 138 static int add_device(DRIVER_OBJECT *driver, const WCHAR *guidstrW, MIB_IF_ROW2 *netdev)
 139 {
 140     WCHAR nameW[47], linkW[51];
 141     UNICODE_STRING name, link;
 142     DEVICE_OBJECT *device;
 143     NTSTATUS status;
 144
 145     swprintf( nameW, ARRAY_SIZE(nameW), L"\\Device\\%s", guidstrW );
 146     RtlInitUnicodeString( &name, nameW );
 147
 148     swprintf( linkW, ARRAY_SIZE(linkW), L"\\DosDevices\\%s", guidstrW );
 149     RtlInitUnicodeString( &link, linkW );
 150
 151     if (!(status = IoCreateDevice( driver, sizeof(*netdev), &name, 0, 0, FALSE, &device )))
 152         status = IoCreateSymbolicLink( &link, &name );
 153     if (status)
 154     {
 155         FIXME( "failed to create device error %x\n", status );
 156         return 0;
 157     }
 158
 159     memcpy( device->DeviceExtension, netdev, sizeof(*netdev) );
 160     return 1;
 161 }
 162
 163
 164 static void create_network_devices(DRIVER_OBJECT *driver)
 165 {
 166     MIB_IF_TABLE2 *table;
 167     ULONG i;
 168
 169     if (GetIfTable2( &table ) != NO_ERROR)
 170         return;
 171
 172     for (i = 0; i < table->NumEntries; i++)
 173     {
 174         GUID *guid = &table->Table[i].InterfaceGuid;
 175         WCHAR guidstrW[39];
 176
 177         swprintf( guidstrW, ARRAY_SIZE(guidstrW), L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
 178                   guid->Data1, guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1],
 179                   guid->Data4[2], guid->Data4[3], guid->Data4[4], guid->Data4[5],
 180                   guid->Data4[6], guid->Data4[7] );
 181
 182         if (add_device( driver, guidstrW, &table->Table[i] ))
 183             add_key( guidstrW, &table->Table[i] );
 184     }
 185
 186     FreeMibTable( table );
 187 }
 188
 189 NTSTATUS WINAPI DriverEntry(DRIVER_OBJECT *driver, UNICODE_STRING *path)
 190 {
 191     TRACE("(%p, %s)\n", driver, debugstr_w(path->Buffer));
 192
 193     driver->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ndis_ioctl;
 194
 195     create_network_devices( driver );
 196
 197     return STATUS_SUCCESS;
 198 }
 199
 200 NDIS_STATUS WINAPI NdisAllocateMemoryWithTag(void **address, UINT length, ULONG tag)
 201 {
 202     FIXME("(%p, %u, %u): stub\n", address, length, tag);
 203     return NDIS_STATUS_FAILURE;
 204 }
 205
 206 void WINAPI NdisAllocateSpinLock(NDIS_SPIN_LOCK *lock)
 207 {
 208     FIXME("(%p): stub\n", lock);
 209 }
 210
 211 void WINAPI NdisRegisterProtocol(NDIS_STATUS *status, NDIS_HANDLE *handle,
 212                                  NDIS_PROTOCOL_CHARACTERISTICS *prot, UINT len)
 213 {
 214     FIXME("(%p, %p, %p, %u): stub\n", status, handle, prot, len);
 215     *status = NDIS_STATUS_FAILURE;
 216 }
 217
 218 CCHAR WINAPI NdisSystemProcessorCount(void)
 219 {
 220     SYSTEM_INFO si;
 221
 222     TRACE("()\n");
 223     GetSystemInfo(&si);
 224
 225     return si.dwNumberOfProcessors;
 226 }