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