drivers/net/packet/packet.c

   1 /*
   2  * Copyright (c) 1999, 2000
   3  *      Politecnico di Torino.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that: (1) source code distributions
   7  * retain the above copyright notice and this paragraph in its entirety, (2)
   8  * distributions including binary code include the above copyright notice and
   9  * this paragraph in its entirety in the documentation or other materials
  10  * provided with the distribution, and (3) all advertising materials mentioning
  11  * features or use of this software display the following acknowledgement:
  12  * ``This product includes software developed by the Politecnico
  13  * di Torino, and its contributors.'' Neither the name of
  14  * the University nor the names of its contributors may be used to endorse
  15  * or promote products derived from this software without specific prior
  16  * written permission.
  17  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20  */
  21
  22 #ifdef _MSC_VER
  23 #include "stdarg.h"
  24 #include "ntddk.h"
  25 #include "ntiologc.h"
  26 #include "ndis.h"
  27 #else
  28 #include <ddk/ntddk.h>
  29 #include <net/ndis.h>
  30 #endif
  31
  32 #include "ntddpack.h"
  33
  34 #include "debug.h"
  35 #include "packet.h"
  36 #include "win_bpf.h"
  37 #include "win_bpf_filter_init.h"
  38
  39 #include "tme.h"
  40
  41 #if DBG
  42 // Declare the global debug flag for this driver.
  43 //ULONG PacketDebugFlag = PACKET_DEBUG_LOUD;
  44 ULONG PacketDebugFlag = PACKET_DEBUG_LOUD + PACKET_DEBUG_VERY_LOUD + PACKET_DEBUG_INIT;
  45
  46 #endif
  47
  48 PDEVICE_EXTENSION GlobalDeviceExtension;
  49
  50 ////////////////////////////////////////////////////////////////////////////////
  51 #define ROBERTS_PATCH
  52 #ifdef ROBERTS_PATCH
  53
  54 #define NDIS_STRING_CONST(x)    {sizeof(L##x)-2, sizeof(L##x), L##x}
  55
  56 //void __moddi3(void) {}
  57 //void __divdi3(void) {}
  58
  59 #endif // ROBERTS_PATCH
  60 ////////////////////////////////////////////////////////////////////////////////
  61 //
  62 // Global strings
  63 //
  64 NDIS_STRING NPF_Prefix = NDIS_STRING_CONST("NPF_");
  65 NDIS_STRING devicePrefix = NDIS_STRING_CONST("\\Device\\");
  66 NDIS_STRING symbolicLinkPrefix = NDIS_STRING_CONST("\\DosDevices\\");
  67 NDIS_STRING tcpLinkageKeyName = NDIS_STRING_CONST("\\Registry\\Machine\\System"
  68                                                                 L"\\CurrentControlSet\\Services\\Tcpip\\Linkage");
  69 NDIS_STRING AdapterListKey = NDIS_STRING_CONST("\\Registry\\Machine\\System"
  70                                                                 L"\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}");
  71 NDIS_STRING bindValueName = NDIS_STRING_CONST("Bind");
  72
  73
  74 /// Global variable that points to the names of the bound adapters
  75 WCHAR* bindP = NULL;
  76
  77 extern struct time_conv G_Start_Time; // from openclos.c
  78
  79 extern NDIS_SPIN_LOCK Opened_Instances_Lock;
  80
  81 //
  82 //  Packet Driver's entry routine.
  83 //
  84 NTSTATUS
  85 #ifdef __GNUC__
  86 STDCALL
  87 #endif
  88 DriverEntry(
  89     IN PDRIVER_OBJECT DriverObject,
  90     IN PUNICODE_STRING RegistryPath
  91     )
  92 {
  93
  94     NDIS_PROTOCOL_CHARACTERISTICS  ProtocolChar;
  95     UNICODE_STRING MacDriverName;
  96     UNICODE_STRING UnicodeDeviceName;
  97     PDEVICE_OBJECT DeviceObject = NULL;
  98     PDEVICE_EXTENSION DeviceExtension = NULL;
  99     NDIS_STATUS Status = NDIS_STATUS_SUCCESS;
 100     NTSTATUS ErrorCode = STATUS_SUCCESS;
 101     NDIS_STRING ProtoName = NDIS_STRING_CONST("PacketDriver");
 102     ULONG          DevicesCreated=0;
 103     PWSTR          BindString;
 104     PWSTR          ExportString;
 105     PWSTR          BindStringSave;
 106     PWSTR          ExportStringSave;
 107     NDIS_HANDLE    NdisProtocolHandle;
 108         WCHAR* bindT;
 109         PKEY_VALUE_PARTIAL_INFORMATION tcpBindingsP;
 110         UNICODE_STRING macName;
 111
 112         // This driver at the moment works only on single processor machines
 113         if(NdisSystemProcessorCount() != 1){
 114                 return STATUS_IMAGE_MP_UP_MISMATCH;
 115         }
 116
 117     IF_LOUD(DbgPrint("Packet: DriverEntry\n");)
 118
 119         RtlZeroMemory(&ProtocolChar,sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
 120
 121 #ifdef NDIS50
 122     ProtocolChar.MajorNdisVersion            = 5;
 123 #else
 124     ProtocolChar.MajorNdisVersion            = 3;
 125 #endif
 126     ProtocolChar.MinorNdisVersion            = 0;
 127 #ifndef __GNUC__
 128     ProtocolChar.Reserved                    = 0;
 129 #else
 130     ProtocolChar.u1.Reserved                 = 0;
 131 #endif
 132     ProtocolChar.OpenAdapterCompleteHandler  = NPF_OpenAdapterComplete;
 133     ProtocolChar.CloseAdapterCompleteHandler = NPF_CloseAdapterComplete;
 134 #ifndef __GNUC__
 135     ProtocolChar.SendCompleteHandler         = NPF_SendComplete;
 136     ProtocolChar.TransferDataCompleteHandler = NPF_TransferDataComplete;
 137 #else
 138     ProtocolChar.u2.SendCompleteHandler         = NPF_SendComplete;
 139     ProtocolChar.u3.TransferDataCompleteHandler = NPF_TransferDataComplete;
 140 #endif
 141     ProtocolChar.ResetCompleteHandler        = NPF_ResetComplete;
 142     ProtocolChar.RequestCompleteHandler      = NPF_RequestComplete;
 143 #ifndef __GNUC__
 144     ProtocolChar.ReceiveHandler              = NPF_tap;
 145 #else
 146     ProtocolChar.u4.ReceiveHandler           = NPF_tap;
 147 #endif
 148     ProtocolChar.ReceiveCompleteHandler      = NPF_ReceiveComplete;
 149     ProtocolChar.StatusHandler               = NPF_Status;
 150     ProtocolChar.StatusCompleteHandler       = NPF_StatusComplete;
 151 #ifdef NDIS50
 152     ProtocolChar.BindAdapterHandler          = NPF_BindAdapter;
 153     ProtocolChar.UnbindAdapterHandler        = NPF_UnbindAdapter;
 154     ProtocolChar.PnPEventHandler             = NPF_PowerChange;
 155     ProtocolChar.ReceivePacketHandler        = NULL;
 156 #endif
 157     ProtocolChar.Name                        = ProtoName;
 158
 159     NdisRegisterProtocol(
 160         &Status,
 161         &NdisProtocolHandle,
 162         &ProtocolChar,
 163         sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
 164
 165     if (Status != NDIS_STATUS_SUCCESS) {
 166
 167         IF_LOUD(DbgPrint("NPF: Failed to register protocol with NDIS\n");)
 168
 169         return Status;
 170
 171     }
 172
 173     NdisAllocateSpinLock(&Opened_Instances_Lock);
 174
 175     // Set up the device driver entry points.
 176     DriverObject->MajorFunction[IRP_MJ_CREATE] = NPF_Open;
 177     DriverObject->MajorFunction[IRP_MJ_CLOSE]  = NPF_Close;
 178     DriverObject->MajorFunction[IRP_MJ_READ]   = NPF_Read;
 179     DriverObject->MajorFunction[IRP_MJ_WRITE]  = NPF_Write;
 180     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL]  = NPF_IoControl;
 181     DriverObject->DriverUnload = NPF_Unload;
 182
 183 /*
 184     //  Get the name of the Packet driver and the name of the NIC driver
 185     //  to bind to from the registry
 186     Status=NPF_ReadRegistry(
 187                &BindString,
 188                &ExportString,
 189                RegistryPath
 190                );
 191
 192     if (Status != STATUS_SUCCESS) {
 193
 194                 IF_LOUD(DbgPrint("Trying dynamic binding\n");)
 195  */
 196                 bindP = getAdaptersList();
 197
 198                 if (bindP == NULL) {
 199                         IF_LOUD(DbgPrint("Adapters not found in the registry, try to copy the bindings of TCP-IP.\n");)
 200
 201                         tcpBindingsP = getTcpBindings();
 202
 203                         if (tcpBindingsP == NULL){
 204                                 IF_LOUD(DbgPrint("TCP-IP not found, quitting.\n");)
 205                                 goto RegistryError;
 206                         }
 207
 208                         bindP = (WCHAR*)tcpBindingsP;
 209                         bindT = (WCHAR*)(tcpBindingsP->Data);
 210         } else {
 211                         bindT = bindP;
 212                 }
 213
 214                 for (; *bindT != UNICODE_NULL; bindT += (macName.Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR)) {
 215                         RtlInitUnicodeString(&macName, bindT);
 216                         createDevice(DriverObject, &macName, NdisProtocolHandle);
 217                 }
 218
 219                 return STATUS_SUCCESS;
 220 /*
 221     }
 222     BindStringSave   = BindString;
 223     ExportStringSave = ExportString;
 224     //
 225     //  create a device object for each entry
 226     //
 227     while (*BindString!= UNICODE_NULL && *ExportString!= UNICODE_NULL) {
 228         //
 229         //  Create a counted unicode string for both null terminated strings
 230         //
 231         RtlInitUnicodeString(
 232             &MacDriverName,
 233             BindString);
 234         RtlInitUnicodeString(
 235             &UnicodeDeviceName,
 236             ExportString);
 237         //
 238         //  Advance to the next string of the MULTI_SZ string
 239         //
 240         BindString   += (MacDriverName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);
 241         ExportString += (UnicodeDeviceName.Length+sizeof(UNICODE_NULL))/sizeof(WCHAR);
 242         IF_LOUD(DbgPrint("NPF: DeviceName=%ws  MacName=%ws\n",UnicodeDeviceName.Buffer,MacDriverName.Buffer);)
 243         //
 244         //  Create the device object
 245         //
 246         Status = IoCreateDevice(
 247                     DriverObject,
 248                     sizeof(DEVICE_EXTENSION),
 249                     &UnicodeDeviceName,
 250                     FILE_DEVICE_PROTOCOL,
 251                     0,
 252                     FALSE,
 253                     &DeviceObject);
 254         if (Status != STATUS_SUCCESS) {
 255             IF_LOUD(DbgPrint("NPF: IoCreateDevice() failed:\n");)
 256             break;
 257         }
 258         DevicesCreated++;
 259         DeviceObject->Flags |= DO_DIRECT_IO;
 260         DeviceExtension  =  (PDEVICE_EXTENSION) DeviceObject->DeviceExtension;
 261         DeviceExtension->DeviceObject = DeviceObject;
 262         //
 263         //  Save the the name of the MAC driver to open in the Device Extension
 264         //
 265         DeviceExtension->AdapterName=MacDriverName;
 266         if (DevicesCreated == 1) {
 267             DeviceExtension->BindString   = NULL;
 268             DeviceExtension->ExportString = NULL;
 269         }
 270         DeviceExtension->NdisProtocolHandle=NdisProtocolHandle;
 271     }
 272     if (DevicesCreated > 0) {
 273         //
 274         //  Managed to create at least one device.
 275         //
 276         IF_LOUD(DbgPrint("NPF: Managed to create at least one device.\n");)
 277         return STATUS_SUCCESS;
 278     }
 279     ExFreePool(BindStringSave);
 280     ExFreePool(ExportStringSave);
 281  */
 282
 283 RegistryError:
 284     IF_LOUD(DbgPrint("NPF: RegistryError: calling NdisDeregisterProtocol()\n");)
 285     NdisDeregisterProtocol(
 286         &Status,
 287         NdisProtocolHandle
 288         );
 289
 290     Status=STATUS_UNSUCCESSFUL;
 291
 292     return(Status);
 293
 294 }
 295
 296 //-------------------------------------------------------------------
 297
 298 PWCHAR getAdaptersList(void)
 299 {
 300         PKEY_VALUE_PARTIAL_INFORMATION result = NULL;
 301         OBJECT_ATTRIBUTES objAttrs;
 302         NTSTATUS status;
 303         HANDLE keyHandle;
 304         UINT BufPos=0;
 305
 306 #define NPF_TAG_DEVICENAME  TAG('0', 'P', 'W', 'A')
 307         PWCHAR DeviceNames = (PWCHAR) ExAllocatePoolWithTag(PagedPool, 4096, NPF_TAG_DEVICENAME);
 308
 309         if (DeviceNames == NULL) {
 310                 IF_LOUD(DbgPrint("Unable the allocate the buffer for the list of the network adapters\n");)
 311                         return NULL;
 312         }
 313
 314         InitializeObjectAttributes(&objAttrs, &AdapterListKey,
 315                 OBJ_CASE_INSENSITIVE, NULL, NULL);
 316         status = ZwOpenKey(&keyHandle, KEY_READ, &objAttrs);
 317         if (!NT_SUCCESS(status)) {
 318
 319         //IF_LOUD(DbgPrint("Status of %x opening %ws\n", status, tcpLinkageKeyName.Buffer);)
 320         IF_LOUD(DbgPrint("Status of %x opening %ws\n", status, AdapterListKey.Buffer);)
 321
 322     } else { //OK
 323                 ULONG resultLength;
 324                 KEY_VALUE_PARTIAL_INFORMATION valueInfo;
 325                 CHAR AdapInfo[1024];
 326                 UINT i=0;
 327
 328                 IF_LOUD(DbgPrint("getAdaptersList: scanning the list of the adapters in the registry, DeviceNames=%x\n",DeviceNames);)
 329
 330                         // Scan the list of the devices
 331                         while((status=ZwEnumerateKey(keyHandle,i,KeyBasicInformation,AdapInfo,sizeof(AdapInfo),&resultLength))==STATUS_SUCCESS) {
 332                                 WCHAR ExportKeyName [512];
 333                                 PWCHAR ExportKeyPrefix = L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}\\";
 334                                 UINT ExportKeyPrefixSize = sizeof(L"\\Registry\\Machine\\System\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}");
 335                                 PWCHAR LinkageKeyPrefix = L"\\Linkage";
 336                                 UINT LinkageKeyPrefixSize = sizeof(L"\\Linkage");
 337                                 NDIS_STRING FinalExportKey = NDIS_STRING_CONST("Export");
 338                                 PKEY_BASIC_INFORMATION tInfo= (PKEY_BASIC_INFORMATION)AdapInfo;
 339                                 UNICODE_STRING AdapterKeyName;
 340                                 HANDLE ExportKeyHandle;
 341                                 KEY_VALUE_PARTIAL_INFORMATION valueInfo;
 342                                 ULONG resultLength;
 343
 344                                 RtlCopyMemory(ExportKeyName,
 345                                         ExportKeyPrefix,
 346                                         ExportKeyPrefixSize);
 347
 348                                 RtlCopyMemory((PCHAR)ExportKeyName+ExportKeyPrefixSize,
 349                                         tInfo->Name,
 350                                         tInfo->NameLength+2);
 351
 352                                 RtlCopyMemory((PCHAR)ExportKeyName+ExportKeyPrefixSize+tInfo->NameLength,
 353                                         LinkageKeyPrefix,
 354                                         LinkageKeyPrefixSize);
 355
 356                                 IF_LOUD(DbgPrint("Key name=%ws\n", ExportKeyName);)
 357
 358                                 RtlInitUnicodeString(&AdapterKeyName, ExportKeyName);
 359
 360                                 InitializeObjectAttributes(&objAttrs, &AdapterKeyName,
 361                                         OBJ_CASE_INSENSITIVE, NULL, NULL);
 362
 363                                 status=ZwOpenKey(&ExportKeyHandle,KEY_READ,&objAttrs);
 364
 365                                 if (!NT_SUCCESS(status)) {
 366                                         DbgPrint("OpenKey Failed, %d!\n",status);
 367                                         i++;
 368                                         continue;
 369                                 }
 370
 371                                 status = ZwQueryValueKey(ExportKeyHandle, &FinalExportKey,
 372                                         KeyValuePartialInformation, &valueInfo,
 373                                         sizeof(valueInfo), &resultLength);
 374
 375                                 if (!NT_SUCCESS(status) && (status != STATUS_BUFFER_OVERFLOW)) {
 376                                         IF_LOUD(DbgPrint("\n\nStatus of %x querying key value for size\n", status);)
 377                 } else { // We know how big it needs to be.
 378                                         ULONG valueInfoLength = valueInfo.DataLength + FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]);
 379 #define NPF_TAG_KEYVALUE  TAG('1', 'P', 'W', 'A')
 380                                         PKEY_VALUE_PARTIAL_INFORMATION valueInfoP =     (PKEY_VALUE_PARTIAL_INFORMATION) ExAllocatePoolWithTag(PagedPool, valueInfoLength, NPF_TAG_KEYVALUE);
 381                                         if (valueInfoP != NULL) {
 382                                                 status = ZwQueryValueKey(ExportKeyHandle, &FinalExportKey,
 383                                                         KeyValuePartialInformation,
 384                                                         valueInfoP,
 385                                                         valueInfoLength, &resultLength);
 386                                                 if (!NT_SUCCESS(status)) {
 387                                                         IF_LOUD(DbgPrint("Status of %x querying key value\n", status);)
 388                         } else {
 389                                                         IF_LOUD(DbgPrint("Device %d = %ws\n", i, valueInfoP->Data);)
 390                                                                 RtlCopyMemory((PCHAR)DeviceNames+BufPos,
 391                                                                 valueInfoP->Data,
 392                                                                 valueInfoP->DataLength);
 393                                                         BufPos+=valueInfoP->DataLength-2;
 394                                                 }
 395
 396                                                 ExFreePool(valueInfoP);
 397                     } else {
 398                                                 IF_LOUD(DbgPrint("Error Allocating the buffer for the device name\n");)
 399                                         }
 400
 401                                 }
 402
 403                                 // terminate the buffer
 404                                 DeviceNames[BufPos/2]=0;
 405                                 DeviceNames[BufPos/2+1]=0;
 406
 407                                 ZwClose (ExportKeyHandle);
 408                                 i++;
 409
 410                         }
 411
 412                         ZwClose (keyHandle);
 413
 414         }
 415         if(BufPos==0){
 416                 ExFreePool(DeviceNames);
 417                 return NULL;
 418         }
 419         return DeviceNames;
 420 }
 421
 422 //-------------------------------------------------------------------
 423
 424 PKEY_VALUE_PARTIAL_INFORMATION getTcpBindings(void)
 425 {
 426   PKEY_VALUE_PARTIAL_INFORMATION result = NULL;
 427   OBJECT_ATTRIBUTES objAttrs;
 428   NTSTATUS status;
 429   HANDLE keyHandle;
 430
 431   InitializeObjectAttributes(&objAttrs, &tcpLinkageKeyName,
 432                              OBJ_CASE_INSENSITIVE, NULL, NULL);
 433   status = ZwOpenKey(&keyHandle, KEY_READ, &objAttrs);
 434   if (!NT_SUCCESS(status)) {
 435     IF_LOUD(DbgPrint("\n\nStatus of %x opening %ws\n", status, tcpLinkageKeyName.Buffer);)
 436   } else {
 437     ULONG resultLength;
 438     KEY_VALUE_PARTIAL_INFORMATION valueInfo;
 439
 440     IF_LOUD(DbgPrint("\n\nOpened %ws\n", tcpLinkageKeyName.Buffer);)
 441
 442     status = ZwQueryValueKey(keyHandle, &bindValueName,
 443                              KeyValuePartialInformation, &valueInfo,
 444                              sizeof(valueInfo), &resultLength);
 445     if (!NT_SUCCESS(status) && (status != STATUS_BUFFER_OVERFLOW)) {
 446       IF_LOUD(DbgPrint("\n\nStatus of %x querying key value for size\n", status);)
 447     } else {                      // We know how big it needs to be.
 448       ULONG valueInfoLength = valueInfo.DataLength + FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data[0]);
 449 #define NPF_TAG_KEYVALUE2  TAG('2', 'P', 'W', 'A')
 450       PKEY_VALUE_PARTIAL_INFORMATION valueInfoP =
 451         (PKEY_VALUE_PARTIAL_INFORMATION)ExAllocatePoolWithTag(PagedPool, valueInfoLength, NPF_TAG_KEYVALUE2);
 452
 453           if (valueInfoP != NULL) {
 454         status = ZwQueryValueKey(keyHandle, &bindValueName,
 455                                  KeyValuePartialInformation,
 456                                  valueInfoP,
 457                                  valueInfoLength, &resultLength);
 458
 459                 if (!NT_SUCCESS(status)) {
 460           IF_LOUD(DbgPrint("\n\nStatus of %x querying key value\n", status);)
 461         }
 462         else if (valueInfoLength != resultLength) {
 463           IF_LOUD(DbgPrint("\n\nQuerying key value result len = %u "
 464                      "but previous len = %u\n",
 465                      resultLength, valueInfoLength);)
 466         }
 467         else if (valueInfoP->Type != REG_MULTI_SZ) {
 468           IF_LOUD(DbgPrint("\n\nTcpip bind value not REG_MULTI_SZ but %u\n",
 469                      valueInfoP->Type);)
 470         }
 471         else {                  // It's OK
 472 #if DBG
 473           ULONG i;
 474           WCHAR* dataP = (WCHAR*)(&valueInfoP->Data[0]);
 475           IF_LOUD(DbgPrint("\n\nBind value:\n");)
 476           for (i = 0; *dataP != UNICODE_NULL; i++) {
 477             UNICODE_STRING macName;
 478             RtlInitUnicodeString(&macName, dataP);
 479             IF_LOUD(DbgPrint("\n\nMac %u = %ws\n", i, macName.Buffer);)
 480             dataP +=
 481               (macName.Length + sizeof(UNICODE_NULL)) / sizeof(WCHAR);
 482           }
 483 #endif // DBG
 484           result = valueInfoP;
 485         }
 486       }
 487     }
 488     ZwClose(keyHandle);
 489   }
 490   return result;
 491 }
 492
 493 //-------------------------------------------------------------------
 494
 495 BOOLEAN createDevice(IN OUT PDRIVER_OBJECT adriverObjectP,
 496                      IN PUNICODE_STRING amacNameP, NDIS_HANDLE aProtoHandle)
 497 {
 498     NTSTATUS status;
 499     PDEVICE_OBJECT devObjP;
 500     UNICODE_STRING deviceName;
 501         UNICODE_STRING deviceSymLink;
 502
 503         IF_LOUD(DbgPrint("\n\ncreateDevice for MAC %ws\n", amacNameP->Buffer););
 504     if (RtlCompareMemory(amacNameP->Buffer, devicePrefix.Buffer,
 505                        devicePrefix.Length) < devicePrefix.Length) {
 506                 return FALSE;
 507     }
 508
 509     deviceName.Length = 0;
 510     deviceName.MaximumLength = (USHORT)(amacNameP->Length + NPF_Prefix.Length + sizeof(UNICODE_NULL));
 511 #define NPF_TAG_DEVICENAMEBUF  TAG('3', 'P', 'W', 'A')
 512     deviceName.Buffer = ExAllocatePoolWithTag(PagedPool, deviceName.MaximumLength, NPF_TAG_DEVICENAMEBUF);
 513
 514         if (deviceName.Buffer == NULL)
 515                 return FALSE;
 516
 517         deviceSymLink.Length = 0;
 518         deviceSymLink.MaximumLength =(USHORT)(amacNameP->Length-devicePrefix.Length
 519                 + symbolicLinkPrefix.Length
 520                 + NPF_Prefix.Length
 521                 + sizeof(UNICODE_NULL));
 522
 523 #define NPF_TAG_SYMLINKBUF  TAG('3', 'P', 'W', 'A')
 524         deviceSymLink.Buffer = ExAllocatePoolWithTag(NonPagedPool, deviceSymLink.MaximumLength, NPF_TAG_SYMLINKBUF);
 525
 526         if (deviceSymLink.Buffer  == NULL)
 527         {
 528                 ExFreePool(deviceName.Buffer);
 529                 return FALSE;
 530         }
 531
 532     RtlAppendUnicodeStringToString(&deviceName, &devicePrefix);
 533     RtlAppendUnicodeStringToString(&deviceName, &NPF_Prefix);
 534     RtlAppendUnicodeToString(&deviceName, amacNameP->Buffer +
 535                              devicePrefix.Length / sizeof(WCHAR));
 536
 537         RtlAppendUnicodeStringToString(&deviceSymLink, &symbolicLinkPrefix);
 538         RtlAppendUnicodeStringToString(&deviceSymLink, &NPF_Prefix);
 539         RtlAppendUnicodeToString(&deviceSymLink, amacNameP->Buffer +
 540                 devicePrefix.Length / sizeof(WCHAR));
 541
 542         IF_LOUD(DbgPrint("Creating device name: %ws\n", deviceName.Buffer);)
 543
 544         status = IoCreateDevice(adriverObjectP,
 545         sizeof(PDEVICE_EXTENSION),
 546         &deviceName,
 547         FILE_DEVICE_TRANSPORT,
 548         0,
 549         FALSE,
 550         &devObjP);
 551
 552     if (NT_SUCCESS(status)) {
 553         PDEVICE_EXTENSION devExtP = (PDEVICE_EXTENSION)devObjP->DeviceExtension;
 554
 555                 IF_LOUD(DbgPrint("Device created successfully\n"););
 556
 557         devObjP->Flags |= DO_DIRECT_IO;
 558         RtlInitUnicodeString(&devExtP->AdapterName,amacNameP->Buffer);
 559                 devExtP->NdisProtocolHandle=aProtoHandle;
 560
 561                 IF_LOUD(DbgPrint("Trying to create SymLink %ws\n",deviceSymLink.Buffer););
 562
 563                 if (IoCreateSymbolicLink(&deviceSymLink,&deviceName) != STATUS_SUCCESS) {
 564                         IF_LOUD(DbgPrint("\n\nError creating SymLink %ws\nn", deviceSymLink.Buffer););
 565
 566                         ExFreePool(deviceName.Buffer);
 567                         ExFreePool(deviceSymLink.Buffer);
 568
 569                         devExtP->ExportString = NULL;
 570
 571                         return FALSE;
 572     }
 573
 574                 IF_LOUD(DbgPrint("SymLink %ws successfully created.\n\n", deviceSymLink.Buffer););
 575
 576                 devExtP->ExportString = deviceSymLink.Buffer;
 577
 578         ExFreePool(deviceName.Buffer);
 579
 580                 return TRUE;
 581     }
 582
 583         else
 584         {
 585                 IF_LOUD(DbgPrint("\n\nIoCreateDevice status = %x\n", status););
 586
 587                 ExFreePool(deviceName.Buffer);
 588                 ExFreePool(deviceSymLink.Buffer);
 589
 590                 return FALSE;
 591         }
 592 }
 593
 594 //-------------------------------------------------------------------
 595
 596 VOID
 597 STDCALL_FUNC
 598 NPF_Unload(IN PDRIVER_OBJECT DriverObject)
 599 {
 600     PDEVICE_OBJECT     DeviceObject;
 601     PDEVICE_OBJECT     OldDeviceObject;
 602     PDEVICE_EXTENSION  DeviceExtension;
 603
 604     NDIS_HANDLE        NdisProtocolHandle;
 605     NDIS_STATUS        Status;
 606
 607         NDIS_STRING                SymLink;
 608
 609     IF_LOUD(DbgPrint("NPF: Unload\n"););
 610
 611         DeviceObject    = DriverObject->DeviceObject;
 612
 613     while (DeviceObject != NULL) {
 614         OldDeviceObject=DeviceObject;
 615
 616         DeviceObject=DeviceObject->NextDevice;
 617
 618                 DeviceExtension = OldDeviceObject->DeviceExtension;
 619
 620         NdisProtocolHandle=DeviceExtension->NdisProtocolHandle;
 621
 622                 IF_LOUD(DbgPrint("Deleting Adapter %ws, Protocol Handle=%x, Device Obj=%x (%x)\n",
 623                         DeviceExtension->AdapterName.Buffer,
 624                         NdisProtocolHandle,
 625                         DeviceObject,
 626                         OldDeviceObject););
 627
 628                 if (DeviceExtension->ExportString)
 629                 {
 630                         RtlInitUnicodeString(&SymLink , DeviceExtension->ExportString);
 631
 632                         IF_LOUD(DbgPrint("Deleting SymLink at %p\n", SymLink.Buffer););
 633
 634                         IoDeleteSymbolicLink(&SymLink);
 635                         ExFreePool(DeviceExtension->ExportString);
 636                 }
 637
 638         IoDeleteDevice(OldDeviceObject);
 639     }
 640
 641         NdisDeregisterProtocol(
 642         &Status,
 643         NdisProtocolHandle
 644         );
 645
 646         // Free the adapters names
 647         ExFreePool( bindP );
 648 }
 649
 650 //-------------------------------------------------------------------
 651
 652 NTSTATUS
 653 NPF_IoControl(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)
 654 {
 655     POPEN_INSTANCE      Open;
 656     PIO_STACK_LOCATION  IrpSp;
 657     PLIST_ENTRY         RequestListEntry;
 658     PINTERNAL_REQUEST   pRequest;
 659     ULONG               FunctionCode;
 660     NDIS_STATUS         Status;
 661     PLIST_ENTRY         PacketListEntry;
 662         UINT                            i;
 663         PUCHAR                          tpointer;
 664         ULONG                           dim,timeout;
 665         PUCHAR                          prog;
 666         PPACKET_OID_DATA    OidData;
 667         int                                     *StatsBuf;
 668     PNDIS_PACKET        pPacket;
 669         ULONG                           mode;
 670         PWSTR                           DumpNameBuff;
 671         PUCHAR                          TmpBPFProgram;
 672         INT                                     WriteRes;
 673         BOOLEAN                         SyncWrite = FALSE;
 674         struct bpf_insn         *initprogram;
 675         ULONG                           insns;
 676         ULONG                           cnt;
 677         BOOLEAN                         IsExtendedFilter=FALSE;
 678
 679     IF_LOUD(DbgPrint("NPF: IoControl\n");)
 680
 681         IrpSp = IoGetCurrentIrpStackLocation(Irp);
 682     FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;
 683     Open=IrpSp->FileObject->FsContext;
 684
 685     Irp->IoStatus.Status = STATUS_SUCCESS;
 686
 687     IF_LOUD(DbgPrint("NPF: Function code is %08lx  buff size=%08lx  %08lx\n",FunctionCode,IrpSp->Parameters.DeviceIoControl.InputBufferLength,IrpSp->Parameters.DeviceIoControl.OutputBufferLength);)
 688
 689
 690         switch (FunctionCode){
 691
 692         case BIOCGSTATS: //function to get the capture stats
 693
 694                 if(IrpSp->Parameters.DeviceIoControl.OutputBufferLength < 4*sizeof(INT)){
 695                         EXIT_FAILURE(0);
 696                 }
 697
 698                 *(((PUINT)Irp->UserBuffer)+3) = Open->Accepted;
 699                 *(((PUINT)Irp->UserBuffer)) = Open->Received;
 700                 *(((PUINT)Irp->UserBuffer)+1) = Open->Dropped;
 701                 *(((PUINT)Irp->UserBuffer)+2) = 0;              // Not yet supported
 702
 703                 EXIT_SUCCESS(4*sizeof(INT));
 704
 705                 break;
 706
 707         case BIOCGEVNAME: //function to get the name of the event associated with the current instance
 708
 709                 if(IrpSp->Parameters.DeviceIoControl.OutputBufferLength<26){
 710                         EXIT_FAILURE(0);
 711                 }
 712
 713                 RtlCopyMemory(Irp->UserBuffer,(Open->ReadEventName.Buffer)+18,26);
 714
 715                 EXIT_SUCCESS(26);
 716
 717                 break;
 718
 719         case BIOCSENDPACKETSSYNC:
 720
 721                 SyncWrite = TRUE;
 722
 723         case BIOCSENDPACKETSNOSYNC:
 724
 725                 WriteRes = NPF_BufferedWrite(Irp,
 726                         (PUCHAR)Irp->AssociatedIrp.SystemBuffer,
 727                         IrpSp->Parameters.DeviceIoControl.InputBufferLength,
 728                         SyncWrite);
 729
 730                 if( WriteRes != -1)
 731                 {
 732                         EXIT_SUCCESS(WriteRes);
 733                 }
 734
 735                 EXIT_FAILURE(WriteRes);
 736
 737                 break;
 738
 739         case BIOCSETF:
 740
 741                 // Free the previous buffer if it was present
 742                 if(Open->bpfprogram!=NULL){
 743                         TmpBPFProgram=Open->bpfprogram;
 744                         Open->bpfprogram = NULL;
 745                         ExFreePool(TmpBPFProgram);
 746                 }
 747
 748                 if (Open->Filter!=NULL)
 749                 {
 750                         JIT_BPF_Filter *OldFilter=Open->Filter;
 751                         Open->Filter=NULL;
 752                         BPF_Destroy_JIT_Filter(OldFilter);
 753                 }
 754
 755                 // Get the pointer to the new program
 756                 prog=(PUCHAR)Irp->AssociatedIrp.SystemBuffer;
 757
 758                 if(prog==NULL){
 759                         IF_LOUD(DbgPrint("0001");)
 760
 761                         EXIT_FAILURE(0);
 762                 }
 763
 764                 insns=(IrpSp->Parameters.DeviceIoControl.InputBufferLength)/sizeof(struct bpf_insn);
 765
 766                 //count the number of operative instructions
 767                 for (cnt=0;(cnt<insns) &&(((struct bpf_insn*)prog)[cnt].code!=BPF_SEPARATION); cnt++);
 768
 769                 IF_LOUD(DbgPrint("Operative instructions=%u\n",cnt);)
 770
 771                 if (((struct bpf_insn*)prog)[cnt].code==BPF_SEPARATION && (insns-cnt-1)!=0)
 772                 {
 773                         IF_LOUD(DbgPrint("Initialization instructions=%u\n",insns-cnt-1);)
 774
 775                         IsExtendedFilter=TRUE;
 776
 777                         initprogram=&((struct bpf_insn*)prog)[cnt+1];
 778
 779                         if(bpf_filter_init(initprogram,&(Open->mem_ex),&(Open->tme), &G_Start_Time)!=INIT_OK)
 780                         {
 781
 782                                 IF_LOUD(DbgPrint("Error initializing NPF machine (bpf_filter_init)\n");)
 783
 784                                 EXIT_FAILURE(0);
 785                         }
 786                 }
 787
 788                 //the NPF processor has been initialized, we have to validate the operative instructions
 789                 insns=cnt;
 790
 791                 if(bpf_validate((struct bpf_insn*)prog,cnt,Open->mem_ex.size)==0)
 792                 {
 793                         IF_LOUD(DbgPrint("Error validating program");)
 794                         //FIXME: the machine has been initialized(?), but the operative code is wrong.
 795                         //we have to reset the machine!
 796                         //something like: reallocate the mem_ex, and reset the tme_core
 797                         EXIT_FAILURE(0);
 798                 }
 799
 800                 // Allocate the memory to contain the new filter program
 801                 // We could need the original BPF binary if we are forced to use bpf_filter_with_2_buffers()
 802 #define NPF_TAG_BPFPROG  TAG('4', 'P', 'W', 'A')
 803                 TmpBPFProgram=(PUCHAR)ExAllocatePoolWithTag(NonPagedPool, cnt*sizeof(struct bpf_insn), NPF_TAG_BPFPROG);
 804                 if (TmpBPFProgram==NULL){
 805                         IF_LOUD(DbgPrint("Error - No memory for filter");)
 806                         // no memory
 807                         EXIT_FAILURE(0);
 808                 }
 809
 810                 //copy the program in the new buffer
 811                 RtlCopyMemory(TmpBPFProgram,prog,cnt*sizeof(struct bpf_insn));
 812                 Open->bpfprogram=TmpBPFProgram;
 813
 814                 // Create the new JIT filter function
 815                 if(!IsExtendedFilter)
 816                         if((Open->Filter=BPF_jitter((struct bpf_insn*)Open->bpfprogram,cnt)) == NULL) {
 817                         IF_LOUD(DbgPrint("Error jittering filter");)
 818                         EXIT_FAILURE(0);
 819                 }
 820
 821                 //return
 822                 Open->Bhead = 0;
 823                 Open->Btail = 0;
 824                 (INT)Open->BLastByte = -1;
 825                 Open->Received = 0;
 826                 Open->Dropped = 0;
 827                 Open->Accepted = 0;
 828
 829                 EXIT_SUCCESS(IrpSp->Parameters.DeviceIoControl.InputBufferLength);
 830
 831                 break;
 832
 833         case BIOCSMODE:  //set the capture mode
 834
 835                 mode=*((PULONG)Irp->AssociatedIrp.SystemBuffer);
 836
 837                 if(mode == MODE_CAPT){
 838                         Open->mode=MODE_CAPT;
 839
 840                         EXIT_SUCCESS(0);
 841                 }
 842                 else if (mode==MODE_MON){
 843                         Open->mode=MODE_MON;
 844
 845                         EXIT_SUCCESS(0);
 846                 }
 847                 else{
 848                         if(mode & MODE_STAT){
 849                                 Open->mode = MODE_STAT;
 850                                 Open->Nbytes.QuadPart=0;
 851                                 Open->Npackets.QuadPart=0;
 852
 853                                 if(Open->TimeOut.QuadPart==0)Open->TimeOut.QuadPart=-10000000;
 854
 855                         }
 856
 857                         if(mode & MODE_DUMP){
 858
 859                                 Open->mode |= MODE_DUMP;
 860                                 Open->MinToCopy=(Open->BufSize<2000000)?Open->BufSize/2:1000000;
 861
 862                         }
 863                         EXIT_SUCCESS(0);
 864                 }
 865
 866                 EXIT_FAILURE(0);
 867
 868                 break;
 869
 870         case BIOCSETDUMPFILENAME:
 871
 872                 if(Open->mode & MODE_DUMP)
 873                 {
 874
 875                         // Close current dump file
 876                         if(Open->DumpFileHandle != NULL){
 877                                 NPF_CloseDumpFile(Open);
 878                                 Open->DumpFileHandle = NULL;
 879                         }
 880
 881                         if(IrpSp->Parameters.DeviceIoControl.InputBufferLength == 0){
 882                                 EXIT_FAILURE(0);
 883                         }
 884
 885                         // Allocate the buffer that will contain the string
 886 #define NPF_TAG_DUMPNAMEBUF  TAG('5', 'P', 'W', 'A')
 887                         DumpNameBuff=ExAllocatePoolWithTag(NonPagedPool, IrpSp->Parameters.DeviceIoControl.InputBufferLength, NPF_TAG_DUMPNAMEBUF);
 888                         if(DumpNameBuff==NULL || Open->DumpFileName.Buffer!=NULL){
 889                                 IF_LOUD(DbgPrint("NPF: unable to allocate the dump filename: not enough memory or name already set\n");)
 890                                         EXIT_FAILURE(0);
 891                         }
 892
 893                         // Copy the buffer
 894                         RtlCopyBytes((PVOID)DumpNameBuff,
 895                                 Irp->AssociatedIrp.SystemBuffer,
 896                                 IrpSp->Parameters.DeviceIoControl.InputBufferLength);
 897
 898                         // Force a \0 at the end of the filename to avoid that malformed strings cause RtlInitUnicodeString to crash the system
 899                         ((SHORT*)DumpNameBuff)[IrpSp->Parameters.DeviceIoControl.InputBufferLength/2-1]=0;
 900
 901                         // Create the unicode string
 902                         RtlInitUnicodeString(&Open->DumpFileName, DumpNameBuff);
 903
 904                         IF_LOUD(DbgPrint("NPF: dump file name set to %ws, len=%d\n",
 905                                 Open->DumpFileName.Buffer,
 906                                 IrpSp->Parameters.DeviceIoControl.InputBufferLength);)
 907
 908                         // Try to create the file
 909                         if ( NT_SUCCESS( NPF_OpenDumpFile(Open,&Open->DumpFileName,FALSE)) &&
 910                                 NT_SUCCESS( NPF_StartDump(Open))){
 911
 912                                 EXIT_SUCCESS(0);
 913                         }
 914                 }
 915
 916                 EXIT_FAILURE(0);
 917
 918                 break;
 919
 920         case BIOCSETDUMPLIMITS:
 921
 922                 Open->MaxDumpBytes = *(PULONG)Irp->AssociatedIrp.SystemBuffer;
 923                 Open->MaxDumpPacks = *((PULONG)Irp->AssociatedIrp.SystemBuffer + 1);
 924
 925                 IF_LOUD(DbgPrint("NPF: Set dump limits to %u bytes, %u packs\n", Open->MaxDumpBytes, Open->MaxDumpPacks);)
 926
 927                 EXIT_SUCCESS(0);
 928
 929                 break;
 930
 931         case BIOCISDUMPENDED:
 932                 if(IrpSp->Parameters.DeviceIoControl.OutputBufferLength < 4){
 933                         EXIT_FAILURE(0);
 934                 }
 935
 936                 *((UINT*)Irp->UserBuffer) = (Open->DumpLimitReached)?1:0;
 937
 938                 EXIT_SUCCESS(4);
 939
 940                 break;
 941
 942         case BIOCSETBUFFERSIZE:
 943
 944                 // Get the number of bytes to allocate
 945                 dim = *((PULONG)Irp->AssociatedIrp.SystemBuffer);
 946
 947                 // Free the old buffer
 948                 tpointer = Open->Buffer;
 949                 if(tpointer != NULL){
 950                         Open->BufSize = 0;
 951                         Open->Buffer = NULL;
 952                         ExFreePool(tpointer);
 953                 }
 954                 // Allocate the new buffer
 955                 if(dim!=0){
 956 #define NPF_TAG_TPOINTER  TAG('6', 'P', 'W', 'A')
 957                         tpointer = ExAllocatePoolWithTag(NonPagedPool, dim, NPF_TAG_TPOINTER);
 958                         if (tpointer==NULL)     {
 959                                 // no memory
 960                                 Open->BufSize = 0;
 961                                 Open->Buffer = NULL;
 962                                 EXIT_FAILURE(0);
 963                         }
 964                 }
 965                 else
 966                         tpointer = NULL;
 967
 968                 Open->Buffer = tpointer;
 969                 Open->Bhead = 0;
 970                 Open->Btail = 0;
 971                 (INT)Open->BLastByte = -1;
 972
 973                 Open->BufSize = (UINT)dim;
 974                 EXIT_SUCCESS(dim);
 975
 976                 break;
 977
 978         case BIOCSRTIMEOUT: //set the timeout on the read calls
 979
 980                 timeout = *((PULONG)Irp->AssociatedIrp.SystemBuffer);
 981                 if((int)timeout==-1)
 982                         Open->TimeOut.QuadPart=(LONGLONG)IMMEDIATE;
 983                 else {
 984                         Open->TimeOut.QuadPart=(LONGLONG)timeout;
 985                         Open->TimeOut.QuadPart*=10000;
 986                         Open->TimeOut.QuadPart=-Open->TimeOut.QuadPart;
 987                 }
 988
 989                 //IF_LOUD(DbgPrint("NPF: read timeout set to %d:%d\n",Open->TimeOut.HighPart,Open->TimeOut.LowPart);)
 990                 EXIT_SUCCESS(timeout);
 991
 992                 break;
 993
 994         case BIOCSWRITEREP: //set the writes repetition number
 995
 996                 Open->Nwrites = *((PULONG)Irp->AssociatedIrp.SystemBuffer);
 997
 998                 EXIT_SUCCESS(Open->Nwrites);
 999
1000                 break;
1001
1002         case BIOCSMINTOCOPY: //set the minimum buffer's size to copy to the application
1003
1004                 Open->MinToCopy = *((PULONG)Irp->AssociatedIrp.SystemBuffer);
1005
1006                 EXIT_SUCCESS(Open->MinToCopy);
1007
1008                 break;
1009
1010         case IOCTL_PROTOCOL_RESET:
1011
1012         IF_LOUD(DbgPrint("NPF: IoControl - Reset request\n");)
1013
1014                 IoMarkIrpPending(Irp);
1015                 Irp->IoStatus.Status = STATUS_SUCCESS;
1016
1017                 ExInterlockedInsertTailList(&Open->ResetIrpList,&Irp->Tail.Overlay.ListEntry,&Open->RequestSpinLock);
1018         NdisReset(&Status,Open->AdapterHandle);
1019         if (Status != NDIS_STATUS_PENDING) {
1020             IF_LOUD(DbgPrint("NPF: IoControl - ResetComplete being called\n");)
1021                                 NPF_ResetComplete(Open,Status);
1022         }
1023
1024                 break;
1025
1026
1027         case BIOCSETOID:
1028         case BIOCQUERYOID:
1029
1030                 // Extract a request from the list of free ones
1031                 RequestListEntry=ExInterlockedRemoveHeadList(&Open->RequestList,&Open->RequestSpinLock);
1032                 if (RequestListEntry == NULL)
1033                 {
1034                         EXIT_FAILURE(0);
1035                 }
1036
1037                 pRequest=CONTAINING_RECORD(RequestListEntry,INTERNAL_REQUEST,ListElement);
1038                 pRequest->Irp=Irp;
1039                 pRequest->Internal = FALSE;
1040
1041
1042                 //
1043         //  See if it is an Ndis request
1044         //
1045         OidData=Irp->AssociatedIrp.SystemBuffer;
1046
1047         if (((FunctionCode == BIOCSETOID) || (FunctionCode == BIOCQUERYOID))
1048             &&
1049             (IrpSp->Parameters.DeviceIoControl.InputBufferLength == IrpSp->Parameters.DeviceIoControl.OutputBufferLength)
1050             &&
1051             (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA))
1052             &&
1053             (IrpSp->Parameters.DeviceIoControl.InputBufferLength >= sizeof(PACKET_OID_DATA)-1+OidData->Length)) {
1054
1055             IF_LOUD(DbgPrint("NPF: IoControl: Request: Oid=%08lx, Length=%08lx\n",OidData->Oid,OidData->Length);)
1056
1057                                 //
1058                                 //  The buffer is valid
1059                                 //
1060                                 if (FunctionCode == BIOCSETOID){
1061
1062                                         pRequest->Request.RequestType=NdisRequestSetInformation;
1063                                         pRequest->Request.DATA.SET_INFORMATION.Oid=OidData->Oid;
1064
1065                                         pRequest->Request.DATA.SET_INFORMATION.InformationBuffer=OidData->Data;
1066                                         pRequest->Request.DATA.SET_INFORMATION.InformationBufferLength=OidData->Length;
1067                                 } else{
1068                                         pRequest->Request.RequestType=NdisRequestQueryInformation;
1069                                         pRequest->Request.DATA.QUERY_INFORMATION.Oid=OidData->Oid;
1070
1071                                         pRequest->Request.DATA.QUERY_INFORMATION.InformationBuffer=OidData->Data;
1072                                         pRequest->Request.DATA.QUERY_INFORMATION.InformationBufferLength=OidData->Length;
1073
1074                                 }
1075
1076                                 NdisResetEvent(&Open->IOEvent);
1077                                 //
1078                                 //  submit the request
1079                                 //
1080                                 NdisRequest(
1081                                         &Status,
1082                                         Open->AdapterHandle,
1083                                         &pRequest->Request
1084                                         );
1085
1086         } else {
1087             //
1088             //  buffer too small
1089             //
1090             Status=NDIS_STATUS_FAILURE;
1091             pRequest->Request.DATA.SET_INFORMATION.BytesRead=0;
1092             pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten=0;
1093
1094         }
1095
1096         if (Status != NDIS_STATUS_PENDING) {
1097             IF_LOUD(DbgPrint("NPF: Calling RequestCompleteHandler\n");)
1098
1099                         NPF_RequestComplete(Open, &pRequest->Request, Status);
1100             return Status;
1101
1102         }
1103
1104                 NdisWaitEvent(&Open->IOEvent, 5000);
1105
1106                 return(Open->IOStatus);
1107
1108                 break;
1109
1110
1111         default:
1112
1113                 EXIT_FAILURE(0);
1114         }
1115
1116         return Status;
1117 }
1118
1119 //-------------------------------------------------------------------
1120
1121 VOID
1122 NPF_RequestComplete(
1123     IN NDIS_HANDLE   ProtocolBindingContext,
1124     IN PNDIS_REQUEST NdisRequest,
1125     IN NDIS_STATUS   Status
1126     )
1127
1128 {
1129     POPEN_INSTANCE      Open;
1130     PIO_STACK_LOCATION  IrpSp;
1131     PIRP                Irp;
1132     PINTERNAL_REQUEST   pRequest;
1133     UINT                FunctionCode;
1134         KIRQL                           OldIrq;
1135
1136     PPACKET_OID_DATA    OidData;
1137
1138     IF_LOUD(DbgPrint("NPF: RequestComplete\n");)
1139
1140     Open= (POPEN_INSTANCE)ProtocolBindingContext;
1141
1142     pRequest=CONTAINING_RECORD(NdisRequest,INTERNAL_REQUEST,Request);
1143     Irp=pRequest->Irp;
1144
1145         if(pRequest->Internal == TRUE){
1146
1147                 // Put the request in the list of the free ones
1148                 ExInterlockedInsertTailList(&Open->RequestList, &pRequest->ListElement, &Open->RequestSpinLock);
1149
1150             if(Status != NDIS_STATUS_SUCCESS)
1151                         Open->MaxFrameSize = 1514;      // Assume Ethernet
1152
1153                 // We always return success, because the adapter has been already opened
1154                 Irp->IoStatus.Status = NDIS_STATUS_SUCCESS;
1155                 Irp->IoStatus.Information = 0;
1156                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1157                 return;
1158         }
1159
1160     IrpSp = IoGetCurrentIrpStackLocation(Irp);
1161
1162     FunctionCode=IrpSp->Parameters.DeviceIoControl.IoControlCode;
1163
1164     OidData=Irp->AssociatedIrp.SystemBuffer;
1165
1166     if (FunctionCode == BIOCSETOID) {
1167
1168         OidData->Length=pRequest->Request.DATA.SET_INFORMATION.BytesRead;
1169
1170     } else {
1171
1172         if (FunctionCode == BIOCQUERYOID) {
1173
1174             OidData->Length=pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten;
1175
1176                     IF_LOUD(DbgPrint("RequestComplete: BytesWritten=%d\n",pRequest->Request.DATA.QUERY_INFORMATION.BytesWritten);)
1177         }
1178
1179     }
1180
1181     Irp->IoStatus.Information=IrpSp->Parameters.DeviceIoControl.InputBufferLength;
1182
1183     IF_LOUD(DbgPrint("RequestComplete: BytesReturned=%d\n",IrpSp->Parameters.DeviceIoControl.InputBufferLength);)
1184
1185     ExInterlockedInsertTailList(
1186         &Open->RequestList,
1187         &pRequest->ListElement,
1188         &Open->RequestSpinLock);
1189
1190     Irp->IoStatus.Status = Status;
1191
1192         Open->IOStatus = Status;
1193
1194         IoCompleteRequest(Irp, IO_NO_INCREMENT);
1195
1196         // Unlock the caller
1197         NdisSetEvent(&Open->IOEvent);
1198
1199     return;
1200
1201
1202 }
1203
1204 //-------------------------------------------------------------------
1205
1206 VOID
1207 NPF_Status(
1208     IN NDIS_HANDLE   ProtocolBindingContext,
1209     IN NDIS_STATUS   Status,
1210     IN PVOID         StatusBuffer,
1211     IN UINT          StatusBufferSize
1212     )
1213
1214 {
1215
1216     IF_LOUD(DbgPrint("NPF: Status Indication\n");)
1217
1218     return;
1219
1220 }
1221
1222 //-------------------------------------------------------------------
1223
1224 VOID
1225 NPF_StatusComplete(
1226     IN NDIS_HANDLE  ProtocolBindingContext
1227     )
1228
1229 {
1230
1231     IF_LOUD(DbgPrint("NPF: StatusIndicationComplete\n");)
1232
1233     return;
1234
1235 }
1236
1237 //-------------------------------------------------------------------
1238
1239 NTSTATUS
1240 NPF_ReadRegistry(
1241     IN  PWSTR              *MacDriverName,
1242     IN  PWSTR              *PacketDriverName,
1243     IN  PUNICODE_STRING     RegistryPath
1244     )
1245
1246 {
1247     NTSTATUS   Status;
1248
1249     RTL_QUERY_REGISTRY_TABLE ParamTable[4];
1250
1251     PWSTR      Bind       = L"Bind";
1252     PWSTR      Export     = L"Export";
1253     PWSTR      Parameters = L"Parameters";
1254     PWSTR      Linkage    = L"Linkage";
1255
1256     PWCHAR     Path;
1257
1258 #define NPF_TAG_PATH  TAG('7', 'P', 'W', 'A')
1259     Path=ExAllocatePoolWithTag(PagedPool, RegistryPath->Length+sizeof(WCHAR), NPF_TAG_PATH);
1260
1261     if (Path == NULL) {
1262                 IF_LOUD(DbgPrint("\nPacketReadRegistry: returing STATUS_INSUFFICIENT_RESOURCES\n");)
1263         return STATUS_INSUFFICIENT_RESOURCES;
1264     }
1265
1266     RtlZeroMemory(
1267         Path,
1268         RegistryPath->Length+sizeof(WCHAR)
1269         );
1270
1271     RtlCopyMemory(
1272         Path,
1273         RegistryPath->Buffer,
1274         RegistryPath->Length
1275         );
1276
1277     IF_LOUD(DbgPrint("NPF: Reg path is %ws\n",RegistryPath->Buffer);)
1278
1279     RtlZeroMemory(
1280         ParamTable,
1281         sizeof(ParamTable)
1282         );
1283
1284
1285
1286     //
1287     //  change to the linkage key
1288     //
1289     //ParamTable[0].QueryRoutine = NULL;
1290     ParamTable[0].QueryRoutine = NPF_QueryRegistryRoutine;
1291     ParamTable[0].Flags = RTL_QUERY_REGISTRY_SUBKEY;
1292     ParamTable[0].Name = Linkage;
1293
1294
1295     //
1296     //  Get the name of the mac driver we should bind to
1297     //
1298
1299     ParamTable[1].QueryRoutine = NPF_QueryRegistryRoutine;
1300     ParamTable[1].Flags = RTL_QUERY_REGISTRY_REQUIRED |
1301                           RTL_QUERY_REGISTRY_NOEXPAND;
1302
1303     ParamTable[1].Name = Bind;
1304     ParamTable[1].EntryContext = (PVOID)MacDriverName;
1305     ParamTable[1].DefaultType = REG_MULTI_SZ;
1306
1307     //
1308     //  Get the name that we should use for the driver object
1309     //
1310
1311     ParamTable[2].QueryRoutine = NPF_QueryRegistryRoutine;
1312     ParamTable[2].Flags = RTL_QUERY_REGISTRY_REQUIRED |
1313                           RTL_QUERY_REGISTRY_NOEXPAND;
1314
1315     ParamTable[2].Name = Export;
1316     ParamTable[2].EntryContext = (PVOID)PacketDriverName;
1317     ParamTable[2].DefaultType = REG_MULTI_SZ;
1318
1319
1320     Status=RtlQueryRegistryValues(
1321                RTL_REGISTRY_ABSOLUTE,
1322                Path,
1323                ParamTable,
1324                NULL,
1325                NULL
1326                );
1327
1328     if (Status != STATUS_SUCCESS) {
1329                 // insert hard coded parameters here while registry on ROS is not working...
1330                 IF_LOUD(DbgPrint("PacketReadRegistry() RtlQueryRegistryValues failed - returing fixed parameters\n");)
1331
1332         *MacDriverName = ExAllocatePool(PagedPool, 50 * sizeof(WCHAR));
1333                 //memcpy(*MacDriverName,    L"\\Device\\ne2000", 15 * sizeof(WCHAR));
1334                 memcpy(*MacDriverName,    L"\\Device\\ne2000", 15 * sizeof(WCHAR));
1335
1336         *PacketDriverName = ExAllocatePool(PagedPool, 50 * sizeof(WCHAR));
1337                 memcpy(*PacketDriverName, L"\\Device\\NPF_ne2000", 19 * sizeof(WCHAR));
1338                 Status = STATUS_SUCCESS;
1339
1340         }
1341
1342     ExFreePool(Path);
1343     return Status;
1344 }
1345
1346 //-------------------------------------------------------------------
1347
1348 NTSTATUS
1349 NPF_QueryRegistryRoutine(
1350     IN PWSTR     ValueName,
1351     IN ULONG     ValueType,
1352     IN PVOID     ValueData,
1353     IN ULONG     ValueLength,
1354     IN PVOID     Context,
1355     IN PVOID     EntryContext
1356     )
1357
1358 {
1359
1360     PUCHAR       Buffer;
1361
1362     IF_LOUD(DbgPrint("Perf: QueryRegistryRoutine\n");)
1363
1364     if (ValueType != REG_MULTI_SZ) {
1365
1366         return STATUS_OBJECT_NAME_NOT_FOUND;
1367
1368     }
1369
1370 #define NPF_TAG_REGBUF  TAG('8', 'P', 'W', 'A')
1371     Buffer=ExAllocatePoolWithTag(NonPagedPool, ValueLength, NPF_TAG_REGBUF);
1372
1373     if (Buffer==NULL) {
1374
1375         return STATUS_INSUFFICIENT_RESOURCES;
1376
1377     }
1378
1379     RtlCopyMemory(
1380         Buffer,
1381         ValueData,
1382         ValueLength
1383         );
1384
1385     *((PUCHAR *)EntryContext)=Buffer;
1386
1387     return STATUS_SUCCESS;
1388
1389 }