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