reactos/drivers/network/tcpip/datalink/lan.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS TCP/IP protocol driver
   4  * FILE:        datalink/lan.c
   5  * PURPOSE:     Local Area Network media routines
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/08-2000 Created
   9  */
  10
  11 #include "precomp.h"
  12
  13 UINT TransferDataCalled = 0;
  14 UINT TransferDataCompleteCalled = 0;
  15
  16 #define CCS_ROOT L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet"
  17 #define TCPIP_GUID L"{4D36E972-E325-11CE-BFC1-08002BE10318}"
  18
  19 typedef struct _LAN_WQ_ITEM {
  20     LIST_ENTRY ListEntry;
  21     PNDIS_PACKET Packet;
  22     PLAN_ADAPTER Adapter;
  23     UINT BytesTransferred;
  24     BOOLEAN LegacyReceive;
  25 } LAN_WQ_ITEM, *PLAN_WQ_ITEM;
  26
  27 typedef struct _RECONFIGURE_CONTEXT {
  28     ULONG State;
  29     PLAN_ADAPTER Adapter;
  30 } RECONFIGURE_CONTEXT, *PRECONFIGURE_CONTEXT;
  31
  32 NDIS_HANDLE NdisProtocolHandle = (NDIS_HANDLE)NULL;
  33 BOOLEAN ProtocolRegistered     = FALSE;
  34 LIST_ENTRY AdapterListHead;
  35 KSPIN_LOCK AdapterListLock;
  36
  37 NDIS_STATUS NDISCall(
  38     PLAN_ADAPTER Adapter,
  39     NDIS_REQUEST_TYPE Type,
  40     NDIS_OID OID,
  41     PVOID Buffer,
  42     UINT Length)
  43 /*
  44  * FUNCTION: Send a request to NDIS
  45  * ARGUMENTS:
  46  *     Adapter     = Pointer to a LAN_ADAPTER structure
  47  *     Type        = Type of request (Set or Query)
  48  *     OID         = Value to be set/queried for
  49  *     Buffer      = Pointer to a buffer to use
  50  *     Length      = Number of bytes in Buffer
  51  * RETURNS:
  52  *     Status of operation
  53  */
  54 {
  55     NDIS_REQUEST Request;
  56     NDIS_STATUS NdisStatus;
  57
  58     Request.RequestType = Type;
  59     if (Type == NdisRequestSetInformation) {
  60         Request.DATA.SET_INFORMATION.Oid                     = OID;
  61         Request.DATA.SET_INFORMATION.InformationBuffer       = Buffer;
  62         Request.DATA.SET_INFORMATION.InformationBufferLength = Length;
  63     } else {
  64         Request.DATA.QUERY_INFORMATION.Oid                     = OID;
  65         Request.DATA.QUERY_INFORMATION.InformationBuffer       = Buffer;
  66         Request.DATA.QUERY_INFORMATION.InformationBufferLength = Length;
  67     }
  68
  69     if (Adapter->State != LAN_STATE_RESETTING) {
  70         NdisRequest(&NdisStatus, Adapter->NdisHandle, &Request);
  71     } else {
  72         NdisStatus = NDIS_STATUS_NOT_ACCEPTED;
  73     }
  74
  75     /* Wait for NDIS to complete the request */
  76     if (NdisStatus == NDIS_STATUS_PENDING) {
  77         KeWaitForSingleObject(&Adapter->Event,
  78                               UserRequest,
  79                               KernelMode,
  80                               FALSE,
  81                               NULL);
  82         NdisStatus = Adapter->NdisStatus;
  83     }
  84
  85     return NdisStatus;
  86 }
  87
  88 /* Used by legacy ProtocolReceive for packet type */
  89 NDIS_STATUS
  90 GetPacketTypeFromHeaderBuffer(PLAN_ADAPTER Adapter,
  91                               PVOID HeaderBuffer,
  92                               ULONG HeaderBufferSize,
  93                               PULONG PacketType)
  94 {
  95     PETH_HEADER EthHeader = HeaderBuffer;
  96
  97     if (HeaderBufferSize < Adapter->HeaderSize)
  98     {
  99         TI_DbgPrint(DEBUG_DATALINK, ("Runt frame (size %d).\n", HeaderBufferSize));
 100         return NDIS_STATUS_NOT_ACCEPTED;
 101     }
 102
 103     switch (Adapter->Media)
 104     {
 105         case NdisMedium802_3:
 106             /* Ethernet and IEEE 802.3 frames can be destinguished by
 107                looking at the IEEE 802.3 length field. This field is
 108                less than or equal to 1500 for a valid IEEE 802.3 frame
 109                and larger than 1500 is it's a valid EtherType value.
 110                See RFC 1122, section 2.3.3 for more information */
 111
 112             *PacketType = EthHeader->EType;
 113             break;
 114
 115         default:
 116             TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
 117
 118             /* FIXME: Support other medias */
 119             return NDIS_STATUS_NOT_ACCEPTED;
 120     }
 121
 122     TI_DbgPrint(DEBUG_DATALINK, ("EtherType (0x%X).\n", *PacketType));
 123
 124     return NDIS_STATUS_SUCCESS;
 125 }
 126
 127 /* Used by ProtocolReceivePacket for packet type */
 128 NDIS_STATUS
 129 GetPacketTypeFromNdisPacket(PLAN_ADAPTER Adapter,
 130                             PNDIS_PACKET NdisPacket,
 131                             PULONG PacketType)
 132 {
 133     PVOID HeaderBuffer;
 134     ULONG BytesCopied;
 135     NDIS_STATUS Status;
 136
 137     HeaderBuffer = ExAllocatePool(NonPagedPool,
 138                                   Adapter->HeaderSize);
 139     if (!HeaderBuffer)
 140         return NDIS_STATUS_RESOURCES;
 141
 142     /* Copy the media header */
 143     BytesCopied = CopyPacketToBuffer(HeaderBuffer,
 144                                      NdisPacket,
 145                                      0,
 146                                      Adapter->HeaderSize);
 147     if (BytesCopied != Adapter->HeaderSize)
 148     {
 149         /* Runt frame */
 150         ExFreePool(HeaderBuffer);
 151         TI_DbgPrint(DEBUG_DATALINK, ("Runt frame (size %d).\n", BytesCopied));
 152         return NDIS_STATUS_NOT_ACCEPTED;
 153     }
 154
 155     Status = GetPacketTypeFromHeaderBuffer(Adapter,
 156                                            HeaderBuffer,
 157                                            BytesCopied,
 158                                            PacketType);
 159
 160     ExFreePool(HeaderBuffer);
 161
 162     return Status;
 163 }
 164
 165
 166 VOID FreeAdapter(
 167     PLAN_ADAPTER Adapter)
 168 /*
 169  * FUNCTION: Frees memory for a LAN_ADAPTER structure
 170  * ARGUMENTS:
 171  *     Adapter = Pointer to LAN_ADAPTER structure to free
 172  */
 173 {
 174     ExFreePoolWithTag(Adapter, LAN_ADAPTER_TAG);
 175 }
 176
 177
 178 NTSTATUS TcpipLanGetDwordOid
 179 ( PIP_INTERFACE Interface,
 180   NDIS_OID Oid,
 181   PULONG Result ) {
 182     /* Get maximum frame size */
 183     if( Interface->Context ) {
 184         return NDISCall((PLAN_ADAPTER)Interface->Context,
 185                         NdisRequestQueryInformation,
 186                         Oid,
 187                         Result,
 188                         sizeof(ULONG));
 189     } else switch( Oid ) { /* Loopback Case */
 190     case OID_GEN_HARDWARE_STATUS:
 191         *Result = NdisHardwareStatusReady;
 192         return STATUS_SUCCESS;
 193     case OID_GEN_MEDIA_CONNECT_STATUS:
 194         *Result = NdisMediaStateConnected;
 195         return STATUS_SUCCESS;
 196     default:
 197         return STATUS_INVALID_PARAMETER;
 198     }
 199 }
 200
 201
 202 VOID NTAPI ProtocolOpenAdapterComplete(
 203     NDIS_HANDLE BindingContext,
 204     NDIS_STATUS Status,
 205     NDIS_STATUS OpenErrorStatus)
 206 /*
 207  * FUNCTION: Called by NDIS to complete opening of an adapter
 208  * ARGUMENTS:
 209  *     BindingContext  = Pointer to a device context (LAN_ADAPTER)
 210  *     Status          = Status of the operation
 211  *     OpenErrorStatus = Additional status information
 212  */
 213 {
 214     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 215
 216     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 217
 218     Adapter->NdisStatus = Status;
 219
 220     KeSetEvent(&Adapter->Event, 0, FALSE);
 221 }
 222
 223
 224 VOID NTAPI ProtocolCloseAdapterComplete(
 225     NDIS_HANDLE BindingContext,
 226     NDIS_STATUS Status)
 227 /*
 228  * FUNCTION: Called by NDIS to complete closing an adapter
 229  * ARGUMENTS:
 230  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 231  *     Status         = Status of the operation
 232  */
 233 {
 234     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 235
 236     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 237
 238     Adapter->NdisStatus = Status;
 239
 240     KeSetEvent(&Adapter->Event, 0, FALSE);
 241 }
 242
 243
 244 VOID NTAPI ProtocolResetComplete(
 245     NDIS_HANDLE BindingContext,
 246     NDIS_STATUS Status)
 247 /*
 248  * FUNCTION: Called by NDIS to complete resetting an adapter
 249  * ARGUMENTS:
 250  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 251  *     Status         = Status of the operation
 252  */
 253 {
 254     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 255
 256     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 257
 258     Adapter->NdisStatus = Status;
 259
 260     KeSetEvent(&Adapter->Event, 0, FALSE);
 261 }
 262
 263
 264 VOID NTAPI ProtocolRequestComplete(
 265     NDIS_HANDLE BindingContext,
 266     PNDIS_REQUEST NdisRequest,
 267     NDIS_STATUS Status)
 268 /*
 269  * FUNCTION: Called by NDIS to complete a request
 270  * ARGUMENTS:
 271  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 272  *     NdisRequest    = Pointer to an object describing the request
 273  *     Status         = Status of the operation
 274  */
 275 {
 276     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 277
 278     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 279
 280     /* Save status of request and signal an event */
 281     Adapter->NdisStatus = Status;
 282
 283     KeSetEvent(&Adapter->Event, 0, FALSE);
 284 }
 285
 286
 287 VOID NTAPI ProtocolSendComplete(
 288     NDIS_HANDLE BindingContext,
 289     PNDIS_PACKET Packet,
 290     NDIS_STATUS Status)
 291 /*
 292  * FUNCTION: Called by NDIS to complete sending process
 293  * ARGUMENTS:
 294  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 295  *     Packet         = Pointer to a packet descriptor
 296  *     Status         = Status of the operation
 297  */
 298 {
 299     FreeNdisPacket(Packet);
 300 }
 301
 302 VOID LanReceiveWorker( PVOID Context ) {
 303     ULONG PacketType;
 304     PLAN_WQ_ITEM WorkItem = (PLAN_WQ_ITEM)Context;
 305     PNDIS_PACKET Packet;
 306     PLAN_ADAPTER Adapter;
 307     UINT BytesTransferred;
 308     IP_PACKET IPPacket;
 309     BOOLEAN LegacyReceive;
 310     PIP_INTERFACE Interface;
 311
 312     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 313
 314     Packet = WorkItem->Packet;
 315     Adapter = WorkItem->Adapter;
 316     BytesTransferred = WorkItem->BytesTransferred;
 317     LegacyReceive = WorkItem->LegacyReceive;
 318
 319     ExFreePoolWithTag(WorkItem, WQ_CONTEXT_TAG);
 320
 321     Interface = Adapter->Context;
 322
 323     IPInitializePacket(&IPPacket, 0);
 324
 325     IPPacket.NdisPacket = Packet;
 326     IPPacket.ReturnPacket = !LegacyReceive;
 327
 328     if (LegacyReceive)
 329     {
 330         /* Packet type is precomputed */
 331         PacketType = PC(IPPacket.NdisPacket)->PacketType;
 332
 333         /* Data is at position 0 */
 334         IPPacket.Position = 0;
 335
 336         /* Packet size is determined by bytes transferred */
 337         IPPacket.TotalSize = BytesTransferred;
 338     }
 339     else
 340     {
 341         /* Determine packet type from media header */
 342         if (GetPacketTypeFromNdisPacket(Adapter,
 343                                         IPPacket.NdisPacket,
 344                                         &PacketType) != NDIS_STATUS_SUCCESS)
 345         {
 346             /* Bad packet */
 347             IPPacket.Free(&IPPacket);
 348             return;
 349         }
 350
 351         /* Data is at the end of the media header */
 352         IPPacket.Position = Adapter->HeaderSize;
 353
 354         /* Calculate packet size (excluding media header) */
 355         NdisQueryPacketLength(IPPacket.NdisPacket, &IPPacket.TotalSize);
 356     }
 357
 358     TI_DbgPrint
 359         (DEBUG_DATALINK,
 360          ("Ether Type = %x Total = %d\n",
 361           PacketType, IPPacket.TotalSize));
 362
 363     /* Update interface stats */
 364     Interface->Stats.InBytes += IPPacket.TotalSize + Adapter->HeaderSize;
 365
 366     /* NDIS packet is freed in all of these cases */
 367     switch (PacketType) {
 368         case ETYPE_IPv4:
 369         case ETYPE_IPv6:
 370             TI_DbgPrint(MID_TRACE,("Received IP Packet\n"));
 371             IPReceive(Adapter->Context, &IPPacket);
 372             break;
 373         case ETYPE_ARP:
 374             TI_DbgPrint(MID_TRACE,("Received ARP Packet\n"));
 375             ARPReceive(Adapter->Context, &IPPacket);
 376             break;
 377         default:
 378             IPPacket.Free(&IPPacket);
 379             break;
 380     }
 381 }
 382
 383 VOID LanSubmitReceiveWork(
 384     NDIS_HANDLE BindingContext,
 385     PNDIS_PACKET Packet,
 386     UINT BytesTransferred,
 387     BOOLEAN LegacyReceive) {
 388     PLAN_WQ_ITEM WQItem = ExAllocatePoolWithTag(NonPagedPool, sizeof(LAN_WQ_ITEM),
 389                                                 WQ_CONTEXT_TAG);
 390     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 391
 392     TI_DbgPrint(DEBUG_DATALINK,("called\n"));
 393
 394     if (!WQItem) return;
 395
 396     WQItem->Packet = Packet;
 397     WQItem->Adapter = Adapter;
 398     WQItem->BytesTransferred = BytesTransferred;
 399     WQItem->LegacyReceive = LegacyReceive;
 400
 401     if (!ChewCreate( LanReceiveWorker, WQItem ))
 402         ExFreePoolWithTag(WQItem, WQ_CONTEXT_TAG);
 403 }
 404
 405 VOID NTAPI ProtocolTransferDataComplete(
 406     NDIS_HANDLE BindingContext,
 407     PNDIS_PACKET Packet,
 408     NDIS_STATUS Status,
 409     UINT BytesTransferred)
 410 /*
 411  * FUNCTION: Called by NDIS to complete reception of data
 412  * ARGUMENTS:
 413  *     BindingContext   = Pointer to a device context (LAN_ADAPTER)
 414  *     Packet           = Pointer to a packet descriptor
 415  *     Status           = Status of the operation
 416  *     BytesTransferred = Number of bytes transferred
 417  * NOTES:
 418  *     If the packet was successfully received, determine the protocol
 419  *     type and pass it to the correct receive handler
 420  */
 421 {
 422     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 423
 424     TI_DbgPrint(DEBUG_DATALINK,("called\n"));
 425
 426     TransferDataCompleteCalled++;
 427     ASSERT(TransferDataCompleteCalled <= TransferDataCalled);
 428
 429     if( Status != NDIS_STATUS_SUCCESS ) return;
 430
 431     LanSubmitReceiveWork(BindingContext,
 432                          Packet,
 433                          BytesTransferred,
 434                          TRUE);
 435 }
 436
 437 INT NTAPI ProtocolReceivePacket(
 438     NDIS_HANDLE BindingContext,
 439     PNDIS_PACKET NdisPacket)
 440 {
 441     PLAN_ADAPTER Adapter = BindingContext;
 442
 443     if (Adapter->State != LAN_STATE_STARTED) {
 444         TI_DbgPrint(DEBUG_DATALINK, ("Adapter is stopped.\n"));
 445         return 0;
 446     }
 447
 448     LanSubmitReceiveWork(BindingContext,
 449                          NdisPacket,
 450                          0, /* Unused */
 451                          FALSE);
 452
 453     /* Hold 1 reference on this packet */
 454     return 1;
 455 }
 456
 457 NDIS_STATUS NTAPI ProtocolReceive(
 458     NDIS_HANDLE BindingContext,
 459     NDIS_HANDLE MacReceiveContext,
 460     PVOID HeaderBuffer,
 461     UINT HeaderBufferSize,
 462     PVOID LookaheadBuffer,
 463     UINT LookaheadBufferSize,
 464     UINT PacketSize)
 465 /*
 466  * FUNCTION: Called by NDIS when a packet has been received on the physical link
 467  * ARGUMENTS:
 468  *     BindingContext      = Pointer to a device context (LAN_ADAPTER)
 469  *     MacReceiveContext   = Handle used by underlying NIC driver
 470  *     HeaderBuffer        = Pointer to a buffer containing the packet header
 471  *     HeaderBufferSize    = Number of bytes in HeaderBuffer
 472  *     LookaheadBuffer     = Pointer to a buffer containing buffered packet data
 473  *     LookaheadBufferSize = Size of LookaheadBuffer. May be less than asked for
 474  *     PacketSize          = Overall size of the packet (not including header)
 475  * RETURNS:
 476  *     Status of operation
 477  */
 478 {
 479     ULONG PacketType;
 480     UINT BytesTransferred;
 481     PCHAR BufferData;
 482     NDIS_STATUS NdisStatus;
 483     PNDIS_PACKET NdisPacket;
 484     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)BindingContext;
 485
 486     TI_DbgPrint(DEBUG_DATALINK, ("Called. (packetsize %d)\n",PacketSize));
 487
 488     if (Adapter->State != LAN_STATE_STARTED) {
 489         TI_DbgPrint(DEBUG_DATALINK, ("Adapter is stopped.\n"));
 490         return NDIS_STATUS_NOT_ACCEPTED;
 491     }
 492
 493     if (HeaderBufferSize < Adapter->HeaderSize) {
 494         TI_DbgPrint(DEBUG_DATALINK, ("Runt frame received.\n"));
 495         return NDIS_STATUS_NOT_ACCEPTED;
 496     }
 497
 498     NdisStatus = GetPacketTypeFromHeaderBuffer(Adapter,
 499                                                HeaderBuffer,
 500                                                HeaderBufferSize,
 501                                                &PacketType);
 502     if (NdisStatus != NDIS_STATUS_SUCCESS)
 503         return NDIS_STATUS_NOT_ACCEPTED;
 504
 505     TI_DbgPrint(DEBUG_DATALINK, ("Adapter: %x (MTU %d)\n",
 506                                  Adapter, Adapter->MTU));
 507
 508     /* Get a transfer data packet */
 509     NdisStatus = AllocatePacketWithBuffer( &NdisPacket, NULL,
 510                                            PacketSize );
 511     if( NdisStatus != NDIS_STATUS_SUCCESS ) {
 512         return NDIS_STATUS_NOT_ACCEPTED;
 513     }
 514
 515     PC(NdisPacket)->PacketType = PacketType;
 516
 517     TI_DbgPrint(DEBUG_DATALINK, ("pretransfer LookaheadBufferSize %d packsize %d\n",LookaheadBufferSize,PacketSize));
 518
 519     GetDataPtr( NdisPacket, 0, &BufferData, &PacketSize );
 520
 521     TransferDataCalled++;
 522
 523     if (LookaheadBufferSize == PacketSize)
 524     {
 525         /* Optimized code path for packets that are fully contained in
 526          * the lookahead buffer. */
 527         NdisCopyLookaheadData(BufferData,
 528                               LookaheadBuffer,
 529                               LookaheadBufferSize,
 530                               Adapter->MacOptions);
 531     }
 532     else
 533     {
 534         NdisTransferData(&NdisStatus, Adapter->NdisHandle,
 535                          MacReceiveContext, 0, PacketSize,
 536                          NdisPacket, &BytesTransferred);
 537     }
 538     TI_DbgPrint(DEBUG_DATALINK, ("Calling complete\n"));
 539
 540     if (NdisStatus != NDIS_STATUS_PENDING)
 541         ProtocolTransferDataComplete(BindingContext,
 542                                      NdisPacket,
 543                                      NdisStatus,
 544                                      PacketSize);
 545
 546     TI_DbgPrint(DEBUG_DATALINK, ("leaving\n"));
 547
 548     return NDIS_STATUS_SUCCESS;
 549 }
 550
 551
 552 VOID NTAPI ProtocolReceiveComplete(
 553     NDIS_HANDLE BindingContext)
 554 /*
 555  * FUNCTION: Called by NDIS when we're done receiving data
 556  * ARGUMENTS:
 557  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 558  */
 559 {
 560     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 561 }
 562
 563 BOOLEAN ReadIpConfiguration(PIP_INTERFACE Interface)
 564 {
 565     OBJECT_ATTRIBUTES ObjectAttributes;
 566     HANDLE ParameterHandle;
 567     PKEY_VALUE_PARTIAL_INFORMATION KeyValueInfo;
 568     WCHAR Buffer[150];
 569     UNICODE_STRING IPAddress = RTL_CONSTANT_STRING(L"IPAddress");
 570     UNICODE_STRING Netmask = RTL_CONSTANT_STRING(L"SubnetMask");
 571     UNICODE_STRING Gateway = RTL_CONSTANT_STRING(L"DefaultGateway");
 572     UNICODE_STRING EnableDhcp = RTL_CONSTANT_STRING(L"EnableDHCP");
 573     UNICODE_STRING Prefix = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\");
 574     UNICODE_STRING TcpipRegistryPath;
 575     UNICODE_STRING RegistryDataU;
 576     ANSI_STRING RegistryDataA;
 577     ULONG Unused;
 578     NTSTATUS Status;
 579     IP_ADDRESS DefaultMask, Router;
 580
 581     AddrInitIPv4(&DefaultMask, 0);
 582
 583     TcpipRegistryPath.MaximumLength = sizeof(WCHAR) * 150;
 584     TcpipRegistryPath.Length = 0;
 585     TcpipRegistryPath.Buffer = Buffer;
 586
 587     /* Build the registry path */
 588     RtlAppendUnicodeStringToString(&TcpipRegistryPath, &Prefix);
 589     RtlAppendUnicodeStringToString(&TcpipRegistryPath, &Interface->Name);
 590
 591     InitializeObjectAttributes(&ObjectAttributes,
 592                                &TcpipRegistryPath,
 593                                OBJ_CASE_INSENSITIVE,
 594                                0,
 595                                NULL);
 596
 597     /* Open a handle to the adapter parameters */
 598     Status = ZwOpenKey(&ParameterHandle, KEY_READ, &ObjectAttributes);
 599
 600     if (!NT_SUCCESS(Status))
 601     {
 602         return FALSE;
 603     }
 604     else
 605     {
 606         KeyValueInfo = ExAllocatePool(PagedPool, sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 16 * sizeof(WCHAR));
 607         if (!KeyValueInfo)
 608         {
 609             ZwClose(ParameterHandle);
 610             return FALSE;
 611         }
 612
 613         /* Read the EnableDHCP entry */
 614         Status = ZwQueryValueKey(ParameterHandle,
 615                                  &EnableDhcp,
 616                                  KeyValuePartialInformation,
 617                                  KeyValueInfo,
 618                                  sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG),
 619                                  &Unused);
 620         if (NT_SUCCESS(Status) && KeyValueInfo->DataLength == sizeof(ULONG) && (*(PULONG)KeyValueInfo->Data) == 0)
 621         {
 622             RegistryDataU.MaximumLength = 16 + sizeof(WCHAR);
 623             RegistryDataU.Buffer = (PWCHAR)KeyValueInfo->Data;
 624
 625             /* Read the IP address */
 626             Status = ZwQueryValueKey(ParameterHandle,
 627                                      &IPAddress,
 628                                      KeyValuePartialInformation,
 629                                      KeyValueInfo,
 630                                      sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 16 * sizeof(WCHAR),
 631                                      &Unused);
 632             if (NT_SUCCESS(Status))
 633             {
 634                 RegistryDataU.Length = KeyValueInfo->DataLength;
 635
 636                 RtlUnicodeStringToAnsiString(&RegistryDataA,
 637                                              &RegistryDataU,
 638                                              TRUE);
 639
 640                 AddrInitIPv4(&Interface->Unicast, inet_addr(RegistryDataA.Buffer));
 641
 642                 RtlFreeAnsiString(&RegistryDataA);
 643             }
 644
 645             Status = ZwQueryValueKey(ParameterHandle,
 646                                      &Netmask,
 647                                      KeyValuePartialInformation,
 648                                      KeyValueInfo,
 649                                      sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 16 * sizeof(WCHAR),
 650                                      &Unused);
 651             if (NT_SUCCESS(Status))
 652             {
 653                 RegistryDataU.Length = KeyValueInfo->DataLength;
 654
 655                 RtlUnicodeStringToAnsiString(&RegistryDataA,
 656                                              &RegistryDataU,
 657                                              TRUE);
 658
 659                 AddrInitIPv4(&Interface->Netmask, inet_addr(RegistryDataA.Buffer));
 660
 661                 RtlFreeAnsiString(&RegistryDataA);
 662             }
 663
 664             /* We have to wait until both IP address and subnet mask
 665              * are read to add the interface route, but we must do it
 666              * before we add the default gateway */
 667             if (!AddrIsUnspecified(&Interface->Unicast) &&
 668                 !AddrIsUnspecified(&Interface->Netmask))
 669                 IPAddInterfaceRoute(Interface);
 670
 671             /* Read default gateway info */
 672             Status = ZwQueryValueKey(ParameterHandle,
 673                                      &Gateway,
 674                                      KeyValuePartialInformation,
 675                                      KeyValueInfo,
 676                                      sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 16 * sizeof(WCHAR),
 677                                      &Unused);
 678             if (NT_SUCCESS(Status))
 679             {
 680                 RegistryDataU.Length = KeyValueInfo->DataLength;
 681
 682                 RtlUnicodeStringToAnsiString(&RegistryDataA,
 683                                              &RegistryDataU,
 684                                              TRUE);
 685
 686                 AddrInitIPv4(&Router, inet_addr(RegistryDataA.Buffer));
 687
 688                 if (!AddrIsUnspecified(&Router))
 689                     RouterCreateRoute(&DefaultMask, &DefaultMask, &Router, Interface, 1);
 690
 691                 RtlFreeAnsiString(&RegistryDataA);
 692             }
 693         }
 694
 695         ZwClose(ParameterHandle);
 696     }
 697
 698     return TRUE;
 699 }
 700
 701 BOOLEAN ReconfigureAdapter(PRECONFIGURE_CONTEXT Context)
 702 {
 703     PLAN_ADAPTER Adapter = Context->Adapter;
 704     PIP_INTERFACE Interface = Adapter->Context;
 705     //NDIS_STATUS NdisStatus;
 706     IP_ADDRESS DefaultMask;
 707
 708     /* Initalize the default unspecified address (0.0.0.0) */
 709     AddrInitIPv4(&DefaultMask, 0);
 710     if (Context->State == LAN_STATE_STARTED &&
 711         !Context->Adapter->CompletingReset)
 712     {
 713         /* Read the IP configuration */
 714         ReadIpConfiguration(Interface);
 715
 716         /* Compute the broadcast address */
 717         Interface->Broadcast.Type = IP_ADDRESS_V4;
 718         Interface->Broadcast.Address.IPv4Address = Interface->Unicast.Address.IPv4Address |
 719                                                   ~Interface->Netmask.Address.IPv4Address;
 720     }
 721     else if (!Context->Adapter->CompletingReset)
 722     {
 723         /* Clear IP configuration */
 724         Interface->Unicast = DefaultMask;
 725         Interface->Netmask = DefaultMask;
 726         Interface->Broadcast = DefaultMask;
 727
 728         /* Remove all interface routes */
 729         RouterRemoveRoutesForInterface(Interface);
 730
 731         /* Destroy all cached neighbors */
 732         NBDestroyNeighborsForInterface(Interface);
 733     }
 734
 735     Context->Adapter->CompletingReset = FALSE;
 736
 737     /* We're done here if the adapter isn't connected */
 738     if (Context->State != LAN_STATE_STARTED)
 739     {
 740         Adapter->State = Context->State;
 741         return TRUE;
 742     }
 743
 744     /* NDIS Bug! */
 745 #if 0
 746     /* Get maximum link speed */
 747     NdisStatus = NDISCall(Adapter,
 748                           NdisRequestQueryInformation,
 749                           OID_GEN_LINK_SPEED,
 750                           &Interface->Speed,
 751                           sizeof(UINT));
 752
 753     if (!NT_SUCCESS(NdisStatus))
 754         Interface->Speed = IP_DEFAULT_LINK_SPEED;
 755
 756     Adapter->Speed = Interface->Speed * 100L;
 757
 758     /* Get maximum frame size */
 759     NdisStatus = NDISCall(Adapter,
 760                           NdisRequestQueryInformation,
 761                           OID_GEN_MAXIMUM_FRAME_SIZE,
 762                           &Adapter->MTU,
 763                           sizeof(UINT));
 764     if (NdisStatus != NDIS_STATUS_SUCCESS)
 765         return FALSE;
 766
 767     Interface->MTU = Adapter->MTU;
 768
 769     /* Get maximum packet size */
 770     NdisStatus = NDISCall(Adapter,
 771                           NdisRequestQueryInformation,
 772                           OID_GEN_MAXIMUM_TOTAL_SIZE,
 773                           &Adapter->MaxPacketSize,
 774                           sizeof(UINT));
 775     if (NdisStatus != NDIS_STATUS_SUCCESS)
 776         return FALSE;
 777 #endif
 778
 779     Adapter->State = Context->State;
 780
 781     return TRUE;
 782 }
 783
 784 VOID ReconfigureAdapterWorker(PVOID Context)
 785 {
 786     PRECONFIGURE_CONTEXT ReconfigureContext = Context;
 787
 788     /* Complete the reconfiguration asynchronously */
 789     ReconfigureAdapter(ReconfigureContext);
 790
 791     /* Free the context */
 792     ExFreePool(ReconfigureContext);
 793 }
 794
 795 VOID NTAPI ProtocolStatus(
 796     NDIS_HANDLE BindingContext,
 797     NDIS_STATUS GeneralStatus,
 798     PVOID StatusBuffer,
 799     UINT StatusBufferSize)
 800 /*
 801  * FUNCTION: Called by NDIS when the underlying driver has changed state
 802  * ARGUMENTS:
 803  *     BindingContext   = Pointer to a device context (LAN_ADAPTER)
 804  *     GeneralStatus    = A general status code
 805  *     StatusBuffer     = Pointer to a buffer with medium-specific data
 806  *     StatusBufferSize = Number of bytes in StatusBuffer
 807  */
 808 {
 809     PLAN_ADAPTER Adapter = BindingContext;
 810     PRECONFIGURE_CONTEXT Context;
 811
 812     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 813
 814     Context = ExAllocatePool(NonPagedPool, sizeof(RECONFIGURE_CONTEXT));
 815     if (!Context)
 816         return;
 817
 818     Context->Adapter = Adapter;
 819
 820     switch(GeneralStatus)
 821     {
 822         case NDIS_STATUS_MEDIA_CONNECT:
 823             DbgPrint("NDIS_STATUS_MEDIA_CONNECT\n");
 824
 825             if (Adapter->State == LAN_STATE_STARTED)
 826             {
 827                 ExFreePool(Context);
 828                 return;
 829             }
 830
 831             Context->State = LAN_STATE_STARTED;
 832             break;
 833
 834         case NDIS_STATUS_MEDIA_DISCONNECT:
 835             DbgPrint("NDIS_STATUS_MEDIA_DISCONNECT\n");
 836
 837             if (Adapter->State == LAN_STATE_STOPPED)
 838             {
 839                 ExFreePool(Context);
 840                 return;
 841             }
 842
 843             Context->State = LAN_STATE_STOPPED;
 844             break;
 845
 846         case NDIS_STATUS_RESET_START:
 847             Adapter->OldState = Adapter->State;
 848             Adapter->State = LAN_STATE_RESETTING;
 849             /* Nothing else to do here */
 850             ExFreePool(Context);
 851             return;
 852
 853         case NDIS_STATUS_RESET_END:
 854             Adapter->CompletingReset = TRUE;
 855             Context->State = Adapter->OldState;
 856             break;
 857
 858         default:
 859             DbgPrint("Unhandled status: %x", GeneralStatus);
 860             ExFreePool(Context);
 861             return;
 862     }
 863
 864     /* Queue the work item */
 865     if (!ChewCreate(ReconfigureAdapterWorker, Context))
 866         ExFreePool(Context);
 867 }
 868
 869 VOID NTAPI ProtocolStatusComplete(NDIS_HANDLE NdisBindingContext)
 870 /*
 871  * FUNCTION: Called by NDIS when a status-change has occurred
 872  * ARGUMENTS:
 873  *     BindingContext = Pointer to a device context (LAN_ADAPTER)
 874  */
 875 {
 876     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
 877 }
 878
 879 NDIS_STATUS NTAPI
 880 ProtocolPnPEvent(
 881     NDIS_HANDLE NdisBindingContext,
 882     PNET_PNP_EVENT PnPEvent)
 883 {
 884     switch(PnPEvent->NetEvent)
 885     {
 886       case NetEventSetPower:
 887          DbgPrint("Device transitioned to power state %ld\n", PnPEvent->Buffer);
 888          return NDIS_STATUS_SUCCESS;
 889
 890       case NetEventQueryPower:
 891          DbgPrint("Device wants to go into power state %ld\n", PnPEvent->Buffer);
 892          return NDIS_STATUS_SUCCESS;
 893
 894       case NetEventQueryRemoveDevice:
 895          DbgPrint("Device is about to be removed\n");
 896          return NDIS_STATUS_SUCCESS;
 897
 898       case NetEventCancelRemoveDevice:
 899          DbgPrint("Device removal cancelled\n");
 900          return NDIS_STATUS_SUCCESS;
 901
 902       default:
 903          DbgPrint("Unhandled event type: %ld\n", PnPEvent->NetEvent);
 904          return NDIS_STATUS_SUCCESS;
 905     }
 906 }
 907
 908 VOID NTAPI ProtocolBindAdapter(
 909     OUT PNDIS_STATUS   Status,
 910     IN  NDIS_HANDLE    BindContext,
 911     IN  PNDIS_STRING   DeviceName,
 912     IN  PVOID          SystemSpecific1,
 913     IN  PVOID          SystemSpecific2)
 914 /*
 915  * FUNCTION: Called by NDIS during NdisRegisterProtocol to set up initial
 916  *           bindings, and periodically thereafer as new adapters come online
 917  * ARGUMENTS:
 918  *     Status: Return value to NDIS
 919  *     BindContext: Handle provided by NDIS to track pending binding operations
 920  *     DeviceName: Name of the miniport device to bind to
 921  *     SystemSpecific1: Pointer to a registry path with protocol-specific configuration information
 922  *     SystemSpecific2: Unused & must not be touched
 923  */
 924 {
 925     TI_DbgPrint(DEBUG_DATALINK, ("Called with registry path %wZ for %wZ\n", SystemSpecific1, DeviceName));
 926     *Status = LANRegisterAdapter(DeviceName, SystemSpecific1);
 927 }
 928
 929
 930 VOID LANTransmit(
 931     PVOID Context,
 932     PNDIS_PACKET NdisPacket,
 933     UINT Offset,
 934     PVOID LinkAddress,
 935     USHORT Type)
 936 /*
 937  * FUNCTION: Transmits a packet
 938  * ARGUMENTS:
 939  *     Context     = Pointer to context information (LAN_ADAPTER)
 940  *     NdisPacket  = Pointer to NDIS packet to send
 941  *     Offset      = Offset in packet where data starts
 942  *     LinkAddress = Pointer to link address of destination (NULL = broadcast)
 943  *     Type        = LAN protocol type (LAN_PROTO_*)
 944  */
 945 {
 946     NDIS_STATUS NdisStatus;
 947     PETH_HEADER EHeader;
 948     PCHAR Data, OldData;
 949     UINT Size, OldSize;
 950     PLAN_ADAPTER Adapter = (PLAN_ADAPTER)Context;
 951     KIRQL OldIrql;
 952     PNDIS_PACKET XmitPacket;
 953     PIP_INTERFACE Interface = Adapter->Context;
 954
 955     TI_DbgPrint(DEBUG_DATALINK,
 956                 ("Called( NdisPacket %x, Offset %d, Adapter %x )\n",
 957                  NdisPacket, Offset, Adapter));
 958
 959     if (Adapter->State != LAN_STATE_STARTED) {
 960         (*PC(NdisPacket)->DLComplete)(PC(NdisPacket)->Context, NdisPacket, NDIS_STATUS_NOT_ACCEPTED);
 961         return;
 962     }
 963
 964     TI_DbgPrint(DEBUG_DATALINK,
 965                 ("Adapter Address [%02x %02x %02x %02x %02x %02x]\n",
 966                  Adapter->HWAddress[0] & 0xff,
 967                  Adapter->HWAddress[1] & 0xff,
 968                  Adapter->HWAddress[2] & 0xff,
 969                  Adapter->HWAddress[3] & 0xff,
 970                  Adapter->HWAddress[4] & 0xff,
 971                  Adapter->HWAddress[5] & 0xff));
 972
 973     GetDataPtr( NdisPacket, 0, &OldData, &OldSize );
 974
 975     NdisStatus = AllocatePacketWithBuffer(&XmitPacket, NULL, OldSize + Adapter->HeaderSize);
 976     if (NdisStatus != NDIS_STATUS_SUCCESS) {
 977         (*PC(NdisPacket)->DLComplete)(PC(NdisPacket)->Context, NdisPacket, NDIS_STATUS_RESOURCES);
 978         return;
 979     }
 980
 981     GetDataPtr(XmitPacket, 0, &Data, &Size);
 982
 983     RtlCopyMemory(Data + Adapter->HeaderSize, OldData, OldSize);
 984
 985     (*PC(NdisPacket)->DLComplete)(PC(NdisPacket)->Context, NdisPacket, NDIS_STATUS_SUCCESS);
 986
 987     switch (Adapter->Media) {
 988         case NdisMedium802_3:
 989             EHeader = (PETH_HEADER)Data;
 990
 991             if (LinkAddress) {
 992                 /* Unicast address */
 993                 RtlCopyMemory(EHeader->DstAddr, LinkAddress, IEEE_802_ADDR_LENGTH);
 994             } else {
 995                 /* Broadcast address */
 996                 RtlFillMemory(EHeader->DstAddr, IEEE_802_ADDR_LENGTH, 0xFF);
 997             }
 998
 999             RtlCopyMemory(EHeader->SrcAddr, Adapter->HWAddress, IEEE_802_ADDR_LENGTH);
1000
1001             switch (Type) {
1002                 case LAN_PROTO_IPv4:
1003                     EHeader->EType = ETYPE_IPv4;
1004                     break;
1005                 case LAN_PROTO_ARP:
1006                     EHeader->EType = ETYPE_ARP;
1007                     break;
1008                 case LAN_PROTO_IPv6:
1009                     EHeader->EType = ETYPE_IPv6;
1010                     break;
1011                 default:
1012                     ASSERT(FALSE);
1013                     return;
1014             }
1015             break;
1016
1017         default:
1018             /* FIXME: Support other medias */
1019             break;
1020     }
1021
1022         TI_DbgPrint( MID_TRACE, ("LinkAddress: %x\n", LinkAddress));
1023         if( LinkAddress ) {
1024             TI_DbgPrint
1025                 ( MID_TRACE,
1026                   ("Link Address [%02x %02x %02x %02x %02x %02x]\n",
1027                    ((PCHAR)LinkAddress)[0] & 0xff,
1028                    ((PCHAR)LinkAddress)[1] & 0xff,
1029                    ((PCHAR)LinkAddress)[2] & 0xff,
1030                    ((PCHAR)LinkAddress)[3] & 0xff,
1031                    ((PCHAR)LinkAddress)[4] & 0xff,
1032                    ((PCHAR)LinkAddress)[5] & 0xff));
1033         }
1034
1035     if (Adapter->MTU < Size) {
1036         /* This is NOT a pointer. MSDN explicitly says so. */
1037         NDIS_PER_PACKET_INFO_FROM_PACKET(NdisPacket,
1038                                          TcpLargeSendPacketInfo) = (PVOID)((ULONG_PTR)Adapter->MTU);
1039     }
1040
1041     /* Update interface stats */
1042     Interface->Stats.OutBytes += Size;
1043
1044         TcpipAcquireSpinLock( &Adapter->Lock, &OldIrql );
1045         TI_DbgPrint(MID_TRACE, ("NdisSend\n"));
1046         NdisSend(&NdisStatus, Adapter->NdisHandle, XmitPacket);
1047         TI_DbgPrint(MID_TRACE, ("NdisSend %s\n",
1048                                 NdisStatus == NDIS_STATUS_PENDING ?
1049                                 "Pending" : "Complete"));
1050         TcpipReleaseSpinLock( &Adapter->Lock, OldIrql );
1051
1052         /* I had a talk with vizzini: these really ought to be here.
1053          * we're supposed to see these completed by ndis *only* when
1054          * status_pending is returned.  Note that this is different from
1055          * the situation with IRPs. */
1056         if (NdisStatus != NDIS_STATUS_PENDING)
1057             ProtocolSendComplete((NDIS_HANDLE)Context, XmitPacket, NdisStatus);
1058 }
1059
1060 static NTSTATUS
1061 OpenRegistryKey( PNDIS_STRING RegistryPath, PHANDLE RegHandle ) {
1062     OBJECT_ATTRIBUTES Attributes;
1063     NTSTATUS Status;
1064
1065     InitializeObjectAttributes(&Attributes, RegistryPath, OBJ_CASE_INSENSITIVE, 0, 0);
1066     Status = ZwOpenKey(RegHandle, KEY_ALL_ACCESS, &Attributes);
1067     return Status;
1068 }
1069
1070 static NTSTATUS ReadStringFromRegistry( HANDLE RegHandle,
1071                                         PWCHAR RegistryValue,
1072                                         PUNICODE_STRING String ) {
1073     UNICODE_STRING ValueName;
1074     UNICODE_STRING UnicodeString;
1075     NTSTATUS Status;
1076     ULONG ResultLength;
1077     UCHAR buf[1024];
1078     PKEY_VALUE_PARTIAL_INFORMATION Information = (PKEY_VALUE_PARTIAL_INFORMATION)buf;
1079
1080     RtlInitUnicodeString(&ValueName, RegistryValue);
1081     Status =
1082         ZwQueryValueKey(RegHandle,
1083                         &ValueName,
1084                         KeyValuePartialInformation,
1085                         Information,
1086                         sizeof(buf),
1087                         &ResultLength);
1088
1089     if (!NT_SUCCESS(Status))
1090         return Status;
1091     /* IP address is stored as a REG_MULTI_SZ - we only pay attention to the first one though */
1092     TI_DbgPrint(MIN_TRACE, ("Information DataLength: 0x%x\n", Information->DataLength));
1093
1094     UnicodeString.Buffer = (PWCHAR)&Information->Data;
1095     UnicodeString.Length = Information->DataLength - sizeof(WCHAR);
1096     UnicodeString.MaximumLength = Information->DataLength;
1097
1098     String->Buffer =
1099         (PWCHAR)ExAllocatePool( NonPagedPool,
1100                                 UnicodeString.MaximumLength + sizeof(WCHAR) );
1101
1102     if( !String->Buffer ) return STATUS_NO_MEMORY;
1103
1104     String->MaximumLength = UnicodeString.MaximumLength;
1105     RtlCopyUnicodeString( String, &UnicodeString );
1106
1107     return STATUS_SUCCESS;
1108 }
1109
1110 /*
1111  * Utility to copy and append two unicode strings.
1112  *
1113  * IN OUT PUNICODE_STRING ResultFirst -> First string and result
1114  * IN     PUNICODE_STRING Second      -> Second string to append
1115  * IN     BOOL            Deallocate  -> TRUE: Deallocate First string before
1116  *                                       overwriting.
1117  *
1118  * Returns NTSTATUS.
1119  */
1120
1121 NTSTATUS NTAPI AppendUnicodeString(PUNICODE_STRING ResultFirst,
1122                                    PUNICODE_STRING Second,
1123                                    BOOLEAN Deallocate) {
1124     NTSTATUS Status;
1125     UNICODE_STRING Ustr = *ResultFirst;
1126     PWSTR new_string = ExAllocatePool
1127         (PagedPool,
1128          (ResultFirst->Length + Second->Length + sizeof(WCHAR)));
1129     if( !new_string ) {
1130         return STATUS_NO_MEMORY;
1131     }
1132     memcpy( new_string, ResultFirst->Buffer, ResultFirst->Length );
1133     memcpy( new_string + ResultFirst->Length / sizeof(WCHAR),
1134             Second->Buffer, Second->Length );
1135     if( Deallocate ) RtlFreeUnicodeString(ResultFirst);
1136     ResultFirst->Length = Ustr.Length + Second->Length;
1137     ResultFirst->MaximumLength = ResultFirst->Length;
1138     new_string[ResultFirst->Length / sizeof(WCHAR)] = 0;
1139     Status = RtlCreateUnicodeString(ResultFirst,new_string) ?
1140         STATUS_SUCCESS : STATUS_NO_MEMORY;
1141     ExFreePool(new_string);
1142     return Status;
1143 }
1144
1145 static NTSTATUS CheckForDeviceDesc( PUNICODE_STRING EnumKeyName,
1146                                     PUNICODE_STRING TargetKeyName,
1147                                     PUNICODE_STRING Name,
1148                                     PUNICODE_STRING DeviceDesc ) {
1149     UNICODE_STRING RootDevice = { 0, 0, NULL }, LinkageKeyName = { 0, 0, NULL };
1150     UNICODE_STRING DescKeyName = { 0, 0, NULL }, Linkage = { 0, 0, NULL };
1151     UNICODE_STRING BackSlash = { 0, 0, NULL };
1152     HANDLE DescKey = NULL, LinkageKey = NULL;
1153     NTSTATUS Status;
1154
1155     TI_DbgPrint(DEBUG_DATALINK,("EnumKeyName %wZ\n", EnumKeyName));
1156
1157     RtlInitUnicodeString(&BackSlash, L"\\");
1158     RtlInitUnicodeString(&Linkage, L"\\Linkage");
1159
1160     RtlInitUnicodeString(&DescKeyName, L"");
1161     AppendUnicodeString( &DescKeyName, EnumKeyName, FALSE );
1162     AppendUnicodeString( &DescKeyName, &BackSlash, TRUE );
1163     AppendUnicodeString( &DescKeyName, TargetKeyName, TRUE );
1164
1165     RtlInitUnicodeString(&LinkageKeyName, L"");
1166     AppendUnicodeString( &LinkageKeyName, &DescKeyName, FALSE );
1167     AppendUnicodeString( &LinkageKeyName, &Linkage, TRUE );
1168
1169     Status = OpenRegistryKey( &LinkageKeyName, &LinkageKey );
1170     if( !NT_SUCCESS(Status) ) goto cleanup;
1171
1172     Status = ReadStringFromRegistry( LinkageKey, L"RootDevice", &RootDevice );
1173     if( !NT_SUCCESS(Status) ) goto cleanup;
1174
1175     if( RtlCompareUnicodeString( &RootDevice, Name, TRUE ) == 0 ) {
1176         Status = OpenRegistryKey( &DescKeyName, &DescKey );
1177         if( !NT_SUCCESS(Status) ) goto cleanup;
1178
1179         Status = ReadStringFromRegistry( DescKey, L"DriverDesc", DeviceDesc );
1180         if( !NT_SUCCESS(Status) ) goto cleanup;
1181
1182         TI_DbgPrint(DEBUG_DATALINK,("ADAPTER DESC: %wZ\n", DeviceDesc));
1183     } else Status = STATUS_UNSUCCESSFUL;
1184
1185 cleanup:
1186     RtlFreeUnicodeString( &RootDevice );
1187     RtlFreeUnicodeString( &LinkageKeyName );
1188     RtlFreeUnicodeString( &DescKeyName );
1189     if( LinkageKey ) NtClose( LinkageKey );
1190     if( DescKey ) NtClose( DescKey );
1191
1192     TI_DbgPrint(DEBUG_DATALINK,("Returning %x\n", Status));
1193
1194     return Status;
1195 }
1196
1197 static NTSTATUS FindDeviceDescForAdapter( PUNICODE_STRING Name,
1198                                           PUNICODE_STRING DeviceDesc ) {
1199     UNICODE_STRING EnumKeyName, TargetKeyName;
1200     HANDLE EnumKey;
1201     NTSTATUS Status;
1202     ULONG i;
1203     KEY_BASIC_INFORMATION *Kbio =
1204         ExAllocatePool(NonPagedPool, sizeof(KEY_BASIC_INFORMATION));
1205     ULONG KbioLength = sizeof(KEY_BASIC_INFORMATION), ResultLength;
1206
1207     RtlInitUnicodeString( DeviceDesc, NULL );
1208
1209     if( !Kbio ) return STATUS_INSUFFICIENT_RESOURCES;
1210
1211     RtlInitUnicodeString
1212         (&EnumKeyName, CCS_ROOT L"\\Control\\Class\\" TCPIP_GUID);
1213
1214     Status = OpenRegistryKey( &EnumKeyName, &EnumKey );
1215
1216     if( !NT_SUCCESS(Status) ) {
1217         TI_DbgPrint(DEBUG_DATALINK,("Couldn't open Enum key %wZ: %x\n",
1218                                     &EnumKeyName, Status));
1219         ExFreePool( Kbio );
1220         return Status;
1221     }
1222
1223     for( i = 0; NT_SUCCESS(Status); i++ ) {
1224         Status = ZwEnumerateKey( EnumKey, i, KeyBasicInformation,
1225                                  Kbio, KbioLength, &ResultLength );
1226
1227         if( Status == STATUS_BUFFER_TOO_SMALL || Status == STATUS_BUFFER_OVERFLOW ) {
1228             ExFreePool( Kbio );
1229             KbioLength = ResultLength;
1230             Kbio = ExAllocatePool( NonPagedPool, KbioLength );
1231             if( !Kbio ) {
1232                 TI_DbgPrint(DEBUG_DATALINK,("Failed to allocate memory\n"));
1233                 NtClose( EnumKey );
1234                 return STATUS_NO_MEMORY;
1235             }
1236
1237             Status = ZwEnumerateKey( EnumKey, i, KeyBasicInformation,
1238                                      Kbio, KbioLength, &ResultLength );
1239
1240             if( !NT_SUCCESS(Status) ) {
1241                 TI_DbgPrint(DEBUG_DATALINK,("Couldn't enum key child %d\n", i));
1242                 NtClose( EnumKey );
1243                 ExFreePool( Kbio );
1244                 return Status;
1245             }
1246         }
1247
1248         if( NT_SUCCESS(Status) ) {
1249             TargetKeyName.Length = TargetKeyName.MaximumLength =
1250                 Kbio->NameLength;
1251             TargetKeyName.Buffer = Kbio->Name;
1252
1253             Status = CheckForDeviceDesc
1254                 ( &EnumKeyName, &TargetKeyName, Name, DeviceDesc );
1255             if( NT_SUCCESS(Status) ) {
1256                 NtClose( EnumKey );
1257                 ExFreePool( Kbio );
1258                 return Status;
1259             } else Status = STATUS_SUCCESS;
1260         }
1261     }
1262
1263     NtClose( EnumKey );
1264     ExFreePool( Kbio );
1265     return STATUS_UNSUCCESSFUL;
1266 }
1267
1268 VOID GetName( PUNICODE_STRING RegistryKey,
1269               PUNICODE_STRING OutName ) {
1270     PWCHAR Ptr;
1271     UNICODE_STRING PartialRegistryKey;
1272
1273     PartialRegistryKey.Buffer =
1274         RegistryKey->Buffer + wcslen(CCS_ROOT L"\\Services\\");
1275     Ptr = PartialRegistryKey.Buffer;
1276
1277     while( *Ptr != L'\\' &&
1278            ((PCHAR)Ptr) < ((PCHAR)RegistryKey->Buffer) + RegistryKey->Length )
1279         Ptr++;
1280
1281     PartialRegistryKey.Length = PartialRegistryKey.MaximumLength =
1282         (Ptr - PartialRegistryKey.Buffer) * sizeof(WCHAR);
1283
1284     RtlInitUnicodeString( OutName, L"" );
1285     AppendUnicodeString( OutName, &PartialRegistryKey, FALSE );
1286 }
1287
1288 BOOLEAN BindAdapter(
1289     PLAN_ADAPTER Adapter,
1290     PNDIS_STRING RegistryPath)
1291 /*
1292  * FUNCTION: Binds a LAN adapter to IP layer
1293  * ARGUMENTS:
1294  *     Adapter = Pointer to LAN_ADAPTER structure
1295  * NOTES:
1296  *    We set the lookahead buffer size, set the packet filter and
1297  *    bind the adapter to IP layer
1298  */
1299 {
1300     PIP_INTERFACE IF;
1301     NDIS_STATUS NdisStatus;
1302     LLIP_BIND_INFO BindInfo;
1303     ULONG Lookahead = LOOKAHEAD_SIZE;
1304     NTSTATUS Status;
1305
1306     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1307
1308     Adapter->State = LAN_STATE_OPENING;
1309
1310     NdisStatus = NDISCall(Adapter,
1311                           NdisRequestSetInformation,
1312                           OID_GEN_CURRENT_LOOKAHEAD,
1313                           &Lookahead,
1314                           sizeof(ULONG));
1315     if (NdisStatus != NDIS_STATUS_SUCCESS) {
1316         TI_DbgPrint(DEBUG_DATALINK, ("Could not set lookahead buffer size (0x%X).\n", NdisStatus));
1317         return FALSE;
1318     }
1319
1320     /* Bind the adapter to IP layer */
1321     BindInfo.Context       = Adapter;
1322     BindInfo.HeaderSize    = Adapter->HeaderSize;
1323     BindInfo.MinFrameSize  = Adapter->MinFrameSize;
1324     BindInfo.Address       = (PUCHAR)&Adapter->HWAddress;
1325     BindInfo.AddressLength = Adapter->HWAddressLength;
1326     BindInfo.Transmit      = LANTransmit;
1327
1328     IF = IPCreateInterface(&BindInfo);
1329
1330     if (!IF) {
1331         TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
1332         return FALSE;
1333     }
1334
1335     /*
1336      * Query per-adapter configuration from the registry
1337      * In case anyone is curious:  there *is* an Ndis configuration api
1338      * for this sort of thing, but it doesn't really support things like
1339      * REG_MULTI_SZ very well, and there is a note in the DDK that says that
1340      * protocol drivers developed for win2k and above just use the native
1341      * services (ZwOpenKey, etc).
1342      */
1343
1344     GetName( RegistryPath, &IF->Name );
1345
1346     Status = FindDeviceDescForAdapter( &IF->Name, &IF->Description );
1347     if (!NT_SUCCESS(Status)) {
1348         TI_DbgPrint(MIN_TRACE, ("Failed to get device description.\n"));
1349         IPDestroyInterface(IF);
1350         return FALSE;
1351     }
1352
1353     TI_DbgPrint(DEBUG_DATALINK,("Adapter Description: %wZ\n",
1354                 &IF->Description));
1355
1356     /* Get maximum link speed */
1357     NdisStatus = NDISCall(Adapter,
1358                           NdisRequestQueryInformation,
1359                           OID_GEN_LINK_SPEED,
1360                           &IF->Speed,
1361                           sizeof(UINT));
1362
1363     if (!NT_SUCCESS(NdisStatus))
1364         IF->Speed = IP_DEFAULT_LINK_SPEED;
1365
1366     Adapter->Speed = IF->Speed * 100L;
1367
1368     /* Get maximum frame size */
1369     NdisStatus = NDISCall(Adapter,
1370                           NdisRequestQueryInformation,
1371                           OID_GEN_MAXIMUM_FRAME_SIZE,
1372                           &Adapter->MTU,
1373                           sizeof(UINT));
1374     if (NdisStatus != NDIS_STATUS_SUCCESS)
1375         return FALSE;
1376
1377     IF->MTU = Adapter->MTU;
1378
1379     /* Get maximum packet size */
1380     NdisStatus = NDISCall(Adapter,
1381                           NdisRequestQueryInformation,
1382                           OID_GEN_MAXIMUM_TOTAL_SIZE,
1383                           &Adapter->MaxPacketSize,
1384                           sizeof(UINT));
1385     if (NdisStatus != NDIS_STATUS_SUCCESS)
1386         return FALSE;
1387
1388     /* Register interface with IP layer */
1389     IPRegisterInterface(IF);
1390
1391     /* Set adapter state */
1392     Adapter->Context = IF;
1393
1394     /* Set packet filter so we can send and receive packets */
1395     NdisStatus = NDISCall(Adapter,
1396                           NdisRequestSetInformation,
1397                           OID_GEN_CURRENT_PACKET_FILTER,
1398                           &Adapter->PacketFilter,
1399                           sizeof(UINT));
1400
1401     if (NdisStatus != NDIS_STATUS_SUCCESS) {
1402         TI_DbgPrint(DEBUG_DATALINK, ("Could not set packet filter (0x%X).\n", NdisStatus));
1403         IPUnregisterInterface(IF);
1404         IPDestroyInterface(IF);
1405         return FALSE;
1406     }
1407
1408     /* Indicate media connect (our drivers are broken and don't do this) */
1409     ProtocolStatus(Adapter, NDIS_STATUS_MEDIA_CONNECT, NULL, 0);
1410
1411     return TRUE;
1412 }
1413
1414
1415 VOID UnbindAdapter(
1416     PLAN_ADAPTER Adapter)
1417 /*
1418  * FUNCTION: Unbinds a LAN adapter from IP layer
1419  * ARGUMENTS:
1420  *     Adapter = Pointer to LAN_ADAPTER structure
1421  */
1422 {
1423     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1424
1425     if (Adapter->State == LAN_STATE_STARTED) {
1426         PIP_INTERFACE IF = Adapter->Context;
1427
1428         IPUnregisterInterface(IF);
1429
1430         IPDestroyInterface(IF);
1431     }
1432 }
1433
1434
1435 NDIS_STATUS LANRegisterAdapter(
1436     PNDIS_STRING AdapterName,
1437     PNDIS_STRING RegistryPath)
1438 /*
1439  * FUNCTION: Registers protocol with an NDIS adapter
1440  * ARGUMENTS:
1441  *     AdapterName = Pointer to string with name of adapter to register
1442  *     Adapter     = Address of pointer to a LAN_ADAPTER structure
1443  * RETURNS:
1444  *     Status of operation
1445  */
1446 {
1447     PLAN_ADAPTER IF;
1448     NDIS_STATUS NdisStatus;
1449     NDIS_STATUS OpenStatus;
1450     UINT MediaIndex;
1451     NDIS_MEDIUM MediaArray[MAX_MEDIA];
1452     UINT AddressOID;
1453
1454     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1455
1456     IF = ExAllocatePoolWithTag(NonPagedPool, sizeof(LAN_ADAPTER), LAN_ADAPTER_TAG);
1457     if (!IF) {
1458         TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
1459         return NDIS_STATUS_RESOURCES;
1460     }
1461
1462     RtlZeroMemory(IF, sizeof(LAN_ADAPTER));
1463
1464     /* Put adapter in stopped state */
1465     IF->State = LAN_STATE_STOPPED;
1466
1467     /* Initialize protecting spin lock */
1468     KeInitializeSpinLock(&IF->Lock);
1469
1470     KeInitializeEvent(&IF->Event, SynchronizationEvent, FALSE);
1471
1472     /* Initialize array with media IDs we support */
1473     MediaArray[MEDIA_ETH] = NdisMedium802_3;
1474
1475     TI_DbgPrint(DEBUG_DATALINK,("opening adapter %wZ\n", AdapterName));
1476     /* Open the adapter. */
1477     NdisOpenAdapter(&NdisStatus,
1478                     &OpenStatus,
1479                     &IF->NdisHandle,
1480                     &MediaIndex,
1481                     MediaArray,
1482                     MAX_MEDIA,
1483                     NdisProtocolHandle,
1484                     IF,
1485                     AdapterName,
1486                     0,
1487                     NULL);
1488
1489     /* Wait until the adapter is opened */
1490     if (NdisStatus == NDIS_STATUS_PENDING)
1491         KeWaitForSingleObject(&IF->Event, UserRequest, KernelMode, FALSE, NULL);
1492     else if (NdisStatus != NDIS_STATUS_SUCCESS) {
1493         TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ\n", AdapterName));
1494         ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
1495         return NdisStatus;
1496     }
1497
1498     IF->Media = MediaArray[MediaIndex];
1499
1500     /* Fill LAN_ADAPTER structure with some adapter specific information */
1501     switch (IF->Media) {
1502     case NdisMedium802_3:
1503         IF->HWAddressLength = IEEE_802_ADDR_LENGTH;
1504         IF->BCastMask       = BCAST_ETH_MASK;
1505         IF->BCastCheck      = BCAST_ETH_CHECK;
1506         IF->BCastOffset     = BCAST_ETH_OFFSET;
1507         IF->HeaderSize      = sizeof(ETH_HEADER);
1508         IF->MinFrameSize    = 60;
1509         AddressOID          = OID_802_3_CURRENT_ADDRESS;
1510         IF->PacketFilter    =
1511             NDIS_PACKET_TYPE_BROADCAST |
1512             NDIS_PACKET_TYPE_DIRECTED  |
1513             NDIS_PACKET_TYPE_MULTICAST;
1514         break;
1515
1516     default:
1517         /* Unsupported media */
1518         TI_DbgPrint(MIN_TRACE, ("Unsupported media.\n"));
1519         ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
1520         return NDIS_STATUS_NOT_SUPPORTED;
1521     }
1522
1523     /* Get maximum number of packets we can pass to NdisSend(Packets) at one time */
1524     NdisStatus = NDISCall(IF,
1525                           NdisRequestQueryInformation,
1526                           OID_GEN_MAXIMUM_SEND_PACKETS,
1527                           &IF->MaxSendPackets,
1528                           sizeof(UINT));
1529     if (NdisStatus != NDIS_STATUS_SUCCESS)
1530         /* Legacy NIC drivers may not support this query, if it fails we
1531            assume it can send at least one packet per call to NdisSend(Packets) */
1532         IF->MaxSendPackets = 1;
1533
1534     /* Get current hardware address */
1535     NdisStatus = NDISCall(IF,
1536                           NdisRequestQueryInformation,
1537                           AddressOID,
1538                           &IF->HWAddress,
1539                           IF->HWAddressLength);
1540     if (NdisStatus != NDIS_STATUS_SUCCESS) {
1541         TI_DbgPrint(MIN_TRACE, ("Query for current hardware address failed.\n"));
1542         ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
1543         return NdisStatus;
1544     }
1545
1546     /* Bind adapter to IP layer */
1547     if( !BindAdapter(IF, RegistryPath) ) {
1548         TI_DbgPrint(DEBUG_DATALINK,("denying adapter %wZ (BindAdapter)\n", AdapterName));
1549         ExFreePoolWithTag(IF, LAN_ADAPTER_TAG);
1550         return NDIS_STATUS_NOT_ACCEPTED;
1551     }
1552
1553     /* Add adapter to the adapter list */
1554     ExInterlockedInsertTailList(&AdapterListHead,
1555                                 &IF->ListEntry,
1556                                 &AdapterListLock);
1557
1558     TI_DbgPrint(DEBUG_DATALINK, ("Leaving.\n"));
1559
1560     return NDIS_STATUS_SUCCESS;
1561 }
1562
1563
1564 NDIS_STATUS LANUnregisterAdapter(
1565     PLAN_ADAPTER Adapter)
1566 /*
1567  * FUNCTION: Unregisters protocol with NDIS adapter
1568  * ARGUMENTS:
1569  *     Adapter = Pointer to a LAN_ADAPTER structure
1570  * RETURNS:
1571  *     Status of operation
1572  */
1573 {
1574     KIRQL OldIrql;
1575     NDIS_HANDLE NdisHandle;
1576     NDIS_STATUS NdisStatus = NDIS_STATUS_SUCCESS;
1577
1578     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1579
1580     /* Unlink the adapter from the list */
1581     RemoveEntryList(&Adapter->ListEntry);
1582
1583     /* Unbind adapter from IP layer */
1584     UnbindAdapter(Adapter);
1585
1586     TcpipAcquireSpinLock(&Adapter->Lock, &OldIrql);
1587     NdisHandle = Adapter->NdisHandle;
1588     if (NdisHandle) {
1589         Adapter->NdisHandle = NULL;
1590         TcpipReleaseSpinLock(&Adapter->Lock, OldIrql);
1591
1592         NdisCloseAdapter(&NdisStatus, NdisHandle);
1593         if (NdisStatus == NDIS_STATUS_PENDING) {
1594             TcpipWaitForSingleObject(&Adapter->Event,
1595                                      UserRequest,
1596                                      KernelMode,
1597                                      FALSE,
1598                                      NULL);
1599             NdisStatus = Adapter->NdisStatus;
1600         }
1601     } else
1602         TcpipReleaseSpinLock(&Adapter->Lock, OldIrql);
1603
1604     FreeAdapter(Adapter);
1605
1606     return NdisStatus;
1607 }
1608
1609 VOID
1610 NTAPI
1611 LANUnregisterProtocol(VOID)
1612 /*
1613  * FUNCTION: Unregisters this protocol driver with NDIS
1614  * NOTES: Does not care wether we are already registered
1615  */
1616 {
1617     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1618
1619     if (ProtocolRegistered) {
1620         NDIS_STATUS NdisStatus;
1621         PLIST_ENTRY CurrentEntry;
1622         PLIST_ENTRY NextEntry;
1623         PLAN_ADAPTER Current;
1624         KIRQL OldIrql;
1625
1626         TcpipAcquireSpinLock(&AdapterListLock, &OldIrql);
1627
1628         /* Search the list and remove every adapter we find */
1629         CurrentEntry = AdapterListHead.Flink;
1630         while (CurrentEntry != &AdapterListHead) {
1631             NextEntry = CurrentEntry->Flink;
1632             Current = CONTAINING_RECORD(CurrentEntry, LAN_ADAPTER, ListEntry);
1633             /* Unregister it */
1634             LANUnregisterAdapter(Current);
1635             CurrentEntry = NextEntry;
1636         }
1637
1638         TcpipReleaseSpinLock(&AdapterListLock, OldIrql);
1639
1640         NdisDeregisterProtocol(&NdisStatus, NdisProtocolHandle);
1641         ProtocolRegistered = FALSE;
1642     }
1643 }
1644
1645 VOID
1646 NTAPI
1647 ProtocolUnbindAdapter(
1648     PNDIS_STATUS Status,
1649     NDIS_HANDLE ProtocolBindingContext,
1650     NDIS_HANDLE UnbindContext)
1651 {
1652     /* We don't pend any unbinding so we can just ignore UnbindContext */
1653     *Status = LANUnregisterAdapter((PLAN_ADAPTER)ProtocolBindingContext);
1654 }
1655
1656 NTSTATUS LANRegisterProtocol(
1657     PNDIS_STRING Name)
1658 /*
1659  * FUNCTION: Registers this protocol driver with NDIS
1660  * ARGUMENTS:
1661  *     Name = Name of this protocol driver
1662  * RETURNS:
1663  *     Status of operation
1664  */
1665 {
1666     NDIS_STATUS NdisStatus;
1667     NDIS_PROTOCOL_CHARACTERISTICS ProtChars;
1668
1669     TI_DbgPrint(DEBUG_DATALINK, ("Called.\n"));
1670
1671     InitializeListHead(&AdapterListHead);
1672     KeInitializeSpinLock(&AdapterListLock);
1673
1674     /* Set up protocol characteristics */
1675     RtlZeroMemory(&ProtChars, sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
1676     ProtChars.MajorNdisVersion               = NDIS_VERSION_MAJOR;
1677     ProtChars.MinorNdisVersion               = NDIS_VERSION_MINOR;
1678     ProtChars.Name.Length                    = Name->Length;
1679     ProtChars.Name.Buffer                    = Name->Buffer;
1680     ProtChars.Name.MaximumLength             = Name->MaximumLength;
1681     ProtChars.OpenAdapterCompleteHandler     = ProtocolOpenAdapterComplete;
1682     ProtChars.CloseAdapterCompleteHandler    = ProtocolCloseAdapterComplete;
1683     ProtChars.ResetCompleteHandler           = ProtocolResetComplete;
1684     ProtChars.RequestCompleteHandler         = ProtocolRequestComplete;
1685     ProtChars.SendCompleteHandler            = ProtocolSendComplete;
1686     ProtChars.TransferDataCompleteHandler    = ProtocolTransferDataComplete;
1687     ProtChars.ReceivePacketHandler           = ProtocolReceivePacket;
1688     ProtChars.ReceiveHandler                 = ProtocolReceive;
1689     ProtChars.ReceiveCompleteHandler         = ProtocolReceiveComplete;
1690     ProtChars.StatusHandler                  = ProtocolStatus;
1691     ProtChars.StatusCompleteHandler          = ProtocolStatusComplete;
1692     ProtChars.BindAdapterHandler             = ProtocolBindAdapter;
1693     ProtChars.PnPEventHandler                = ProtocolPnPEvent;
1694     ProtChars.UnbindAdapterHandler           = ProtocolUnbindAdapter;
1695     ProtChars.UnloadHandler                  = LANUnregisterProtocol;
1696
1697     /* Try to register protocol */
1698     NdisRegisterProtocol(&NdisStatus,
1699                          &NdisProtocolHandle,
1700                          &ProtChars,
1701                          sizeof(NDIS_PROTOCOL_CHARACTERISTICS));
1702     if (NdisStatus != NDIS_STATUS_SUCCESS)
1703     {
1704         TI_DbgPrint(DEBUG_DATALINK, ("NdisRegisterProtocol failed, status 0x%x\n", NdisStatus));
1705         return (NTSTATUS)NdisStatus;
1706     }
1707
1708     ProtocolRegistered = TRUE;
1709
1710     return STATUS_SUCCESS;
1711 }
1712
1713 /* EOF */