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