reactos/lib/drivers/ip/transport/tcp/tcp.c

   1 /*
   2  * COPYRIGHT:   See COPYING in the top level directory
   3  * PROJECT:     ReactOS TCP/IP protocol driver
   4  * FILE:        transport/tcp/tcp.c
   5  * PURPOSE:     Transmission Control Protocol
   6  * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
   7  *              Art Yerkes (arty@users.sf.net)
   8  * REVISIONS:
   9  *   CSH 01/08-2000  Created
  10  *   arty 12/21/2004 Added accept
  11  */
  12
  13 #include "precomp.h"
  14
  15 LONG TCP_IPIdentification = 0;
  16 static BOOLEAN TCPInitialized = FALSE;
  17 static NPAGED_LOOKASIDE_LIST TCPSegmentList;
  18 LIST_ENTRY SignalledConnectionsList;
  19 KSPIN_LOCK SignalledConnectionsLock;
  20 LIST_ENTRY SleepingThreadsList;
  21 FAST_MUTEX SleepingThreadsLock;
  22 RECURSIVE_MUTEX TCPLock;
  23 PORT_SET TCPPorts;
  24
  25 static VOID HandleSignalledConnection( PCONNECTION_ENDPOINT Connection ) {
  26     NTSTATUS Status = STATUS_SUCCESS;
  27     PTCP_COMPLETION_ROUTINE Complete;
  28     PTDI_BUCKET Bucket;
  29     PLIST_ENTRY Entry;
  30     PIRP Irp;
  31     PMDL Mdl;
  32
  33     ASSERT_LOCKED(&TCPLock);
  34
  35     TI_DbgPrint(MID_TRACE,("Handling signalled state on %x (%x)\n",
  36                            Connection, Connection->SocketContext));
  37
  38     if( Connection->SignalState & SEL_FIN ) {
  39         TI_DbgPrint(DEBUG_TCP, ("EOF From socket\n"));
  40
  41         while ((Entry = ExInterlockedRemoveHeadList( &Connection->ReceiveRequest,
  42                                                      &Connection->Lock )) != NULL)
  43         {
  44            Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
  45            Complete = Bucket->Request.RequestNotifyObject;
  46
  47            /* We have to notify oskittcp of the abortion */
  48            TCPDisconnect
  49              ( Connection,
  50                TDI_DISCONNECT_RELEASE | TDI_DISCONNECT_ABORT,
  51                NULL,
  52                NULL,
  53                Bucket->Request.RequestNotifyObject,
  54                (PIRP)Bucket->Request.RequestContext );
  55
  56            Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
  57
  58            exFreePool(Bucket);
  59         }
  60
  61         while ((Entry = ExInterlockedRemoveHeadList( &Connection->SendRequest,
  62                                                      &Connection->Lock )) != NULL)
  63         {
  64            Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
  65            Complete = Bucket->Request.RequestNotifyObject;
  66
  67            /* We have to notify oskittcp of the abortion */
  68            TCPDisconnect
  69              ( Connection,
  70                TDI_DISCONNECT_RELEASE,
  71                NULL,
  72                NULL,
  73                Bucket->Request.RequestNotifyObject,
  74                (PIRP)Bucket->Request.RequestContext );
  75
  76            Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
  77
  78            exFreePool(Bucket);
  79         }
  80
  81         while ((Entry = ExInterlockedRemoveHeadList( &Connection->ListenRequest,
  82                                                      &Connection->Lock )) != NULL)
  83         {
  84            Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
  85            Complete = Bucket->Request.RequestNotifyObject;
  86
  87            /* We have to notify oskittcp of the abortion */
  88            TCPAbortListenForSocket(Connection->AddressFile->Listener,
  89                                Connection);
  90
  91            Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
  92         }
  93
  94         while ((Entry = ExInterlockedRemoveHeadList( &Connection->ConnectRequest,
  95                                                      &Connection->Lock )) != NULL)
  96         {
  97            Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
  98            Complete = Bucket->Request.RequestNotifyObject;
  99
 100            Complete( Bucket->Request.RequestContext, STATUS_CANCELLED, 0 );
 101         }
 102
 103         Connection->SignalState = 0;
 104     }
 105
 106     /* Things that can happen when we try the initial connection */
 107     if( Connection->SignalState & SEL_CONNECT ) {
 108         while( (Entry = ExInterlockedRemoveHeadList( &Connection->ConnectRequest,
 109                                                      &Connection->Lock )) != NULL ) {
 110
 111             TI_DbgPrint(DEBUG_TCP, ("Connect Event\n"));
 112
 113             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 114             Complete = Bucket->Request.RequestNotifyObject;
 115             TI_DbgPrint(DEBUG_TCP,
 116                         ("Completing Request %x\n", Bucket->Request.RequestContext));
 117
 118             Complete( Bucket->Request.RequestContext, STATUS_SUCCESS, 0 );
 119
 120             /* Frees the bucket allocated in TCPConnect */
 121             exFreePool( Bucket );
 122         }
 123     }
 124
 125     if( Connection->SignalState & SEL_ACCEPT ) {
 126         /* Handle readable on a listening socket --
 127          * TODO: Implement filtering
 128          */
 129
 130         TI_DbgPrint(DEBUG_TCP,("Accepting new connection on %x (Queue: %s)\n",
 131                                Connection,
 132                                IsListEmpty(&Connection->ListenRequest) ?
 133                                "empty" : "nonempty"));
 134
 135         while( (Entry = ExInterlockedRemoveHeadList( &Connection->ListenRequest,
 136                                                      &Connection->Lock )) != NULL ) {
 137             PIO_STACK_LOCATION IrpSp;
 138
 139             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 140             Complete = Bucket->Request.RequestNotifyObject;
 141
 142             Irp = Bucket->Request.RequestContext;
 143             IrpSp = IoGetCurrentIrpStackLocation( Irp );
 144
 145             TI_DbgPrint(DEBUG_TCP,("Getting the socket\n"));
 146             Status = TCPServiceListeningSocket
 147                 ( Connection->AddressFile->Listener,
 148                   Bucket->AssociatedEndpoint,
 149                   (PTDI_REQUEST_KERNEL)&IrpSp->Parameters );
 150
 151             TI_DbgPrint(DEBUG_TCP,("Socket: Status: %x\n"));
 152
 153             if( Status == STATUS_PENDING ) {
 154                 ExInterlockedInsertHeadList( &Connection->ListenRequest, &Bucket->Entry, &Connection->Lock );
 155                 break;
 156             } else {
 157                 Complete( Bucket->Request.RequestContext, Status, 0 );
 158                 exFreePool( Bucket );
 159             }
 160         }
 161     }
 162
 163     /* Things that happen after we're connected */
 164     if( Connection->SignalState & SEL_READ ) {
 165         TI_DbgPrint(DEBUG_TCP,("Readable: irp list %s\n",
 166                                IsListEmpty(&Connection->ReceiveRequest) ?
 167                                "empty" : "nonempty"));
 168
 169         while( (Entry = ExInterlockedRemoveHeadList( &Connection->ReceiveRequest,
 170                                                      &Connection->Lock )) != NULL ) {
 171             OSK_UINT RecvLen = 0, Received = 0;
 172             PVOID RecvBuffer = 0;
 173
 174             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 175             Complete = Bucket->Request.RequestNotifyObject;
 176
 177             Irp = Bucket->Request.RequestContext;
 178             Mdl = Irp->MdlAddress;
 179
 180             TI_DbgPrint(DEBUG_TCP,
 181                         ("Getting the user buffer from %x\n", Mdl));
 182
 183             NdisQueryBuffer( Mdl, &RecvBuffer, &RecvLen );
 184
 185             TI_DbgPrint(DEBUG_TCP,
 186                         ("Reading %d bytes to %x\n", RecvLen, RecvBuffer));
 187
 188             TI_DbgPrint(DEBUG_TCP, ("Connection: %x\n", Connection));
 189             TI_DbgPrint
 190                 (DEBUG_TCP,
 191                  ("Connection->SocketContext: %x\n",
 192                   Connection->SocketContext));
 193             TI_DbgPrint(DEBUG_TCP, ("RecvBuffer: %x\n", RecvBuffer));
 194
 195             Status = TCPTranslateError
 196                 ( OskitTCPRecv( Connection->SocketContext,
 197                                 RecvBuffer,
 198                                 RecvLen,
 199                                 &Received,
 200                                 0 ) );
 201
 202             TI_DbgPrint(DEBUG_TCP,("TCP Bytes: %d\n", Received));
 203
 204             if( Status == STATUS_SUCCESS ) {
 205                 TI_DbgPrint(DEBUG_TCP,("Received %d bytes with status %x\n",
 206                                        Received, Status));
 207
 208                 Complete( Bucket->Request.RequestContext,
 209                           STATUS_SUCCESS, Received );
 210                 exFreePool( Bucket );
 211             } else if( Status == STATUS_PENDING ) {
 212                 ExInterlockedInsertHeadList
 213                     ( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
 214                 break;
 215             } else {
 216                 TI_DbgPrint(DEBUG_TCP,
 217                             ("Completing Receive request: %x %x\n",
 218                              Bucket->Request, Status));
 219                 Complete( Bucket->Request.RequestContext, Status, 0 );
 220                 exFreePool( Bucket );
 221             }
 222         }
 223     }
 224     if( Connection->SignalState & SEL_WRITE ) {
 225         TI_DbgPrint(DEBUG_TCP,("Writeable: irp list %s\n",
 226                                IsListEmpty(&Connection->SendRequest) ?
 227                                "empty" : "nonempty"));
 228
 229         while( (Entry = ExInterlockedRemoveHeadList( &Connection->SendRequest,
 230                                                      &Connection->Lock )) != NULL ) {
 231             OSK_UINT SendLen = 0, Sent = 0;
 232             PVOID SendBuffer = 0;
 233
 234             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 235             Complete = Bucket->Request.RequestNotifyObject;
 236
 237             Irp = Bucket->Request.RequestContext;
 238             Mdl = Irp->MdlAddress;
 239
 240             TI_DbgPrint(DEBUG_TCP,
 241                         ("Getting the user buffer from %x\n", Mdl));
 242
 243             NdisQueryBuffer( Mdl, &SendBuffer, &SendLen );
 244
 245             TI_DbgPrint(DEBUG_TCP,
 246                         ("Writing %d bytes to %x\n", SendLen, SendBuffer));
 247
 248             TI_DbgPrint(DEBUG_TCP, ("Connection: %x\n", Connection));
 249             TI_DbgPrint
 250                 (DEBUG_TCP,
 251                  ("Connection->SocketContext: %x\n",
 252                   Connection->SocketContext));
 253
 254             Status = TCPTranslateError
 255                 ( OskitTCPSend( Connection->SocketContext,
 256                                 SendBuffer,
 257                                 SendLen,
 258                                 &Sent,
 259                                 0 ) );
 260
 261             TI_DbgPrint(DEBUG_TCP,("TCP Bytes: %d\n", Sent));
 262
 263             if( Status == STATUS_SUCCESS ) {
 264                 TI_DbgPrint(DEBUG_TCP,("Sent %d bytes with status %x\n",
 265                                        Sent, Status));
 266
 267                 Complete( Bucket->Request.RequestContext,
 268                           STATUS_SUCCESS, Sent );
 269                 exFreePool( Bucket );
 270             } else if( Status == STATUS_PENDING ) {
 271                 ExInterlockedInsertHeadList
 272                     ( &Connection->SendRequest, &Bucket->Entry, &Connection->Lock );
 273                 break;
 274             } else {
 275                 TI_DbgPrint(DEBUG_TCP,
 276                             ("Completing Send request: %x %x\n",
 277                              Bucket->Request, Status));
 278                 Complete( Bucket->Request.RequestContext, Status, 0 );
 279                 exFreePool( Bucket );
 280             }
 281         }
 282     }
 283
 284     Connection->SignalState = 0;
 285     Connection->Signalled = FALSE;
 286 }
 287
 288 VOID DrainSignals() {
 289     PCONNECTION_ENDPOINT Connection;
 290     PLIST_ENTRY ListEntry;
 291
 292     while( (ListEntry = ExInterlockedRemoveHeadList(&SignalledConnectionsList,
 293                                                     &SignalledConnectionsLock)) != NULL) {
 294         Connection = CONTAINING_RECORD( ListEntry, CONNECTION_ENDPOINT,
 295                                         SignalList );
 296         HandleSignalledConnection( Connection );
 297     }
 298 }
 299
 300 PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint( PVOID ClientContext ) {
 301     PCONNECTION_ENDPOINT Connection =
 302         exAllocatePool(NonPagedPool, sizeof(CONNECTION_ENDPOINT));
 303     if (!Connection)
 304         return Connection;
 305
 306     TI_DbgPrint(DEBUG_CPOINT, ("Connection point file object allocated at (0x%X).\n", Connection));
 307
 308     RtlZeroMemory(Connection, sizeof(CONNECTION_ENDPOINT));
 309
 310     /* Initialize spin lock that protects the connection endpoint file object */
 311     TcpipInitializeSpinLock(&Connection->Lock);
 312     InitializeListHead(&Connection->ConnectRequest);
 313     InitializeListHead(&Connection->ListenRequest);
 314     InitializeListHead(&Connection->ReceiveRequest);
 315     InitializeListHead(&Connection->SendRequest);
 316
 317     /* Save client context pointer */
 318     Connection->ClientContext = ClientContext;
 319
 320     return Connection;
 321 }
 322
 323 VOID TCPFreeConnectionEndpoint( PCONNECTION_ENDPOINT Connection ) {
 324     TI_DbgPrint(DEBUG_TCP, ("Freeing TCP Endpoint\n"));
 325     exFreePool( Connection );
 326 }
 327
 328 NTSTATUS TCPSocket( PCONNECTION_ENDPOINT Connection,
 329                     UINT Family, UINT Type, UINT Proto ) {
 330     NTSTATUS Status;
 331
 332     ASSERT_LOCKED(&TCPLock);
 333
 334     TI_DbgPrint(DEBUG_TCP,("Called: Connection %x, Family %d, Type %d, "
 335                            "Proto %d\n",
 336                            Connection, Family, Type, Proto));
 337
 338     Status = TCPTranslateError( OskitTCPSocket( Connection,
 339                                                 &Connection->SocketContext,
 340                                                 Family,
 341                                                 Type,
 342                                                 Proto ) );
 343
 344     ASSERT_KM_POINTER(Connection->SocketContext);
 345
 346     TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext %x\n",
 347                            Connection->SocketContext));
 348
 349     return Status;
 350 }
 351
 352 VOID TCPReceive(PIP_INTERFACE Interface, PIP_PACKET IPPacket)
 353 /*
 354  * FUNCTION: Receives and queues TCP data
 355  * ARGUMENTS:
 356  *     IPPacket = Pointer to an IP packet that was received
 357  * NOTES:
 358  *     This is the low level interface for receiving TCP data
 359  */
 360 {
 361     TI_DbgPrint(DEBUG_TCP,("Sending packet %d (%d) to oskit\n",
 362                            IPPacket->TotalSize,
 363                            IPPacket->HeaderSize));
 364
 365     TcpipRecursiveMutexEnter( &TCPLock, TRUE );
 366
 367     OskitTCPReceiveDatagram( IPPacket->Header,
 368                              IPPacket->TotalSize,
 369                              IPPacket->HeaderSize );
 370
 371     DrainSignals();
 372
 373     TcpipRecursiveMutexLeave( &TCPLock );
 374 }
 375
 376 /* event.c */
 377 int TCPSocketState( void *ClientData,
 378                     void *WhichSocket,
 379                     void *WhichConnection,
 380                     OSK_UINT NewState );
 381
 382 int TCPPacketSend( void *ClientData,
 383                    OSK_PCHAR Data,
 384                    OSK_UINT Len );
 385
 386 POSK_IFADDR TCPFindInterface( void *ClientData,
 387                               OSK_UINT AddrType,
 388                               OSK_UINT FindType,
 389                               OSK_SOCKADDR *ReqAddr );
 390
 391 NTSTATUS TCPMemStartup( void );
 392 void *TCPMalloc( void *ClientData,
 393                  OSK_UINT bytes, OSK_PCHAR file, OSK_UINT line );
 394 void TCPFree( void *ClientData,
 395               void *data, OSK_PCHAR file, OSK_UINT line );
 396 void TCPMemShutdown( void );
 397
 398 int TCPSleep( void *ClientData, void *token, int priority, char *msg,
 399               int tmio );
 400
 401 void TCPWakeup( void *ClientData, void *token );
 402
 403 OSKITTCP_EVENT_HANDLERS EventHandlers = {
 404     NULL,             /* Client Data */
 405     TCPSocketState,   /* SocketState */
 406     TCPPacketSend,    /* PacketSend */
 407     TCPFindInterface, /* FindInterface */
 408     TCPMalloc,        /* Malloc */
 409     TCPFree,          /* Free */
 410     TCPSleep,         /* Sleep */
 411     TCPWakeup         /* Wakeup */
 412 };
 413
 414 static KEVENT TimerLoopEvent;
 415 static HANDLE TimerThreadHandle;
 416
 417 /*
 418  * We are running 2 timers here, one with a 200ms interval (fast) and the other
 419  * with a 500ms interval (slow). So we need to time out at 200, 400, 500, 600,
 420  * 800, 1000 and process the "fast" events at 200, 400, 600, 800, 1000 and the
 421  * "slow" events at 500 and 1000.
 422  */
 423 static VOID NTAPI
 424 TimerThread(PVOID Context)
 425 {
 426     LARGE_INTEGER Timeout;
 427     NTSTATUS Status;
 428     unsigned Current, NextFast, NextSlow, Next;
 429
 430     Current = 0;
 431     Next = 0;
 432     NextFast = 0;
 433     NextSlow = 0;
 434     while ( 1 ) {
 435         if (Next == NextFast) {
 436             NextFast += 2;
 437         }
 438         if (Next == NextSlow) {
 439             NextSlow += 5;
 440         }
 441         Next = min(NextFast, NextSlow);
 442         Timeout.QuadPart = (LONGLONG) (Next - Current) * -1000000; /* 100 ms */
 443         Status = KeWaitForSingleObject(&TimerLoopEvent, Executive, KernelMode,
 444                                        FALSE, &Timeout);
 445         if (Status != STATUS_TIMEOUT) {
 446             PsTerminateSystemThread(Status);
 447         }
 448
 449         TcpipRecursiveMutexEnter( &TCPLock, TRUE );
 450         TimerOskitTCP( Next == NextFast, Next == NextSlow );
 451         if (Next == NextSlow) {
 452             DrainSignals();
 453         }
 454         TcpipRecursiveMutexLeave( &TCPLock );
 455
 456         Current = Next;
 457         if (10 <= Current) {
 458             Current = 0;
 459             Next = 0;
 460             NextFast = 0;
 461             NextSlow = 0;
 462         }
 463     }
 464 }
 465
 466 static VOID
 467 StartTimer(VOID)
 468 {
 469     KeInitializeEvent(&TimerLoopEvent, NotificationEvent, FALSE);
 470     PsCreateSystemThread(&TimerThreadHandle, THREAD_ALL_ACCESS, 0, 0, 0,
 471                          TimerThread, NULL);
 472 }
 473
 474
 475 NTSTATUS TCPStartup(VOID)
 476 /*
 477  * FUNCTION: Initializes the TCP subsystem
 478  * RETURNS:
 479  *     Status of operation
 480  */
 481 {
 482     NTSTATUS Status;
 483
 484     TcpipRecursiveMutexInit( &TCPLock );
 485     ExInitializeFastMutex( &SleepingThreadsLock );
 486     KeInitializeSpinLock( &SignalledConnectionsLock );
 487     InitializeListHead( &SleepingThreadsList );
 488     InitializeListHead( &SignalledConnectionsList );
 489     Status = TCPMemStartup();
 490     if ( ! NT_SUCCESS(Status) ) {
 491         return Status;
 492     }
 493
 494     Status = PortsStartup( &TCPPorts, 1, 0xfffe );
 495     if( !NT_SUCCESS(Status) ) {
 496         TCPMemShutdown();
 497         return Status;
 498     }
 499
 500     TcpipRecursiveMutexEnter(&TCPLock, TRUE);
 501     RegisterOskitTCPEventHandlers( &EventHandlers );
 502     InitOskitTCP();
 503     TcpipRecursiveMutexLeave(&TCPLock);
 504
 505     /* Register this protocol with IP layer */
 506     IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
 507
 508     ExInitializeNPagedLookasideList(
 509         &TCPSegmentList,                /* Lookaside list */
 510         NULL,                           /* Allocate routine */
 511         NULL,                           /* Free routine */
 512         0,                              /* Flags */
 513         sizeof(TCP_SEGMENT),            /* Size of each entry */
 514         'SPCT',                         /* Tag */
 515         0);                             /* Depth */
 516
 517     StartTimer();
 518
 519     TCPInitialized = TRUE;
 520
 521     return STATUS_SUCCESS;
 522 }
 523
 524
 525 NTSTATUS TCPShutdown(VOID)
 526 /*
 527  * FUNCTION: Shuts down the TCP subsystem
 528  * RETURNS:
 529  *     Status of operation
 530  */
 531 {
 532     LARGE_INTEGER WaitForThread;
 533
 534     if (!TCPInitialized)
 535         return STATUS_SUCCESS;
 536
 537     WaitForThread.QuadPart = -2500000; /* 250 ms */
 538     KeSetEvent(&TimerLoopEvent, IO_NO_INCREMENT, FALSE);
 539     ZwWaitForSingleObject(TimerThreadHandle, FALSE, &WaitForThread);
 540
 541     /* Deregister this protocol with IP layer */
 542     IPRegisterProtocol(IPPROTO_TCP, NULL);
 543
 544     ExDeleteNPagedLookasideList(&TCPSegmentList);
 545
 546     TCPInitialized = FALSE;
 547
 548     DeinitOskitTCP();
 549
 550     PortsShutdown( &TCPPorts );
 551
 552     TCPMemShutdown();
 553
 554     return STATUS_SUCCESS;
 555 }
 556
 557 NTSTATUS TCPTranslateError( int OskitError ) {
 558     NTSTATUS Status = STATUS_UNSUCCESSFUL;
 559
 560     switch( OskitError ) {
 561     case 0: Status = STATUS_SUCCESS; break;
 562     case OSK_EADDRNOTAVAIL:
 563     case OSK_EAFNOSUPPORT: Status = STATUS_INVALID_CONNECTION; break;
 564     case OSK_ECONNREFUSED:
 565     case OSK_ECONNRESET: Status = STATUS_REMOTE_NOT_LISTENING; break;
 566     case OSK_EINPROGRESS:
 567     case OSK_EAGAIN: Status = STATUS_PENDING; break;
 568     default: Status = STATUS_INVALID_CONNECTION; break;
 569     }
 570
 571     TI_DbgPrint(DEBUG_TCP,("Error %d -> %x\n", OskitError, Status));
 572     return Status;
 573 }
 574
 575 NTSTATUS TCPConnect
 576 ( PCONNECTION_ENDPOINT Connection,
 577   PTDI_CONNECTION_INFORMATION ConnInfo,
 578   PTDI_CONNECTION_INFORMATION ReturnInfo,
 579   PTCP_COMPLETION_ROUTINE Complete,
 580   PVOID Context ) {
 581     NTSTATUS Status;
 582     SOCKADDR_IN AddressToConnect = { 0 }, AddressToBind = { 0 };
 583     IP_ADDRESS RemoteAddress;
 584     USHORT RemotePort;
 585     PTDI_BUCKET Bucket;
 586     PNEIGHBOR_CACHE_ENTRY NCE;
 587
 588     TI_DbgPrint(DEBUG_TCP,("TCPConnect: Called\n"));
 589
 590     ASSERT_LOCKED(&TCPLock);
 591
 592     Status = AddrBuildAddress
 593         ((PTRANSPORT_ADDRESS)ConnInfo->RemoteAddress,
 594          &RemoteAddress,
 595          &RemotePort);
 596
 597     if (!NT_SUCCESS(Status)) {
 598         TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
 599         return Status;
 600     }
 601
 602     if (!(NCE = RouteGetRouteToDestination(&RemoteAddress)))
 603     {
 604         return STATUS_NETWORK_UNREACHABLE;
 605     }
 606
 607     if (Connection->State & SEL_FIN)
 608     {
 609         return STATUS_REMOTE_DISCONNECT;
 610     }
 611
 612     /* Freed in TCPSocketState */
 613     TI_DbgPrint(DEBUG_TCP,
 614                 ("Connecting to address %x:%x\n",
 615                  RemoteAddress.Address.IPv4Address,
 616                  RemotePort));
 617
 618     AddressToConnect.sin_family = AF_INET;
 619     AddressToBind = AddressToConnect;
 620     AddressToBind.sin_addr.s_addr = NCE->Interface->Unicast.Address.IPv4Address;
 621
 622     Status = TCPTranslateError
 623         ( OskitTCPBind( Connection->SocketContext,
 624                         Connection,
 625                         &AddressToBind,
 626                         sizeof(AddressToBind) ) );
 627
 628     if (NT_SUCCESS(Status)) {
 629         memcpy( &AddressToConnect.sin_addr,
 630                 &RemoteAddress.Address.IPv4Address,
 631                 sizeof(AddressToConnect.sin_addr) );
 632         AddressToConnect.sin_port = RemotePort;
 633
 634         Status = TCPTranslateError
 635             ( OskitTCPConnect( Connection->SocketContext,
 636                                Connection,
 637                                &AddressToConnect,
 638                                sizeof(AddressToConnect) ) );
 639
 640         if (Status == STATUS_PENDING)
 641         {
 642             Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 643             if( !Bucket ) return STATUS_NO_MEMORY;
 644
 645             Bucket->Request.RequestNotifyObject = (PVOID)Complete;
 646             Bucket->Request.RequestContext = Context;
 647
 648             IoMarkIrpPending((PIRP)Context);
 649
 650             ExInterlockedInsertTailList( &Connection->ConnectRequest, &Bucket->Entry, &Connection->Lock );
 651         }
 652     }
 653
 654     return Status;
 655 }
 656
 657 NTSTATUS TCPDisconnect
 658 ( PCONNECTION_ENDPOINT Connection,
 659   UINT Flags,
 660   PTDI_CONNECTION_INFORMATION ConnInfo,
 661   PTDI_CONNECTION_INFORMATION ReturnInfo,
 662   PTCP_COMPLETION_ROUTINE Complete,
 663   PVOID Context ) {
 664     NTSTATUS Status;
 665
 666     ASSERT_LOCKED(&TCPLock);
 667
 668     TI_DbgPrint(DEBUG_TCP,("started\n"));
 669
 670     switch( Flags & (TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE) ) {
 671     case 0:
 672     case TDI_DISCONNECT_ABORT:
 673         Flags = 0;
 674         break;
 675
 676     case TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE:
 677         Flags = 2;
 678         break;
 679
 680     case TDI_DISCONNECT_RELEASE:
 681         Flags = 1;
 682         break;
 683     }
 684
 685     Status = TCPTranslateError
 686         ( OskitTCPShutdown( Connection->SocketContext, Flags ) );
 687
 688     TI_DbgPrint(DEBUG_TCP,("finished %x\n", Status));
 689
 690     return Status;
 691 }
 692
 693 NTSTATUS TCPClose
 694 ( PCONNECTION_ENDPOINT Connection ) {
 695     NTSTATUS Status;
 696
 697     TI_DbgPrint(DEBUG_TCP,("TCPClose started\n"));
 698
 699     ASSERT_LOCKED(&TCPLock);
 700
 701     /* Make our code remove all pending IRPs */
 702     Connection->State |= SEL_FIN;
 703     DrainSignals();
 704
 705     Status = TCPTranslateError( OskitTCPClose( Connection->SocketContext ) );
 706
 707     TI_DbgPrint(DEBUG_TCP,("TCPClose finished %x\n", Status));
 708
 709     return Status;
 710 }
 711
 712 NTSTATUS TCPReceiveData
 713 ( PCONNECTION_ENDPOINT Connection,
 714   PNDIS_BUFFER Buffer,
 715   ULONG ReceiveLength,
 716   PULONG BytesReceived,
 717   ULONG ReceiveFlags,
 718   PTCP_COMPLETION_ROUTINE Complete,
 719   PVOID Context ) {
 720     PVOID DataBuffer;
 721     UINT DataLen, Received = 0;
 722     NTSTATUS Status;
 723     PTDI_BUCKET Bucket;
 724
 725     TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
 726                            ReceiveLength, Connection->SocketContext));
 727
 728     ASSERT_LOCKED(&TCPLock);
 729
 730     ASSERT_KM_POINTER(Connection->SocketContext);
 731
 732     /* Closing */
 733     if (Connection->State & SEL_FIN)
 734     {
 735         *BytesReceived = 0;
 736         return STATUS_REMOTE_DISCONNECT;
 737     }
 738
 739     NdisQueryBuffer( Buffer, &DataBuffer, &DataLen );
 740
 741     TI_DbgPrint(DEBUG_TCP,("TCP>|< Got an MDL %x (%x:%d)\n", Buffer, DataBuffer, DataLen));
 742
 743     Status = TCPTranslateError
 744         ( OskitTCPRecv
 745           ( Connection->SocketContext,
 746             DataBuffer,
 747             DataLen,
 748             &Received,
 749             ReceiveFlags ) );
 750
 751     TI_DbgPrint(DEBUG_TCP,("OskitTCPReceive: %x, %d\n", Status, Received));
 752
 753     /* Keep this request around ... there was no data yet */
 754     if( Status == STATUS_PENDING ) {
 755         /* Freed in TCPSocketState */
 756         Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 757         if( !Bucket ) {
 758             TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 759             return STATUS_NO_MEMORY;
 760         }
 761
 762         Bucket->Request.RequestNotifyObject = Complete;
 763         Bucket->Request.RequestContext = Context;
 764         *BytesReceived = 0;
 765
 766         IoMarkIrpPending((PIRP)Context);
 767
 768         ExInterlockedInsertTailList( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
 769         TI_DbgPrint(DEBUG_TCP,("Queued read irp\n"));
 770     } else {
 771         TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Received));
 772         *BytesReceived = Received;
 773     }
 774
 775     TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
 776
 777     return Status;
 778 }
 779
 780 NTSTATUS TCPSendData
 781 ( PCONNECTION_ENDPOINT Connection,
 782   PCHAR BufferData,
 783   ULONG SendLength,
 784   PULONG BytesSent,
 785   ULONG Flags,
 786   PTCP_COMPLETION_ROUTINE Complete,
 787   PVOID Context ) {
 788     UINT Sent = 0;
 789     NTSTATUS Status;
 790     PTDI_BUCKET Bucket;
 791
 792     ASSERT_LOCKED(&TCPLock);
 793
 794     TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
 795                            SendLength, Connection->SocketContext));
 796
 797     ASSERT_KM_POINTER(Connection->SocketContext);
 798
 799     TI_DbgPrint(DEBUG_TCP,("Connection = %x\n", Connection));
 800     TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext = %x\n",
 801                            Connection->SocketContext));
 802
 803     /* Closing */
 804     if (Connection->State & SEL_FIN)
 805     {
 806         *BytesSent = 0;
 807         return STATUS_REMOTE_DISCONNECT;
 808     }
 809
 810     Status = TCPTranslateError
 811         ( OskitTCPSend( Connection->SocketContext,
 812                         (OSK_PCHAR)BufferData, SendLength,
 813                         &Sent, 0 ) );
 814
 815     TI_DbgPrint(DEBUG_TCP,("OskitTCPSend: %x, %d\n", Status, Sent));
 816
 817     /* Keep this request around ... there was no data yet */
 818     if( Status == STATUS_PENDING ) {
 819         /* Freed in TCPSocketState */
 820         Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 821         if( !Bucket ) {
 822             TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 823             return STATUS_NO_MEMORY;
 824         }
 825
 826         Bucket->Request.RequestNotifyObject = Complete;
 827         Bucket->Request.RequestContext = Context;
 828         *BytesSent = 0;
 829
 830         IoMarkIrpPending((PIRP)Context);
 831
 832         ExInterlockedInsertTailList( &Connection->SendRequest, &Bucket->Entry, &Connection->Lock );
 833         TI_DbgPrint(DEBUG_TCP,("Queued write irp\n"));
 834     } else {
 835         TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Sent));
 836         *BytesSent = Sent;
 837     }
 838
 839     TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
 840
 841     return Status;
 842 }
 843
 844 VOID TCPTimeout(VOID) {
 845     /* Now handled by TimerThread */
 846 }
 847
 848 UINT TCPAllocatePort( UINT HintPort ) {
 849     if( HintPort ) {
 850         if( AllocatePort( &TCPPorts, HintPort ) ) return HintPort;
 851         else {
 852             TI_DbgPrint
 853                 (MID_TRACE,("We got a hint port but couldn't allocate it\n"));
 854             return (UINT)-1;
 855         }
 856     } else return AllocatePortFromRange( &TCPPorts, 1024, 5000 );
 857 }
 858
 859 VOID TCPFreePort( UINT Port ) {
 860     DeallocatePort( &TCPPorts, Port );
 861 }
 862
 863 NTSTATUS TCPGetSockAddress
 864 ( PCONNECTION_ENDPOINT Connection,
 865   PTRANSPORT_ADDRESS Address,
 866   BOOLEAN GetRemote ) {
 867     OSK_UINT LocalAddress, RemoteAddress;
 868     OSK_UI16 LocalPort, RemotePort;
 869     PTA_IP_ADDRESS AddressIP = (PTA_IP_ADDRESS)Address;
 870
 871     ASSERT_LOCKED(&TCPLock);
 872
 873     OskitTCPGetAddress
 874         ( Connection->SocketContext,
 875           &LocalAddress, &LocalPort,
 876           &RemoteAddress, &RemotePort );
 877
 878     AddressIP->TAAddressCount = 1;
 879     AddressIP->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
 880     AddressIP->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
 881     AddressIP->Address[0].Address[0].sin_port = GetRemote ? RemotePort : LocalPort;
 882     AddressIP->Address[0].Address[0].in_addr = GetRemote ? RemoteAddress : LocalAddress;
 883
 884     return STATUS_SUCCESS;
 885 }
 886
 887 VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
 888     PLIST_ENTRY Entry;
 889     PLIST_ENTRY ListHead[4];
 890     KIRQL OldIrql;
 891     PTDI_BUCKET Bucket;
 892     UINT i = 0;
 893
 894     ListHead[0] = &Endpoint->SendRequest;
 895     ListHead[1] = &Endpoint->ReceiveRequest;
 896     ListHead[2] = &Endpoint->ConnectRequest;
 897     ListHead[3] = &Endpoint->ListenRequest;
 898
 899     TcpipAcquireSpinLock( &Endpoint->Lock, &OldIrql );
 900
 901     for( i = 0; i < 4; i++ )
 902     {
 903         for( Entry = ListHead[i]->Flink;
 904              Entry != ListHead[i];
 905              Entry = Entry->Flink )
 906         {
 907             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 908             if( Bucket->Request.RequestContext == Irp )
 909             {
 910                 RemoveEntryList( &Bucket->Entry );
 911                 exFreePool( Bucket );
 912                 break;
 913             }
 914         }
 915     }
 916
 917     TcpipReleaseSpinLock( &Endpoint->Lock, OldIrql );
 918 }
 919
 920 /* EOF */