reactos/drivers/net/tcpip/tcpip/main.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS TCP/IP protocol driver
   4  * FILE:        tcpip/main.c
   5  * PURPOSE:     Driver entry point
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  * REVISIONS:
   8  *   CSH 01/08-2000 Created
   9  */
  10 #include <tcpip.h>
  11 #include <dispatch.h>
  12 #include <fileobjs.h>
  13 #include <datagram.h>
  14 #include <loopback.h>
  15 #include <rawip.h>
  16 #include <udp.h>
  17 #include <tcp.h>
  18
  19
  20 #ifdef DBG
  21
  22 /* See debug.h for debug/trace constants */
  23 DWORD DebugTraceLevel = MIN_TRACE;
  24
  25 #endif /* DBG */
  26
  27 PDEVICE_OBJECT TCPDeviceObject   = NULL;
  28 PDEVICE_OBJECT UDPDeviceObject   = NULL;
  29 PDEVICE_OBJECT IPDeviceObject    = NULL;
  30 PDEVICE_OBJECT RawIPDeviceObject = NULL;
  31 NDIS_HANDLE GlobalPacketPool     = NULL;
  32 NDIS_HANDLE GlobalBufferPool     = NULL;
  33 TDIEntityID *EntityList          = NULL;
  34 ULONG EntityCount                = 0;
  35 UDP_STATISTICS UDPStats;
  36
  37
  38 VOID TiWriteErrorLog(
  39     PDRIVER_OBJECT DriverContext,
  40     NTSTATUS ErrorCode,
  41     ULONG UniqueErrorValue,
  42     NTSTATUS FinalStatus,
  43     PWSTR String,
  44     ULONG DumpDataCount,
  45     PULONG DumpData)
  46 /*
  47  * FUNCTION: Writes an error log entry
  48  * ARGUMENTS:
  49  *     DriverContext    = Pointer to the driver or device object
  50  *     ErrorCode        = An error code to put in the log entry
  51  *     UniqueErrorValue = UniqueErrorValue in the error log packet
  52  *     FinalStatus      = FinalStatus in the error log packet
  53  *     String           = If not NULL, a pointer to a string to put in log entry
  54  *     DumpDataCount    = Number of ULONGs of dump data
  55  *     DumpData         = Pointer to dump data for the log entry
  56  */
  57 {
  58 #ifdef _MSC_VER
  59     PIO_ERROR_LOG_PACKET LogEntry;
  60     UCHAR EntrySize;
  61     ULONG StringSize;
  62     PUCHAR pString;
  63     static WCHAR DriverName[] = L"TCP/IP";
  64
  65     EntrySize = sizeof(IO_ERROR_LOG_PACKET) +
  66         (DumpDataCount * sizeof(ULONG)) + sizeof(DriverName);
  67
  68     if (String) {
  69         StringSize = (wcslen(String) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
  70         EntrySize += (UCHAR)StringSize;
  71     }
  72
  73     LogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
  74                 DriverContext, EntrySize);
  75
  76     if (LogEntry) {
  77         LogEntry->MajorFunctionCode = -1;
  78         LogEntry->RetryCount        = -1;
  79         LogEntry->DumpDataSize      = (USHORT)(DumpDataCount * sizeof(ULONG));
  80         LogEntry->NumberOfStrings   = (String == NULL) ? 1 : 2;
  81         LogEntry->StringOffset      = sizeof(IO_ERROR_LOG_PACKET) + (DumpDataCount-1) * sizeof(ULONG);
  82         LogEntry->EventCategory     = 0;
  83         LogEntry->ErrorCode         = ErrorCode;
  84         LogEntry->UniqueErrorValue  = UniqueErrorValue;
  85         LogEntry->FinalStatus       = FinalStatus;
  86         LogEntry->SequenceNumber    = -1;
  87         LogEntry->IoControlCode     = 0;
  88
  89         if (DumpDataCount)
  90             RtlCopyMemory(LogEntry->DumpData, DumpData, DumpDataCount * sizeof(ULONG));
  91
  92         pString = ((PUCHAR)LogEntry) + LogEntry->StringOffset;
  93         RtlCopyMemory(pString, DriverName, sizeof(DriverName));
  94         pString += sizeof(DriverName);
  95
  96         if (String)
  97             RtlCopyMemory(pString, String, StringSize);
  98
  99         IoWriteErrorLogEntry(LogEntry);
 100     }
 101 #endif
 102 }
 103
 104
 105 /*
 106  * FUNCTION: Creates a file object
 107  * ARGUMENTS:
 108  *     DeviceObject = Pointer to a device object for this driver
 109  *     Irp          = Pointer to a I/O request packet
 110  * RETURNS:
 111  *     Status of the operation
 112  */
 113 NTSTATUS TiCreateFileObject(
 114     PDEVICE_OBJECT DeviceObject,
 115     PIRP Irp)
 116 {
 117     PIO_STACK_LOCATION IrpSp;
 118     PFILE_FULL_EA_INFORMATION EaInfo;
 119     PTA_ADDRESS_IP Address;
 120     PTRANSPORT_CONTEXT Context;
 121     TDI_REQUEST Request;
 122     NTSTATUS Status;
 123
 124     TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
 125
 126     EaInfo = Irp->AssociatedIrp.SystemBuffer;
 127
 128     /* Parameter check */
 129     if (!EaInfo) {
 130         TI_DbgPrint(MIN_TRACE, ("No EA information in IRP.\n"));
 131         return STATUS_INVALID_PARAMETER;
 132     }
 133
 134     /* Allocate resources here. We release them again if something failed */
 135     Context = ExAllocatePool(NonPagedPool, sizeof(TRANSPORT_CONTEXT));
 136     if (!Context) {
 137         TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 138         return STATUS_INSUFFICIENT_RESOURCES;
 139     }
 140
 141     Context->RefCount   = 1;
 142     Context->CancelIrps = FALSE;
 143     KeInitializeEvent(&Context->CleanupEvent, NotificationEvent, FALSE);
 144
 145     IrpSp = IoGetCurrentIrpStackLocation(Irp);
 146     IrpSp->FileObject->FsContext = Context;
 147     Request.RequestContext       = Irp;
 148
 149     /* Branch to the right handler */
 150     if ((EaInfo->EaNameLength==TDI_TRANSPORT_ADDRESS_LENGTH) &&
 151         (RtlCompareMemory(&EaInfo->EaName, TdiTransportAddress,
 152          TDI_TRANSPORT_ADDRESS_LENGTH) == TDI_TRANSPORT_ADDRESS_LENGTH)) {
 153         /* This is a request to open an address */
 154
 155         /* Parameter checks */
 156         Address = (PTA_ADDRESS_IP)(EaInfo->EaName + EaInfo->EaNameLength + 1);
 157         if ((EaInfo->EaValueLength < sizeof(TA_ADDRESS_IP)) ||
 158             (Address->TAAddressCount != 1) ||
 159             (Address->Address[0].AddressLength < sizeof(TDI_ADDRESS_IP)) ||
 160             (Address->Address[0].AddressType != TDI_ADDRESS_TYPE_IP)) {
 161             TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
 162             ExFreePool(Context);
 163             return STATUS_INVALID_PARAMETER;
 164         }
 165
 166         /* Open address file object */
 167         /* FIXME: Protocol depends on device object */
 168         Status = FileOpenAddress(&Request, Address, IPPROTO_UDP, NULL);
 169         if (NT_SUCCESS(Status)) {
 170             IrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
 171             Context->Handle.AddressHandle = Request.Handle.AddressHandle;
 172         }
 173     } else {
 174         TI_DbgPrint(MIN_TRACE, ("Connection point, and control connections are not supported.\n"));
 175         /* FIXME: Open a connection endpoint, or control connection */
 176         Status = STATUS_NOT_IMPLEMENTED;
 177     }
 178
 179     if (!NT_SUCCESS(Status))
 180         ExFreePool(Context);
 181
 182     TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 183
 184     return Status;
 185 }
 186
 187
 188 VOID TiCleanupFileObjectComplete(
 189     PVOID Context,
 190     NTSTATUS Status)
 191 /*
 192  * FUNCTION: Completes an object cleanup IRP I/O request
 193  * ARGUMENTS:
 194  *     Context = Pointer to the IRP for this request
 195  *     Status  = Final status of the operation
 196  */
 197 {
 198     PIRP Irp;
 199     PIO_STACK_LOCATION IrpSp;
 200     PTRANSPORT_CONTEXT TranContext;
 201     KIRQL OldIrql;
 202
 203     Irp         = (PIRP)Context;
 204     IrpSp       = IoGetCurrentIrpStackLocation(Irp);
 205     TranContext = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
 206
 207     Irp->IoStatus.Status = Status;
 208
 209     IoAcquireCancelSpinLock(&OldIrql);
 210
 211     /* Remove the initial reference provided at object creation time */
 212     TranContext->RefCount--;
 213
 214 #ifdef DBG
 215     if (TranContext->RefCount != 0)
 216         TI_DbgPrint(DEBUG_REFCOUNT, ("TranContext->RefCount is %i, should be 0.\n", TranContext->RefCount));
 217 #endif
 218
 219     KeSetEvent(&TranContext->CleanupEvent, 0, FALSE);
 220
 221     IoReleaseCancelSpinLock(OldIrql);
 222 }
 223
 224
 225 /*
 226  * FUNCTION: Releases resources used by a file object
 227  * ARGUMENTS:
 228  *     DeviceObject = Pointer to a device object for this driver
 229  *     Irp          = Pointer to a I/O request packet
 230  * RETURNS:
 231  *     Status of the operation
 232  * NOTES:
 233  *     This function does not pend
 234  */
 235 NTSTATUS TiCleanupFileObject(
 236     PDEVICE_OBJECT DeviceObject,
 237     PIRP Irp)
 238 {
 239     PIO_STACK_LOCATION IrpSp;
 240     PTRANSPORT_CONTEXT Context;
 241     TDI_REQUEST Request;
 242     NTSTATUS Status;
 243     KIRQL OldIrql;
 244
 245     IrpSp   = IoGetCurrentIrpStackLocation(Irp);
 246     Context = IrpSp->FileObject->FsContext;
 247     if (!Context) {
 248         TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
 249         return STATUS_INVALID_PARAMETER;
 250     }
 251
 252     IoAcquireCancelSpinLock(&OldIrql);
 253
 254     Context->CancelIrps = TRUE;
 255     KeResetEvent(&Context->CleanupEvent);
 256
 257     IoReleaseCancelSpinLock(OldIrql);
 258
 259     Request.RequestNotifyObject = TiCleanupFileObjectComplete;
 260     Request.RequestContext      = Irp;
 261
 262     switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
 263     case TDI_TRANSPORT_ADDRESS_FILE:
 264         Request.Handle.AddressHandle = Context->Handle.AddressHandle;
 265         Status = FileCloseAddress(&Request);
 266         break;
 267
 268     case TDI_CONNECTION_FILE:
 269         Request.Handle.ConnectionContext = Context->Handle.ConnectionContext;
 270         Status = FileCloseConnection(&Request);
 271         break;
 272
 273     case TDI_CONTROL_CHANNEL_FILE:
 274         Request.Handle.ControlChannel = Context->Handle.ControlChannel;
 275         Status = FileCloseControlChannel(&Request);
 276         break;
 277
 278     default:
 279         /* This should never happen */
 280
 281         TI_DbgPrint(MIN_TRACE, ("Unknown transport context.\n"));
 282
 283         IoAcquireCancelSpinLock(&OldIrql);
 284         Context->CancelIrps = FALSE;
 285         IoReleaseCancelSpinLock(OldIrql);
 286
 287         return STATUS_INVALID_PARAMETER;
 288     }
 289
 290     if (Status != STATUS_PENDING)
 291        TiCleanupFileObjectComplete(Irp, Status);
 292
 293     KeWaitForSingleObject(&Context->CleanupEvent,
 294         UserRequest, KernelMode, FALSE, NULL);
 295
 296     return Irp->IoStatus.Status;
 297 }
 298
 299
 300 NTSTATUS TiDispatchOpenClose(
 301     PDEVICE_OBJECT DeviceObject,
 302     PIRP Irp)
 303 /*
 304  * FUNCTION: Main dispath routine
 305  * ARGUMENTS:
 306  *     DeviceObject = Pointer to a device object for this driver
 307  *     Irp          = Pointer to a I/O request packet
 308  * RETURNS:
 309  *     Status of the operation
 310  */
 311 {
 312     PIO_STACK_LOCATION IrpSp;
 313     NTSTATUS Status;
 314     PTRANSPORT_CONTEXT Context;
 315
 316     TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
 317
 318     IoMarkIrpPending(Irp);
 319     Irp->IoStatus.Status      = STATUS_PENDING;
 320     Irp->IoStatus.Information = 0;
 321
 322     IrpSp = IoGetCurrentIrpStackLocation(Irp);
 323
 324     switch (IrpSp->MajorFunction) {
 325     /* Open an address file, connection endpoint, or control connection */
 326     case IRP_MJ_CREATE:
 327         Status = TiCreateFileObject(DeviceObject, Irp);
 328         break;
 329
 330     /* Close an address file, connection endpoint, or control connection */
 331     case IRP_MJ_CLOSE:
 332         Context = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
 333         if (Context)
 334             ExFreePool(Context);
 335         Status = STATUS_SUCCESS;
 336         break;
 337
 338     /* Release resources bound to an address file, connection endpoint,
 339        or control connection */
 340     case IRP_MJ_CLEANUP:
 341         Status = TiCleanupFileObject(DeviceObject, Irp);
 342         break;
 343
 344         default:
 345         Status = STATUS_INVALID_DEVICE_REQUEST;
 346     }
 347
 348     if (Status != STATUS_PENDING) {
 349         IrpSp->Control &= ~SL_PENDING_RETURNED;
 350         Irp->IoStatus.Status = Status;
 351
 352         TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
 353
 354         IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 355     }
 356
 357     TI_DbgPrint(DEBUG_IRP, ("Leaving. Status is (0x%X)\n", Status));
 358
 359     return Status;
 360 }
 361
 362
 363 NTSTATUS TiDispatchInternal(
 364     PDEVICE_OBJECT DeviceObject,
 365     PIRP Irp)
 366 /*
 367  * FUNCTION: Internal IOCTL dispatch routine
 368  * ARGUMENTS:
 369  *     DeviceObject = Pointer to a device object for this driver
 370  *     Irp          = Pointer to a I/O request packet
 371  * RETURNS:
 372  *     Status of the operation
 373  */
 374 {
 375         NTSTATUS Status;
 376     PIO_STACK_LOCATION IrpSp;
 377
 378     TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
 379
 380         IrpSp = IoGetCurrentIrpStackLocation(Irp);
 381
 382     Irp->IoStatus.Status      = STATUS_SUCCESS;
 383     Irp->IoStatus.Information = 0;
 384
 385     switch (IrpSp->MinorFunction) {
 386     case TDI_RECEIVE:
 387         Status = DispTdiReceive(Irp);
 388         break;
 389
 390     case TDI_RECEIVE_DATAGRAM:
 391         Status = DispTdiReceiveDatagram(Irp);
 392         break;
 393
 394     case TDI_SEND:
 395         Status = DispTdiSend(Irp);
 396         break;
 397
 398     case TDI_SEND_DATAGRAM:
 399         Status = DispTdiSendDatagram(Irp);
 400         break;
 401
 402     case TDI_ACCEPT:
 403         Status = DispTdiAccept(Irp);
 404         break;
 405
 406     case TDI_LISTEN:
 407         Status = DispTdiListen(Irp);
 408         break;
 409
 410     case TDI_CONNECT:
 411         Status = DispTdiConnect(Irp);
 412         break;
 413
 414     case TDI_DISCONNECT:
 415         Status = DispTdiDisconnect(Irp);
 416         break;
 417
 418     case TDI_ASSOCIATE_ADDRESS:
 419         Status = DispTdiAssociateAddress(Irp);
 420         break;
 421
 422     case TDI_DISASSOCIATE_ADDRESS:
 423         Status = DispTdiDisassociateAddress(Irp);
 424         break;
 425
 426     case TDI_QUERY_INFORMATION:
 427         Status = DispTdiQueryInformation(DeviceObject, Irp);
 428         break;
 429
 430     case TDI_SET_INFORMATION:
 431         Status = DispTdiSetInformation(Irp);
 432         break;
 433
 434     case TDI_SET_EVENT_HANDLER:
 435         Status = DispTdiSetEventHandler(Irp);
 436         break;
 437
 438     case TDI_ACTION:
 439         Status = STATUS_SUCCESS;
 440         break;
 441
 442     /* An unsupported IOCTL code was submitted */
 443     default:
 444         Status = STATUS_INVALID_DEVICE_REQUEST;
 445     }
 446
 447     if (Status != STATUS_PENDING) {
 448         Irp->IoStatus.Status = Status;
 449
 450         TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
 451
 452         IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 453     }
 454
 455     TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 456
 457         return Status;
 458 }
 459
 460
 461 NTSTATUS TiDispatch(
 462     PDEVICE_OBJECT DeviceObject,
 463     PIRP Irp)
 464 /*
 465  * FUNCTION: Dispath routine for IRP_MJ_DEVICE_CONTROL requests
 466  * ARGUMENTS:
 467  *     DeviceObject = Pointer to a device object for this driver
 468  *     Irp          = Pointer to a I/O request packet
 469  * RETURNS:
 470  *     Status of the operation
 471  */
 472 {
 473     NTSTATUS Status;
 474     PIO_STACK_LOCATION IrpSp;
 475
 476     TI_DbgPrint(DEBUG_IRP, ("Called. IRP is at (0x%X).\n", Irp));
 477
 478     Irp->IoStatus.Information = 0;
 479
 480     IrpSp  = IoGetCurrentIrpStackLocation(Irp);
 481 #ifdef _MSC_VER
 482     Status = TdiMapUserRequest(DeviceObject, Irp, IrpSp);
 483     if (NT_SUCCESS(Status)) {
 484         TiDispatchInternal(DeviceObject, Irp);
 485         Status = STATUS_PENDING;
 486     } else {
 487 #else
 488     if (TRUE) {
 489 #endif
 490         /* See if this request is TCP/IP specific */
 491         switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
 492         case IOCTL_TCP_QUERY_INFORMATION_EX:
 493             Status = DispTdiQueryInformationEx(Irp, IrpSp);
 494             break;
 495
 496         case IOCTL_TCP_SET_INFORMATION_EX:
 497             Status = DispTdiSetInformationEx(Irp, IrpSp);
 498             break;
 499
 500         default:
 501             TI_DbgPrint(MIN_TRACE, ("Unknown IOCTL 0x%X\n",
 502                 IrpSp->Parameters.DeviceIoControl.IoControlCode));
 503             Status = STATUS_NOT_IMPLEMENTED;
 504             break;
 505         }
 506     }
 507
 508     if (Status != STATUS_PENDING) {
 509         Irp->IoStatus.Status = Status;
 510
 511         TI_DbgPrint(DEBUG_IRP, ("Completing IRP at (0x%X).\n", Irp));
 512
 513         IoCompleteRequest(Irp, IO_NETWORK_INCREMENT);
 514     }
 515
 516     TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 517
 518     return Status;
 519 }
 520
 521
 522 VOID TiUnload(
 523     PDRIVER_OBJECT DriverObject)
 524 /*
 525  * FUNCTION: Unloads the driver
 526  * ARGUMENTS:
 527  *     DriverObject = Pointer to driver object created by the system
 528  */
 529 {
 530 #ifdef DBG
 531     KIRQL OldIrql;
 532
 533     KeAcquireSpinLock(&AddressFileListLock, &OldIrql);
 534     if (!IsListEmpty(&AddressFileListHead)) {
 535         TI_DbgPrint(MIN_TRACE, ("Open address file objects exists.\n"));
 536     }
 537     KeReleaseSpinLock(&AddressFileListLock, OldIrql);
 538 #endif
 539
 540     /* Unregister loopback adapter */
 541     LoopUnregisterAdapter(NULL);
 542
 543     /* Unregister protocol with NDIS */
 544     LANUnregisterProtocol();
 545
 546     /* Shutdown transport level protocol subsystems */
 547     TCPShutdown();
 548     UDPShutdown();
 549     RawIPShutdown();
 550     DGShutdown();
 551
 552     /* Shutdown network level protocol subsystem */
 553     IPShutdown();
 554
 555     /* Free NDIS buffer descriptors */
 556     if (GlobalBufferPool)
 557         NdisFreeBufferPool(GlobalBufferPool);
 558
 559     /* Free NDIS packet descriptors */
 560     if (GlobalPacketPool)
 561         NdisFreePacketPool(GlobalPacketPool);
 562
 563     /* Release all device objects */
 564
 565     if (TCPDeviceObject)
 566         IoDeleteDevice(TCPDeviceObject);
 567
 568     if (UDPDeviceObject)
 569         IoDeleteDevice(UDPDeviceObject);
 570
 571     if (RawIPDeviceObject)
 572         IoDeleteDevice(RawIPDeviceObject);
 573
 574     if (IPDeviceObject)
 575         IoDeleteDevice(IPDeviceObject);
 576
 577     if (EntityList)
 578         ExFreePool(EntityList);
 579
 580     TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 581 }
 582
 583
 584 NTSTATUS
 585 #ifndef _MSC_VER
 586 STDCALL
 587 #endif
 588 DriverEntry(
 589     PDRIVER_OBJECT DriverObject,
 590     PUNICODE_STRING RegistryPath)
 591 /*
 592  * FUNCTION: Main driver entry point
 593  * ARGUMENTS:
 594  *     DriverObject = Pointer to a driver object for this driver
 595  *     RegistryPath = Registry node for configuration parameters
 596  * RETURNS:
 597  *     Status of driver initialization
 598  */
 599 {
 600     NTSTATUS Status;
 601     UNICODE_STRING strDeviceName;
 602     STRING strNdisDeviceName;
 603     NDIS_STATUS NdisStatus;
 604     PLAN_ADAPTER Adapter;
 605     NDIS_STRING DeviceName;
 606
 607     TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 608
 609     /* FIXME: Create symbolic links in Win32 namespace */
 610
 611     /* Create IP device object */
 612     RtlInitUnicodeString(&strDeviceName, DD_IP_DEVICE_NAME);
 613     Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
 614         FILE_DEVICE_NETWORK, 0, FALSE, &IPDeviceObject);
 615     if (!NT_SUCCESS(Status)) {
 616         TI_DbgPrint(MIN_TRACE, ("Failed to create IP device object. Status (0x%X).\n", Status));
 617         return Status;
 618     }
 619
 620     /* Create RawIP device object */
 621     RtlInitUnicodeString(&strDeviceName, DD_RAWIP_DEVICE_NAME);
 622     Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
 623         FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject);
 624     if (!NT_SUCCESS(Status)) {
 625         TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status));
 626         TiUnload(DriverObject);
 627         return Status;
 628     }
 629
 630     /* Create UDP device object */
 631     RtlInitUnicodeString(&strDeviceName, DD_UDP_DEVICE_NAME);
 632     Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
 633         FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject);
 634     if (!NT_SUCCESS(Status)) {
 635         TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status));
 636         TiUnload(DriverObject);
 637         return Status;
 638     }
 639
 640     /* Create TCP device object */
 641     RtlInitUnicodeString(&strDeviceName, DD_TCP_DEVICE_NAME);
 642     Status = IoCreateDevice(DriverObject, 0, &strDeviceName,
 643         FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject);
 644     if (!NT_SUCCESS(Status)) {
 645         TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status));
 646         TiUnload(DriverObject);
 647         return Status;
 648     }
 649
 650     /* Allocate NDIS packet descriptors */
 651     NdisAllocatePacketPool(&NdisStatus, &GlobalPacketPool, 100, sizeof(PACKET_CONTEXT));
 652     if (NdisStatus != NDIS_STATUS_SUCCESS) {
 653         TiUnload(DriverObject);
 654         return STATUS_INSUFFICIENT_RESOURCES;
 655     }
 656
 657     /* Allocate NDIS buffer descriptors */
 658     NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 100);
 659     if (NdisStatus != NDIS_STATUS_SUCCESS) {
 660         TiUnload(DriverObject);
 661         return STATUS_INSUFFICIENT_RESOURCES;
 662     }
 663
 664     /* Initialize address file list and protecting spin lock */
 665     InitializeListHead(&AddressFileListHead);
 666     KeInitializeSpinLock(&AddressFileListLock);
 667
 668     /* Initialize interface list and protecting spin lock */
 669     InitializeListHead(&InterfaceListHead);
 670     KeInitializeSpinLock(&InterfaceListLock);
 671
 672     /* Initialize network level protocol subsystem */
 673     IPStartup(DriverObject, RegistryPath);
 674
 675     /* Initialize transport level protocol subsystems */
 676     DGStartup();
 677     RawIPStartup();
 678     UDPStartup();
 679     TCPStartup();
 680
 681     /* Register protocol with NDIS */
 682     RtlInitString(&strNdisDeviceName, IP_DEVICE_NAME);
 683     Status = LANRegisterProtocol(&strNdisDeviceName);
 684     if (!NT_SUCCESS(Status)) {
 685                 TiWriteErrorLog(
 686             DriverObject,
 687             EVENT_TRANSPORT_REGISTER_FAILED,
 688             TI_ERROR_DRIVERENTRY,
 689             Status,
 690             NULL,
 691             0,
 692             NULL);
 693         TiUnload(DriverObject);
 694         return Status;
 695     }
 696
 697     /* Open loopback adapter */
 698     if (!NT_SUCCESS(LoopRegisterAdapter(NULL, NULL))) {
 699         TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status));
 700         TiUnload(DriverObject);
 701         return STATUS_INSUFFICIENT_RESOURCES;
 702     }
 703
 704 #if 1
 705     /* Open underlying adapter(s) we are bound to */
 706
 707     /* FIXME: Get binding information from registry */
 708
 709     /* Put your own NDIS adapter device name here */
 710
 711     /* ReactOS */
 712     NdisInitUnicodeString(&DeviceName, L"\\Device\\ne2000");
 713
 714     /* NT4 */
 715     //NdisInitUnicodeString(&DeviceName, L"\\Device\\El90x1");
 716
 717     /* NT5 */
 718     //NdisInitUnicodeString(&DeviceName, L"\\Device\\{56388B49-67BB-4419-A3F4-28DF190B9149}");
 719
 720     NdisStatus = LANRegisterAdapter(&DeviceName, &Adapter);
 721     if (!NT_SUCCESS(NdisStatus)) {
 722         TI_DbgPrint(MIN_TRACE, ("Failed to intialize adapter. Status (0x%X).\n", Status));
 723                 TiWriteErrorLog(
 724             DriverObject,
 725             EVENT_TRANSPORT_ADAPTER_NOT_FOUND,
 726             TI_ERROR_DRIVERENTRY,
 727             NdisStatus,
 728             NULL,
 729             0,
 730             NULL);
 731         TiUnload(DriverObject);
 732         return STATUS_DEVICE_DOES_NOT_EXIST;
 733     }
 734 #endif
 735
 736     /* Setup network layer and transport layer entities */
 737     EntityList = ExAllocatePool(NonPagedPool, sizeof(TDIEntityID) * 2);
 738     if (!NT_SUCCESS(Status)) {
 739         TiUnload(DriverObject);
 740         return STATUS_INSUFFICIENT_RESOURCES;
 741     }
 742
 743     EntityList[0].tei_entity   = CL_NL_ENTITY;
 744     EntityList[0].tei_instance = 0;
 745     EntityList[1].tei_entity   = CL_TL_ENTITY;
 746     EntityList[1].tei_instance = 0;
 747     EntityCount = 2;
 748
 749     /* Use direct I/O */
 750     IPDeviceObject->Flags    |= DO_DIRECT_IO;
 751     RawIPDeviceObject->Flags |= DO_DIRECT_IO;
 752     UDPDeviceObject->Flags   |= DO_DIRECT_IO;
 753     TCPDeviceObject->Flags   |= DO_DIRECT_IO;
 754
 755     /* Initialize the driver object with this driver's entry points */
 756     DriverObject->MajorFunction[IRP_MJ_CREATE]  = TiDispatchOpenClose;
 757     DriverObject->MajorFunction[IRP_MJ_CLOSE]   = TiDispatchOpenClose;
 758     DriverObject->MajorFunction[IRP_MJ_CLEANUP] = TiDispatchOpenClose;
 759     DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = TiDispatchInternal;
 760     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = TiDispatch;
 761
 762     DriverObject->DriverUnload = (PDRIVER_UNLOAD)TiUnload;
 763
 764     return STATUS_SUCCESS;
 765 }
 766
 767
 768 VOID
 769 #ifndef _MSC_VER
 770 STDCALL
 771 #endif
 772 IPAddInterface(
 773         DWORD   Unknown0,
 774         DWORD   Unknown1,
 775         DWORD   Unknown2,
 776         DWORD   Unknown3,
 777         DWORD   Unknown4)
 778 {
 779     UNIMPLEMENTED
 780 }
 781
 782
 783 VOID
 784 #ifndef _MSC_VER
 785 STDCALL
 786 #endif
 787 IPDelInterface(
 788         DWORD   Unknown0)
 789 {
 790     UNIMPLEMENTED
 791 }
 792
 793
 794 VOID
 795 #ifndef _MSC_VER
 796 STDCALL
 797 #endif
 798 LookupRoute(
 799         DWORD   Unknown0,
 800         DWORD   Unknown1)
 801 {
 802     UNIMPLEMENTED
 803 }
 804
 805 /* EOF */