drivers/network/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 "precomp.h"
  11
  12 PDEVICE_OBJECT TCPDeviceObject   = NULL;
  13 PDEVICE_OBJECT UDPDeviceObject   = NULL;
  14 PDEVICE_OBJECT IPDeviceObject    = NULL;
  15 PDEVICE_OBJECT RawIPDeviceObject = NULL;
  16 NDIS_HANDLE GlobalPacketPool     = NULL;
  17 NDIS_HANDLE GlobalBufferPool     = NULL;
  18 KSPIN_LOCK EntityListLock;
  19 TDIEntityInfo *EntityList        = NULL;
  20 ULONG EntityCount                = 0;
  21 ULONG EntityMax                  = 0;
  22 UDP_STATISTICS UDPStats;
  23
  24 /* Network timers */
  25 KTIMER IPTimer;
  26 KDPC IPTimeoutDpc;
  27 KSPIN_LOCK IpWorkLock;
  28 WORK_QUEUE_ITEM IpWorkItem;
  29
  30 VOID TiWriteErrorLog(
  31     PDRIVER_OBJECT DriverContext,
  32     NTSTATUS ErrorCode,
  33     ULONG UniqueErrorValue,
  34     NTSTATUS FinalStatus,
  35     PWSTR String,
  36     ULONG DumpDataCount,
  37     PULONG DumpData)
  38 /*
  39  * FUNCTION: Writes an error log entry
  40  * ARGUMENTS:
  41  *     DriverContext    = Pointer to the driver or device object
  42  *     ErrorCode        = An error code to put in the log entry
  43  *     UniqueErrorValue = UniqueErrorValue in the error log packet
  44  *     FinalStatus      = FinalStatus in the error log packet
  45  *     String           = If not NULL, a pointer to a string to put in log
  46  *                        entry
  47  *     DumpDataCount    = Number of ULONGs of dump data
  48  *     DumpData         = Pointer to dump data for the log entry
  49  */
  50 {
  51 #ifdef _MSC_VER
  52     PIO_ERROR_LOG_PACKET LogEntry;
  53     UCHAR EntrySize;
  54     ULONG StringSize;
  55     PUCHAR pString;
  56     static WCHAR DriverName[] = L"TCP/IP";
  57
  58     EntrySize = sizeof(IO_ERROR_LOG_PACKET) +
  59         (DumpDataCount * sizeof(ULONG)) + sizeof(DriverName);
  60
  61     if (String) {
  62         StringSize = (wcslen(String) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
  63         EntrySize += (UCHAR)StringSize;
  64     }
  65
  66     LogEntry = (PIO_ERROR_LOG_PACKET)IoAllocateErrorLogEntry(
  67                 DriverContext, EntrySize);
  68
  69     if (LogEntry) {
  70         LogEntry->MajorFunctionCode = -1;
  71         LogEntry->RetryCount        = -1;
  72         LogEntry->DumpDataSize      = (USHORT)(DumpDataCount * sizeof(ULONG));
  73         LogEntry->NumberOfStrings   = (String == NULL) ? 1 : 2;
  74         LogEntry->StringOffset      = sizeof(IO_ERROR_LOG_PACKET) + (DumpDataCount-1) * sizeof(ULONG);
  75         LogEntry->EventCategory     = 0;
  76         LogEntry->ErrorCode         = ErrorCode;
  77         LogEntry->UniqueErrorValue  = UniqueErrorValue;
  78         LogEntry->FinalStatus       = FinalStatus;
  79         LogEntry->SequenceNumber    = -1;
  80         LogEntry->IoControlCode     = 0;
  81
  82         if (DumpDataCount)
  83             RtlCopyMemory(LogEntry->DumpData, DumpData, DumpDataCount * sizeof(ULONG));
  84
  85         pString = ((PUCHAR)LogEntry) + LogEntry->StringOffset;
  86         RtlCopyMemory(pString, DriverName, sizeof(DriverName));
  87         pString += sizeof(DriverName);
  88
  89         if (String)
  90             RtlCopyMemory(pString, String, StringSize);
  91
  92         IoWriteErrorLogEntry(LogEntry);
  93     }
  94 #endif
  95 }
  96
  97 /*
  98  * FUNCTION: Creates a file object
  99  * ARGUMENTS:
 100  *     DeviceObject = Pointer to a device object for this driver
 101  *     Irp          = Pointer to a I/O request packet
 102  * RETURNS:
 103  *     Status of the operation
 104  */
 105
 106 NTSTATUS TiCreateFileObject(
 107   PDEVICE_OBJECT DeviceObject,
 108   PIRP Irp)
 109 {
 110   PFILE_FULL_EA_INFORMATION EaInfo;
 111   PTRANSPORT_CONTEXT Context;
 112   PIO_STACK_LOCATION IrpSp;
 113   PTA_IP_ADDRESS Address;
 114   TDI_REQUEST Request;
 115   PVOID ClientContext;
 116   NTSTATUS Status;
 117   ULONG Protocol;
 118
 119   TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp));
 120
 121   EaInfo = Irp->AssociatedIrp.SystemBuffer;
 122 CP
 123   /* Parameter check */
 124   /* No EA information means that we're opening for SET/QUERY_INFORMATION
 125    * style calls. */
 126 #if 0
 127   if (!EaInfo) {
 128     TI_DbgPrint(MIN_TRACE, ("No EA information in IRP.\n"));
 129     return STATUS_INVALID_PARAMETER;
 130   }
 131 #endif
 132 CP
 133   /* Allocate resources here. We release them again if something failed */
 134   Context = ExAllocatePool(NonPagedPool, sizeof(TRANSPORT_CONTEXT));
 135   if (!Context) {
 136     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 137     return STATUS_INSUFFICIENT_RESOURCES;
 138   }
 139 CP
 140   Context->CancelIrps = FALSE;
 141 CP
 142   IrpSp = IoGetCurrentIrpStackLocation(Irp);
 143   IrpSp->FileObject->FsContext = Context;
 144   Request.RequestContext       = Irp;
 145 CP
 146   /* Branch to the right handler */
 147   if (EaInfo &&
 148       (EaInfo->EaNameLength == TDI_TRANSPORT_ADDRESS_LENGTH) &&
 149       (RtlCompareMemory
 150        (&EaInfo->EaName, TdiTransportAddress,
 151         TDI_TRANSPORT_ADDRESS_LENGTH) == TDI_TRANSPORT_ADDRESS_LENGTH)) {
 152     /* This is a request to open an address */
 153 CP
 154
 155         /* XXX This should probably be done in IoCreateFile() */
 156     /* Parameter checks */
 157
 158     Address = (PTA_IP_ADDRESS)(EaInfo->EaName + EaInfo->EaNameLength + 1); //0-term
 159
 160     if ((EaInfo->EaValueLength < sizeof(TA_IP_ADDRESS)) ||
 161       (Address->TAAddressCount != 1) ||
 162       (Address->Address[0].AddressLength < TDI_ADDRESS_LENGTH_IP) ||
 163       (Address->Address[0].AddressType != TDI_ADDRESS_TYPE_IP)) {
 164       TI_DbgPrint(MIN_TRACE, ("Parameters are invalid:\n"));
 165       TI_DbgPrint(MIN_TRACE, ("AddressCount: %d\n", Address->TAAddressCount));
 166       if( Address->TAAddressCount == 1 ) {
 167           TI_DbgPrint(MIN_TRACE, ("AddressLength: %\n",
 168                                   Address->Address[0].AddressLength));
 169           TI_DbgPrint(MIN_TRACE, ("AddressType: %\n",
 170                                   Address->Address[0].AddressType));
 171       }
 172       PoolFreeBuffer(Context);
 173       return STATUS_INVALID_PARAMETER;
 174     }
 175 CP
 176     /* Open address file object */
 177
 178     /* Protocol depends on device object so find the protocol */
 179     if (DeviceObject == TCPDeviceObject)
 180       Protocol = IPPROTO_TCP;
 181     else if (DeviceObject == UDPDeviceObject)
 182       Protocol = IPPROTO_UDP;
 183     else if (DeviceObject == IPDeviceObject)
 184       Protocol = IPPROTO_RAW;
 185     else if (DeviceObject == RawIPDeviceObject) {
 186       Status = TiGetProtocolNumber(&IrpSp->FileObject->FileName, &Protocol);
 187       if (!NT_SUCCESS(Status)) {
 188         TI_DbgPrint(MIN_TRACE, ("Raw IP protocol number is invalid.\n"));
 189         PoolFreeBuffer(Context);
 190         return STATUS_INVALID_PARAMETER;
 191       }
 192     } else {
 193       TI_DbgPrint(MIN_TRACE, ("Invalid device object at (0x%X).\n", DeviceObject));
 194       PoolFreeBuffer(Context);
 195       return STATUS_INVALID_PARAMETER;
 196     }
 197 CP
 198     Status = FileOpenAddress(&Request, Address, Protocol, NULL);
 199     if (NT_SUCCESS(Status)) {
 200       IrpSp->FileObject->FsContext2 = (PVOID)TDI_TRANSPORT_ADDRESS_FILE;
 201       Context->Handle.AddressHandle = Request.Handle.AddressHandle;
 202     }
 203 CP
 204   } else if (EaInfo &&
 205              (EaInfo->EaNameLength == TDI_CONNECTION_CONTEXT_LENGTH) &&
 206              (RtlCompareMemory
 207               (&EaInfo->EaName, TdiConnectionContext,
 208                TDI_CONNECTION_CONTEXT_LENGTH) ==
 209               TDI_CONNECTION_CONTEXT_LENGTH)) {
 210     /* This is a request to open a connection endpoint */
 211 CP
 212     /* Parameter checks */
 213
 214     if (EaInfo->EaValueLength < sizeof(PVOID)) {
 215       TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
 216       PoolFreeBuffer(Context);
 217       return STATUS_INVALID_PARAMETER;
 218     }
 219
 220     /* Can only do connection oriented communication using TCP */
 221
 222     if (DeviceObject != TCPDeviceObject) {
 223       TI_DbgPrint(MIN_TRACE, ("Bad device object.\n"));
 224       PoolFreeBuffer(Context);
 225       return STATUS_INVALID_PARAMETER;
 226     }
 227
 228     ClientContext = *((PVOID*)(EaInfo->EaName + EaInfo->EaNameLength));
 229
 230     /* Open connection endpoint file object */
 231
 232     Status = FileOpenConnection(&Request, ClientContext);
 233     if (NT_SUCCESS(Status)) {
 234       IrpSp->FileObject->FsContext2 = (PVOID)TDI_CONNECTION_FILE;
 235       Context->Handle.ConnectionContext = Request.Handle.ConnectionContext;
 236     }
 237   } else {
 238     /* This is a request to open a control connection */
 239     Status = FileOpenControlChannel(&Request);
 240     if (NT_SUCCESS(Status)) {
 241       IrpSp->FileObject->FsContext2 = (PVOID)TDI_CONTROL_CHANNEL_FILE;
 242       Context->Handle.ControlChannel = Request.Handle.ControlChannel;
 243     }
 244   }
 245
 246   if (!NT_SUCCESS(Status))
 247     PoolFreeBuffer(Context);
 248
 249   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 250
 251   Irp->IoStatus.Status = Status;
 252   return Status;
 253 }
 254
 255 /*
 256  * FUNCTION: Releases resources used by a file object
 257  * ARGUMENTS:
 258  *     DeviceObject = Pointer to a device object for this driver
 259  *     Irp          = Pointer to a I/O request packet
 260  * RETURNS:
 261  *     Status of the operation
 262  * NOTES:
 263  *     This function does not pend
 264  */
 265 NTSTATUS TiCleanupFileObject(
 266   PDEVICE_OBJECT DeviceObject,
 267   PIRP Irp)
 268 {
 269   PIO_STACK_LOCATION IrpSp;
 270   PTRANSPORT_CONTEXT Context;
 271   TDI_REQUEST Request;
 272   NTSTATUS Status;
 273   KIRQL OldIrql;
 274
 275   IrpSp   = IoGetCurrentIrpStackLocation(Irp);
 276   Context = IrpSp->FileObject->FsContext;
 277   if (!Context) {
 278     TI_DbgPrint(MIN_TRACE, ("Parameters are invalid.\n"));
 279     return STATUS_INVALID_PARAMETER;
 280   }
 281
 282   IoAcquireCancelSpinLock(&OldIrql);
 283
 284   Context->CancelIrps = TRUE;
 285
 286   IoReleaseCancelSpinLock(OldIrql);
 287
 288   switch ((ULONG_PTR)IrpSp->FileObject->FsContext2) {
 289   case TDI_TRANSPORT_ADDRESS_FILE:
 290     Request.Handle.AddressHandle = Context->Handle.AddressHandle;
 291     Status = FileCloseAddress(&Request);
 292     break;
 293
 294   case TDI_CONNECTION_FILE:
 295     Request.Handle.ConnectionContext = Context->Handle.ConnectionContext;
 296     Status = FileCloseConnection(&Request);
 297     break;
 298
 299   case TDI_CONTROL_CHANNEL_FILE:
 300     Request.Handle.ControlChannel = Context->Handle.ControlChannel;
 301     Status = FileCloseControlChannel(&Request);
 302     break;
 303
 304   default:
 305     /* This should never happen */
 306
 307     TI_DbgPrint(MIN_TRACE, ("Unknown transport context.\n"));
 308
 309     IoAcquireCancelSpinLock(&OldIrql);
 310     Context->CancelIrps = FALSE;
 311     IoReleaseCancelSpinLock(OldIrql);
 312
 313     Status = STATUS_INVALID_PARAMETER;
 314
 315   }
 316
 317   Irp->IoStatus.Status = Status;
 318
 319   return Irp->IoStatus.Status;
 320 }
 321
 322
 323 NTSTATUS STDCALL
 324 TiDispatchOpenClose(
 325   IN PDEVICE_OBJECT DeviceObject,
 326   IN PIRP Irp)
 327 /*
 328  * FUNCTION: Main dispath routine
 329  * ARGUMENTS:
 330  *     DeviceObject = Pointer to a device object for this driver
 331  *     Irp          = Pointer to a I/O request packet
 332  * RETURNS:
 333  *     Status of the operation
 334  */
 335 {
 336   PIO_STACK_LOCATION IrpSp;
 337   NTSTATUS Status;
 338   PTRANSPORT_CONTEXT Context;
 339
 340   RIRP(Irp);
 341
 342 //  DbgPrint("Called. DeviceObject is at (0x%X), IRP is at (0x%X).\n", DeviceObject, Irp);
 343
 344   IrpSp = IoGetCurrentIrpStackLocation(Irp);
 345
 346   switch (IrpSp->MajorFunction) {
 347   /* Open an address file, connection endpoint, or control connection */
 348   case IRP_MJ_CREATE:
 349     Status = TiCreateFileObject(DeviceObject, Irp);
 350     break;
 351
 352   /* Close an address file, connection endpoint, or control connection */
 353   case IRP_MJ_CLOSE:
 354     Context = (PTRANSPORT_CONTEXT)IrpSp->FileObject->FsContext;
 355     if (Context)
 356         PoolFreeBuffer(Context);
 357     Status = STATUS_SUCCESS;
 358     break;
 359
 360   /* Release resources bound to an address file, connection endpoint,
 361      or control connection */
 362   case IRP_MJ_CLEANUP:
 363     Status = TiCleanupFileObject(DeviceObject, Irp);
 364     break;
 365
 366   default:
 367     Status = STATUS_INVALID_DEVICE_REQUEST;
 368   }
 369
 370   //DbgPrint("Leaving. Status is (0x%X)\n", Status);
 371
 372   return IRPFinish( Irp, Status );
 373 }
 374
 375
 376 NTSTATUS NTAPI
 377 TiDispatchInternal(
 378   PDEVICE_OBJECT DeviceObject,
 379   PIRP Irp)
 380 /*
 381  * FUNCTION: Internal IOCTL dispatch routine
 382  * ARGUMENTS:
 383  *     DeviceObject = Pointer to a device object for this driver
 384  *     Irp          = Pointer to a I/O request packet
 385  * RETURNS:
 386  *     Status of the operation
 387  */
 388 {
 389   NTSTATUS Status;
 390   BOOL Complete = TRUE;
 391   PIO_STACK_LOCATION IrpSp;
 392
 393   RIRP(Irp);
 394
 395   IrpSp = IoGetCurrentIrpStackLocation(Irp);
 396
 397   TI_DbgPrint(DEBUG_IRP, ("Called. DeviceObject is at (0x%X), IRP is at (0x%X) MN (%d).\n",
 398     DeviceObject, Irp, IrpSp->MinorFunction));
 399
 400   Irp->IoStatus.Status      = STATUS_SUCCESS;
 401   Irp->IoStatus.Information = 0;
 402
 403   switch (IrpSp->MinorFunction) {
 404   case TDI_RECEIVE:
 405     Status = DispTdiReceive(Irp);
 406     Complete = FALSE;
 407     break;
 408
 409   case TDI_RECEIVE_DATAGRAM:
 410     Status = DispTdiReceiveDatagram(Irp);
 411     Complete = FALSE;
 412     break;
 413
 414   case TDI_SEND:
 415     Status = DispTdiSend(Irp);
 416     Complete = FALSE; /* Completed in DispTdiSend */
 417     break;
 418
 419   case TDI_SEND_DATAGRAM:
 420     Status = DispTdiSendDatagram(Irp);
 421     Complete = FALSE;
 422     break;
 423
 424   case TDI_ACCEPT:
 425     Status = DispTdiAccept(Irp);
 426     break;
 427
 428   case TDI_LISTEN:
 429     Status = DispTdiListen(Irp);
 430     Complete = FALSE;
 431     break;
 432
 433   case TDI_CONNECT:
 434     Status = DispTdiConnect(Irp);
 435     Complete = FALSE; /* Completed by the TCP event handler */
 436     break;
 437
 438   case TDI_DISCONNECT:
 439     Status = DispTdiDisconnect(Irp);
 440     break;
 441
 442   case TDI_ASSOCIATE_ADDRESS:
 443     Status = DispTdiAssociateAddress(Irp);
 444     break;
 445
 446   case TDI_DISASSOCIATE_ADDRESS:
 447     Status = DispTdiDisassociateAddress(Irp);
 448     break;
 449
 450   case TDI_QUERY_INFORMATION:
 451     Status = DispTdiQueryInformation(DeviceObject, Irp);
 452     break;
 453
 454   case TDI_SET_INFORMATION:
 455     Status = DispTdiSetInformation(Irp);
 456     break;
 457
 458   case TDI_SET_EVENT_HANDLER:
 459     Status = DispTdiSetEventHandler(Irp);
 460     break;
 461
 462   case TDI_ACTION:
 463     Status = STATUS_SUCCESS;
 464     break;
 465
 466   /* An unsupported IOCTL code was submitted */
 467   default:
 468     Status = STATUS_INVALID_DEVICE_REQUEST;
 469   }
 470
 471   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 472
 473   if( Complete )
 474       IRPFinish( Irp, Status );
 475   else
 476       Irp->IoStatus.Status = Status;
 477
 478   return Status;
 479 }
 480
 481
 482 NTSTATUS NTAPI
 483 TiDispatch(
 484   PDEVICE_OBJECT DeviceObject,
 485   PIRP Irp)
 486 /*
 487  * FUNCTION: Dispatch routine for IRP_MJ_DEVICE_CONTROL requests
 488  * ARGUMENTS:
 489  *     DeviceObject = Pointer to a device object for this driver
 490  *     Irp          = Pointer to a I/O request packet
 491  * RETURNS:
 492  *     Status of the operation
 493  */
 494 {
 495   NTSTATUS Status;
 496   PIO_STACK_LOCATION IrpSp;
 497
 498   RIRP(Irp);
 499
 500   IrpSp  = IoGetCurrentIrpStackLocation(Irp);
 501
 502   TI_DbgPrint(DEBUG_IRP, ("Called. IRP is at (0x%X).\n", Irp));
 503
 504   Irp->IoStatus.Information = 0;
 505
 506 #ifdef _MSC_VER
 507   Status = TdiMapUserRequest(DeviceObject, Irp, IrpSp);
 508   if (NT_SUCCESS(Status)) {
 509     TiDispatchInternal(DeviceObject, Irp);
 510     Status = STATUS_PENDING;
 511   } else {
 512 #else
 513   if (TRUE) {
 514 #endif
 515     /* See if this request is TCP/IP specific */
 516     switch (IrpSp->Parameters.DeviceIoControl.IoControlCode) {
 517     case IOCTL_TCP_QUERY_INFORMATION_EX:
 518       TI_DbgPrint(MIN_TRACE, ("TCP_QUERY_INFORMATION_EX\n"));
 519       Status = DispTdiQueryInformationEx(Irp, IrpSp);
 520       break;
 521
 522     case IOCTL_TCP_SET_INFORMATION_EX:
 523       TI_DbgPrint(MIN_TRACE, ("TCP_SET_INFORMATION_EX\n"));
 524       Status = DispTdiSetInformationEx(Irp, IrpSp);
 525       break;
 526
 527     case IOCTL_SET_IP_ADDRESS:
 528       TI_DbgPrint(MIN_TRACE, ("SET_IP_ADDRESS\n"));
 529       Status = DispTdiSetIPAddress(Irp, IrpSp);
 530       break;
 531
 532     case IOCTL_DELETE_IP_ADDRESS:
 533       TI_DbgPrint(MIN_TRACE, ("DELETE_IP_ADDRESS\n"));
 534       Status = DispTdiDeleteIPAddress(Irp, IrpSp);
 535       break;
 536
 537     default:
 538       TI_DbgPrint(MIN_TRACE, ("Unknown IOCTL 0x%X\n",
 539           IrpSp->Parameters.DeviceIoControl.IoControlCode));
 540       Status = STATUS_NOT_IMPLEMENTED;
 541       break;
 542     }
 543   }
 544
 545   TI_DbgPrint(DEBUG_IRP, ("Leaving. Status = (0x%X).\n", Status));
 546
 547   return IRPFinish( Irp, Status );
 548 }
 549
 550
 551 VOID STDCALL TiUnload(
 552   PDRIVER_OBJECT DriverObject)
 553 /*
 554  * FUNCTION: Unloads the driver
 555  * ARGUMENTS:
 556  *     DriverObject = Pointer to driver object created by the system
 557  */
 558 {
 559 #ifdef DBG
 560   KIRQL OldIrql;
 561
 562   TcpipAcquireSpinLock(&AddressFileListLock, &OldIrql);
 563   if (!IsListEmpty(&AddressFileListHead)) {
 564     TI_DbgPrint(MIN_TRACE, ("Open address file objects exists.\n"));
 565   }
 566   TcpipReleaseSpinLock(&AddressFileListLock, OldIrql);
 567 #endif
 568   ChewShutdown();
 569
 570   /* Cancel timer */
 571   KeCancelTimer(&IPTimer);
 572
 573   /* Unregister loopback adapter */
 574   LoopUnregisterAdapter(NULL);
 575
 576   /* Unregister protocol with NDIS */
 577   LANUnregisterProtocol();
 578
 579   /* Shutdown transport level protocol subsystems */
 580   TCPShutdown();
 581   UDPShutdown();
 582   RawIPShutdown();
 583
 584   /* Shutdown network level protocol subsystem */
 585   IPShutdown();
 586
 587   /* Shutdown the lan worker */
 588   LANShutdown();
 589
 590   /* Free NDIS buffer descriptors */
 591   if (GlobalBufferPool)
 592     NdisFreeBufferPool(GlobalBufferPool);
 593
 594   /* Free NDIS packet descriptors */
 595   if (GlobalPacketPool)
 596     NdisFreePacketPool(GlobalPacketPool);
 597
 598   /* Release all device objects */
 599
 600   if (TCPDeviceObject)
 601     IoDeleteDevice(TCPDeviceObject);
 602
 603   if (UDPDeviceObject)
 604     IoDeleteDevice(UDPDeviceObject);
 605
 606   if (RawIPDeviceObject)
 607     IoDeleteDevice(RawIPDeviceObject);
 608
 609   if (IPDeviceObject)
 610     IoDeleteDevice(IPDeviceObject);
 611
 612   if (EntityList)
 613     PoolFreeBuffer(EntityList);
 614
 615   TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));
 616 }
 617
 618 VOID STDCALL IPTimeoutDpcFn(
 619     PKDPC Dpc,
 620     PVOID DeferredContext,
 621     PVOID SystemArgument1,
 622     PVOID SystemArgument2)
 623 /*
 624  * FUNCTION: Timeout DPC
 625  * ARGUMENTS:
 626  *     Dpc             = Pointer to our DPC object
 627  *     DeferredContext = Pointer to context information (unused)
 628  *     SystemArgument1 = Unused
 629  *     SystemArgument2 = Unused
 630  * NOTES:
 631  *     This routine is dispatched once in a while to do maintainance jobs
 632  */
 633 {
 634     if( !IpWorkItemQueued ) {
 635         ExQueueWorkItem( &IpWorkItem, CriticalWorkQueue );
 636         IpWorkItemQueued = TRUE;
 637     }
 638 }
 639
 640 NTSTATUS NTAPI
 641 DriverEntry(
 642   PDRIVER_OBJECT DriverObject,
 643   PUNICODE_STRING RegistryPath)
 644 /*
 645  * FUNCTION: Main driver entry point
 646  * ARGUMENTS:
 647  *     DriverObject = Pointer to a driver object for this driver
 648  *     RegistryPath = Registry node for configuration parameters
 649  * RETURNS:
 650  *     Status of driver initialization
 651  */
 652 {
 653   NTSTATUS Status;
 654   UNICODE_STRING strIpDeviceName = RTL_CONSTANT_STRING(DD_IP_DEVICE_NAME);
 655   UNICODE_STRING strRawDeviceName = RTL_CONSTANT_STRING(DD_RAWIP_DEVICE_NAME);
 656   UNICODE_STRING strUdpDeviceName = RTL_CONSTANT_STRING(DD_UDP_DEVICE_NAME);
 657   UNICODE_STRING strTcpDeviceName = RTL_CONSTANT_STRING(DD_TCP_DEVICE_NAME);
 658   UNICODE_STRING strNdisDeviceName = RTL_CONSTANT_STRING(TCPIP_PROTOCOL_NAME);
 659   NDIS_STATUS NdisStatus;
 660   LARGE_INTEGER DueTime;
 661
 662   TI_DbgPrint(MAX_TRACE, ("Called.\n"));
 663
 664   TrackingInit();
 665   TrackTag(NDIS_BUFFER_TAG);
 666   TrackTag(NDIS_PACKET_TAG);
 667   TrackTag(FBSD_MALLOC);
 668   TrackTag(EXALLOC_TAG);
 669
 670   /* TdiInitialize() ? */
 671
 672   /* FIXME: Create symbolic links in Win32 namespace */
 673
 674   /* Create IP device object */
 675   Status = IoCreateDevice(DriverObject, 0, &strIpDeviceName,
 676     FILE_DEVICE_NETWORK, 0, FALSE, &IPDeviceObject);
 677   if (!NT_SUCCESS(Status)) {
 678     TI_DbgPrint(MIN_TRACE, ("Failed to create IP device object. Status (0x%X).\n", Status));
 679     return Status;
 680   }
 681
 682   ChewInit( IPDeviceObject );
 683
 684   /* Create RawIP device object */
 685   Status = IoCreateDevice(DriverObject, 0, &strRawDeviceName,
 686     FILE_DEVICE_NETWORK, 0, FALSE, &RawIPDeviceObject);
 687   if (!NT_SUCCESS(Status)) {
 688     TI_DbgPrint(MIN_TRACE, ("Failed to create RawIP device object. Status (0x%X).\n", Status));
 689     TiUnload(DriverObject);
 690     return Status;
 691   }
 692
 693   /* Create UDP device object */
 694   Status = IoCreateDevice(DriverObject, 0, &strUdpDeviceName,
 695     FILE_DEVICE_NETWORK, 0, FALSE, &UDPDeviceObject);
 696   if (!NT_SUCCESS(Status)) {
 697     TI_DbgPrint(MIN_TRACE, ("Failed to create UDP device object. Status (0x%X).\n", Status));
 698     TiUnload(DriverObject);
 699     return Status;
 700   }
 701
 702   /* Create TCP device object */
 703   Status = IoCreateDevice(DriverObject, 0, &strTcpDeviceName,
 704     FILE_DEVICE_NETWORK, 0, FALSE, &TCPDeviceObject);
 705   if (!NT_SUCCESS(Status)) {
 706     TI_DbgPrint(MIN_TRACE, ("Failed to create TCP device object. Status (0x%X).\n", Status));
 707     TiUnload(DriverObject);
 708     return Status;
 709   }
 710
 711   /* Setup network layer and transport layer entities */
 712   KeInitializeSpinLock(&EntityListLock);
 713   EntityList = ExAllocatePool(NonPagedPool, sizeof(TDIEntityID) * MAX_TDI_ENTITIES );
 714   if (!EntityList) {
 715     TI_DbgPrint(MIN_TRACE, ("Insufficient resources.\n"));
 716     TiUnload(DriverObject);
 717     return STATUS_INSUFFICIENT_RESOURCES;
 718   }
 719
 720   EntityList[0].tei_entity   = CL_NL_ENTITY;
 721   EntityList[0].tei_instance = 0;
 722   EntityList[0].context      = 0;
 723   EntityList[0].info_req     = InfoNetworkLayerTdiQueryEx;
 724   EntityList[0].info_set     = InfoNetworkLayerTdiSetEx;
 725   EntityList[1].tei_entity   = CL_TL_ENTITY;
 726   EntityList[1].tei_instance = 0;
 727   EntityList[1].context      = 0;
 728   EntityList[1].info_req     = InfoTransportLayerTdiQueryEx;
 729   EntityList[1].info_set     = InfoTransportLayerTdiSetEx;
 730   EntityCount = 2;
 731   EntityMax   = MAX_TDI_ENTITIES;
 732
 733   /* Allocate NDIS packet descriptors */
 734   NdisAllocatePacketPool(&NdisStatus, &GlobalPacketPool, 100, sizeof(PACKET_CONTEXT));
 735   if (NdisStatus != NDIS_STATUS_SUCCESS) {
 736     TiUnload(DriverObject);
 737     return STATUS_INSUFFICIENT_RESOURCES;
 738   }
 739
 740   /* Allocate NDIS buffer descriptors */
 741   NdisAllocateBufferPool(&NdisStatus, &GlobalBufferPool, 100);
 742   if (NdisStatus != NDIS_STATUS_SUCCESS) {
 743     TiUnload(DriverObject);
 744     return STATUS_INSUFFICIENT_RESOURCES;
 745   }
 746
 747   /* Initialize address file list and protecting spin lock */
 748   InitializeListHead(&AddressFileListHead);
 749   KeInitializeSpinLock(&AddressFileListLock);
 750
 751   /* Initialize connection endpoint list and protecting spin lock */
 752   InitializeListHead(&ConnectionEndpointListHead);
 753   KeInitializeSpinLock(&ConnectionEndpointListLock);
 754
 755   /* Initialize interface list and protecting spin lock */
 756   InitializeListHead(&InterfaceListHead);
 757   KeInitializeSpinLock(&InterfaceListLock);
 758
 759   /* Initialize network level protocol subsystem */
 760   IPStartup(RegistryPath);
 761
 762   /* Initialize transport level protocol subsystems */
 763   RawIPStartup();
 764   UDPStartup();
 765   TCPStartup();
 766
 767   /* Initialize the lan worker */
 768   LANStartup();
 769
 770   /* Register protocol with NDIS */
 771   /* This used to be IP_DEVICE_NAME but the DDK says it has to match your entry in the SCM */
 772   Status = LANRegisterProtocol(&strNdisDeviceName);
 773   if (!NT_SUCCESS(Status)) {
 774           TI_DbgPrint(MIN_TRACE,("Failed to register protocol with NDIS; status 0x%x\n", Status));
 775           TiWriteErrorLog(
 776       DriverObject,
 777       EVENT_TRANSPORT_REGISTER_FAILED,
 778       TI_ERROR_DRIVERENTRY,
 779       Status,
 780       NULL,
 781       0,
 782       NULL);
 783     TiUnload(DriverObject);
 784     return Status;
 785   }
 786
 787   /* Open loopback adapter */
 788   if (!NT_SUCCESS(LoopRegisterAdapter(NULL, NULL))) {
 789     TI_DbgPrint(MIN_TRACE, ("Failed to create loopback adapter. Status (0x%X).\n", Status));
 790     TiUnload(DriverObject);
 791     return STATUS_INSUFFICIENT_RESOURCES;
 792   }
 793
 794   /* Use direct I/O */
 795   IPDeviceObject->Flags    |= DO_DIRECT_IO;
 796   RawIPDeviceObject->Flags |= DO_DIRECT_IO;
 797   UDPDeviceObject->Flags   |= DO_DIRECT_IO;
 798   TCPDeviceObject->Flags   |= DO_DIRECT_IO;
 799
 800   /* Initialize the driver object with this driver's entry points */
 801   DriverObject->MajorFunction[IRP_MJ_CREATE]  = TiDispatchOpenClose;
 802   DriverObject->MajorFunction[IRP_MJ_CLOSE]   = TiDispatchOpenClose;
 803   DriverObject->MajorFunction[IRP_MJ_CLEANUP] = TiDispatchOpenClose;
 804   DriverObject->MajorFunction[IRP_MJ_INTERNAL_DEVICE_CONTROL] = TiDispatchInternal;
 805   DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = TiDispatch;
 806
 807   DriverObject->DriverUnload = TiUnload;
 808
 809   /* Initialize our periodic timer and its associated DPC object. When the
 810      timer expires, the IPTimeout deferred procedure call (DPC) is queued */
 811   ExInitializeWorkItem( &IpWorkItem, IPTimeout, NULL );
 812   KeInitializeDpc(&IPTimeoutDpc, IPTimeoutDpcFn, NULL);
 813   KeInitializeTimer(&IPTimer);
 814
 815   /* Start the periodic timer with an initial and periodic
 816      relative expiration time of IP_TIMEOUT milliseconds */
 817   DueTime.QuadPart = -(LONGLONG)IP_TIMEOUT * 10000;
 818   KeSetTimerEx(&IPTimer, DueTime, IP_TIMEOUT, &IPTimeoutDpc);
 819
 820   return STATUS_SUCCESS;
 821 }
 822
 823
 824 VOID NTAPI
 825 IPAddInterface(
 826         DWORD   Unknown0,
 827         DWORD   Unknown1,
 828         DWORD   Unknown2,
 829         DWORD   Unknown3,
 830         DWORD   Unknown4)
 831 {
 832     UNIMPLEMENTED
 833 }
 834
 835
 836 VOID NTAPI
 837 IPDelInterface(
 838         DWORD   Unknown0)
 839 {
 840     UNIMPLEMENTED
 841 }
 842
 843
 844 VOID NTAPI
 845 LookupRoute(
 846         DWORD   Unknown0,
 847         DWORD   Unknown1)
 848 {
 849     UNIMPLEMENTED
 850 }
 851
 852 /* EOF */