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;
 559
 560     switch( OskitError ) {
 561     case 0: Status = STATUS_SUCCESS; break;
 562     case OSK_EADDRNOTAVAIL: Status = STATUS_INVALID_ADDRESS; break;
 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_EWOULDBLOCK:
 567     case OSK_EINPROGRESS: Status = STATUS_PENDING; break;
 568     case OSK_EINVAL: Status = STATUS_INVALID_PARAMETER; break;
 569     case OSK_ENOMEM:
 570     case OSK_ENOBUFS: Status = STATUS_INSUFFICIENT_RESOURCES; break;
 571     case OSK_ESHUTDOWN: Status = STATUS_FILE_CLOSED; break;
 572     case OSK_EMSGSIZE: Status = STATUS_BUFFER_TOO_SMALL; break;
 573     case OSK_ETIMEDOUT: Status = STATUS_TIMEOUT; break;
 574     case OSK_ENETUNREACH: Status = STATUS_NETWORK_UNREACHABLE; break;
 575     case OSK_EFAULT: Status = STATUS_ACCESS_VIOLATION; break;
 576     default:
 577        DbgPrint("OskitTCP returned unhandled error code: %d\n", OskitError);
 578        Status = STATUS_INVALID_CONNECTION;
 579        break;
 580     }
 581
 582     TI_DbgPrint(DEBUG_TCP,("Error %d -> %x\n", OskitError, Status));
 583     return Status;
 584 }
 585
 586 NTSTATUS TCPConnect
 587 ( PCONNECTION_ENDPOINT Connection,
 588   PTDI_CONNECTION_INFORMATION ConnInfo,
 589   PTDI_CONNECTION_INFORMATION ReturnInfo,
 590   PTCP_COMPLETION_ROUTINE Complete,
 591   PVOID Context ) {
 592     NTSTATUS Status;
 593     SOCKADDR_IN AddressToConnect = { 0 }, AddressToBind = { 0 };
 594     IP_ADDRESS RemoteAddress;
 595     USHORT RemotePort;
 596     PTDI_BUCKET Bucket;
 597     PNEIGHBOR_CACHE_ENTRY NCE;
 598
 599     TI_DbgPrint(DEBUG_TCP,("TCPConnect: Called\n"));
 600
 601     ASSERT_LOCKED(&TCPLock);
 602
 603     Status = AddrBuildAddress
 604         ((PTRANSPORT_ADDRESS)ConnInfo->RemoteAddress,
 605          &RemoteAddress,
 606          &RemotePort);
 607
 608     if (!NT_SUCCESS(Status)) {
 609         TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
 610         return Status;
 611     }
 612
 613     if (!(NCE = RouteGetRouteToDestination(&RemoteAddress)))
 614     {
 615         return STATUS_NETWORK_UNREACHABLE;
 616     }
 617
 618     if (Connection->State & SEL_FIN)
 619     {
 620         return STATUS_REMOTE_DISCONNECT;
 621     }
 622
 623     /* Freed in TCPSocketState */
 624     TI_DbgPrint(DEBUG_TCP,
 625                 ("Connecting to address %x:%x\n",
 626                  RemoteAddress.Address.IPv4Address,
 627                  RemotePort));
 628
 629     AddressToConnect.sin_family = AF_INET;
 630     AddressToBind = AddressToConnect;
 631     AddressToBind.sin_addr.s_addr = NCE->Interface->Unicast.Address.IPv4Address;
 632
 633     Status = TCPTranslateError
 634         ( OskitTCPBind( Connection->SocketContext,
 635                         &AddressToBind,
 636                         sizeof(AddressToBind) ) );
 637
 638     if (NT_SUCCESS(Status)) {
 639         memcpy( &AddressToConnect.sin_addr,
 640                 &RemoteAddress.Address.IPv4Address,
 641                 sizeof(AddressToConnect.sin_addr) );
 642         AddressToConnect.sin_port = RemotePort;
 643
 644         Status = TCPTranslateError
 645             ( OskitTCPConnect( Connection->SocketContext,
 646                                Connection,
 647                                &AddressToConnect,
 648                                sizeof(AddressToConnect) ) );
 649
 650         if (Status == STATUS_PENDING)
 651         {
 652             Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 653             if( !Bucket ) return STATUS_NO_MEMORY;
 654
 655             Bucket->Request.RequestNotifyObject = (PVOID)Complete;
 656             Bucket->Request.RequestContext = Context;
 657
 658             IoMarkIrpPending((PIRP)Context);
 659
 660             ExInterlockedInsertTailList( &Connection->ConnectRequest, &Bucket->Entry, &Connection->Lock );
 661         }
 662     }
 663
 664     return Status;
 665 }
 666
 667 NTSTATUS TCPDisconnect
 668 ( PCONNECTION_ENDPOINT Connection,
 669   UINT Flags,
 670   PTDI_CONNECTION_INFORMATION ConnInfo,
 671   PTDI_CONNECTION_INFORMATION ReturnInfo,
 672   PTCP_COMPLETION_ROUTINE Complete,
 673   PVOID Context ) {
 674     NTSTATUS Status;
 675
 676     ASSERT_LOCKED(&TCPLock);
 677
 678     TI_DbgPrint(DEBUG_TCP,("started\n"));
 679
 680     switch( Flags & (TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE) ) {
 681     case 0:
 682     case TDI_DISCONNECT_ABORT:
 683         Flags = 0;
 684         break;
 685
 686     case TDI_DISCONNECT_ABORT | TDI_DISCONNECT_RELEASE:
 687         Flags = 2;
 688         break;
 689
 690     case TDI_DISCONNECT_RELEASE:
 691         Flags = 1;
 692         break;
 693     }
 694
 695     Status = TCPTranslateError
 696         ( OskitTCPShutdown( Connection->SocketContext, Flags ) );
 697
 698     TI_DbgPrint(DEBUG_TCP,("finished %x\n", Status));
 699
 700     return Status;
 701 }
 702
 703 NTSTATUS TCPClose
 704 ( PCONNECTION_ENDPOINT Connection ) {
 705     NTSTATUS Status;
 706
 707     TI_DbgPrint(DEBUG_TCP,("TCPClose started\n"));
 708
 709     ASSERT_LOCKED(&TCPLock);
 710
 711     /* Make our code remove all pending IRPs */
 712     Connection->State |= SEL_FIN;
 713     DrainSignals();
 714
 715     Status = TCPTranslateError( OskitTCPClose( Connection->SocketContext ) );
 716     if (Status == STATUS_SUCCESS)
 717         Connection->SocketContext = NULL;
 718
 719     TI_DbgPrint(DEBUG_TCP,("TCPClose finished %x\n", Status));
 720
 721     return Status;
 722 }
 723
 724 NTSTATUS TCPReceiveData
 725 ( PCONNECTION_ENDPOINT Connection,
 726   PNDIS_BUFFER Buffer,
 727   ULONG ReceiveLength,
 728   PULONG BytesReceived,
 729   ULONG ReceiveFlags,
 730   PTCP_COMPLETION_ROUTINE Complete,
 731   PVOID Context ) {
 732     PVOID DataBuffer;
 733     UINT DataLen, Received = 0;
 734     NTSTATUS Status;
 735     PTDI_BUCKET Bucket;
 736
 737     TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
 738                            ReceiveLength, Connection->SocketContext));
 739
 740     ASSERT_LOCKED(&TCPLock);
 741
 742     ASSERT_KM_POINTER(Connection->SocketContext);
 743
 744     /* Closing */
 745     if (Connection->State & SEL_FIN)
 746     {
 747         *BytesReceived = 0;
 748         return STATUS_REMOTE_DISCONNECT;
 749     }
 750
 751     NdisQueryBuffer( Buffer, &DataBuffer, &DataLen );
 752
 753     TI_DbgPrint(DEBUG_TCP,("TCP>|< Got an MDL %x (%x:%d)\n", Buffer, DataBuffer, DataLen));
 754
 755     Status = TCPTranslateError
 756         ( OskitTCPRecv
 757           ( Connection->SocketContext,
 758             DataBuffer,
 759             DataLen,
 760             &Received,
 761             ReceiveFlags ) );
 762
 763     TI_DbgPrint(DEBUG_TCP,("OskitTCPReceive: %x, %d\n", Status, Received));
 764
 765     /* Keep this request around ... there was no data yet */
 766     if( Status == STATUS_PENDING ) {
 767         /* Freed in TCPSocketState */
 768         Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 769         if( !Bucket ) {
 770             TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 771             return STATUS_NO_MEMORY;
 772         }
 773
 774         Bucket->Request.RequestNotifyObject = Complete;
 775         Bucket->Request.RequestContext = Context;
 776         *BytesReceived = 0;
 777
 778         IoMarkIrpPending((PIRP)Context);
 779
 780         ExInterlockedInsertTailList( &Connection->ReceiveRequest, &Bucket->Entry, &Connection->Lock );
 781         TI_DbgPrint(DEBUG_TCP,("Queued read irp\n"));
 782     } else {
 783         TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Received));
 784         *BytesReceived = Received;
 785     }
 786
 787     TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
 788
 789     return Status;
 790 }
 791
 792 NTSTATUS TCPSendData
 793 ( PCONNECTION_ENDPOINT Connection,
 794   PCHAR BufferData,
 795   ULONG SendLength,
 796   PULONG BytesSent,
 797   ULONG Flags,
 798   PTCP_COMPLETION_ROUTINE Complete,
 799   PVOID Context ) {
 800     UINT Sent = 0;
 801     NTSTATUS Status;
 802     PTDI_BUCKET Bucket;
 803
 804     ASSERT_LOCKED(&TCPLock);
 805
 806     TI_DbgPrint(DEBUG_TCP,("Called for %d bytes (on socket %x)\n",
 807                            SendLength, Connection->SocketContext));
 808
 809     ASSERT_KM_POINTER(Connection->SocketContext);
 810
 811     TI_DbgPrint(DEBUG_TCP,("Connection = %x\n", Connection));
 812     TI_DbgPrint(DEBUG_TCP,("Connection->SocketContext = %x\n",
 813                            Connection->SocketContext));
 814
 815     /* Closing */
 816     if (Connection->State & SEL_FIN)
 817     {
 818         *BytesSent = 0;
 819         return STATUS_REMOTE_DISCONNECT;
 820     }
 821
 822     Status = TCPTranslateError
 823         ( OskitTCPSend( Connection->SocketContext,
 824                         (OSK_PCHAR)BufferData, SendLength,
 825                         &Sent, 0 ) );
 826
 827     TI_DbgPrint(DEBUG_TCP,("OskitTCPSend: %x, %d\n", Status, Sent));
 828
 829     /* Keep this request around ... there was no data yet */
 830     if( Status == STATUS_PENDING ) {
 831         /* Freed in TCPSocketState */
 832         Bucket = exAllocatePool( NonPagedPool, sizeof(*Bucket) );
 833         if( !Bucket ) {
 834             TI_DbgPrint(DEBUG_TCP,("Failed to allocate bucket\n"));
 835             return STATUS_NO_MEMORY;
 836         }
 837
 838         Bucket->Request.RequestNotifyObject = Complete;
 839         Bucket->Request.RequestContext = Context;
 840         *BytesSent = 0;
 841
 842         IoMarkIrpPending((PIRP)Context);
 843
 844         ExInterlockedInsertTailList( &Connection->SendRequest, &Bucket->Entry, &Connection->Lock );
 845         TI_DbgPrint(DEBUG_TCP,("Queued write irp\n"));
 846     } else {
 847         TI_DbgPrint(DEBUG_TCP,("Got status %x, bytes %d\n", Status, Sent));
 848         *BytesSent = Sent;
 849     }
 850
 851     TI_DbgPrint(DEBUG_TCP,("Status %x\n", Status));
 852
 853     return Status;
 854 }
 855
 856 VOID TCPTimeout(VOID) {
 857     /* Now handled by TimerThread */
 858 }
 859
 860 UINT TCPAllocatePort( UINT HintPort ) {
 861     if( HintPort ) {
 862         if( AllocatePort( &TCPPorts, HintPort ) ) return HintPort;
 863         else {
 864             TI_DbgPrint
 865                 (MID_TRACE,("We got a hint port but couldn't allocate it\n"));
 866             return (UINT)-1;
 867         }
 868     } else return AllocatePortFromRange( &TCPPorts, 1024, 5000 );
 869 }
 870
 871 VOID TCPFreePort( UINT Port ) {
 872     DeallocatePort( &TCPPorts, Port );
 873 }
 874
 875 NTSTATUS TCPGetSockAddress
 876 ( PCONNECTION_ENDPOINT Connection,
 877   PTRANSPORT_ADDRESS Address,
 878   BOOLEAN GetRemote ) {
 879     OSK_UINT LocalAddress, RemoteAddress;
 880     OSK_UI16 LocalPort, RemotePort;
 881     PTA_IP_ADDRESS AddressIP = (PTA_IP_ADDRESS)Address;
 882     NTSTATUS Status;
 883
 884     ASSERT_LOCKED(&TCPLock);
 885
 886     Status = TCPTranslateError(OskitTCPGetAddress(Connection->SocketContext,
 887                                                   &LocalAddress, &LocalPort,
 888                                                   &RemoteAddress, &RemotePort));
 889     if (!NT_SUCCESS(Status))
 890         return Status;
 891
 892     AddressIP->TAAddressCount = 1;
 893     AddressIP->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
 894     AddressIP->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
 895     AddressIP->Address[0].Address[0].sin_port = GetRemote ? RemotePort : LocalPort;
 896     AddressIP->Address[0].Address[0].in_addr = GetRemote ? RemoteAddress : LocalAddress;
 897
 898     return Status;
 899 }
 900
 901 VOID TCPRemoveIRP( PCONNECTION_ENDPOINT Endpoint, PIRP Irp ) {
 902     PLIST_ENTRY Entry;
 903     PLIST_ENTRY ListHead[4];
 904     KIRQL OldIrql;
 905     PTDI_BUCKET Bucket;
 906     UINT i = 0;
 907
 908     ListHead[0] = &Endpoint->SendRequest;
 909     ListHead[1] = &Endpoint->ReceiveRequest;
 910     ListHead[2] = &Endpoint->ConnectRequest;
 911     ListHead[3] = &Endpoint->ListenRequest;
 912
 913     TcpipAcquireSpinLock( &Endpoint->Lock, &OldIrql );
 914
 915     for( i = 0; i < 4; i++ )
 916     {
 917         for( Entry = ListHead[i]->Flink;
 918              Entry != ListHead[i];
 919              Entry = Entry->Flink )
 920         {
 921             Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 922             if( Bucket->Request.RequestContext == Irp )
 923             {
 924                 RemoveEntryList( &Bucket->Entry );
 925                 exFreePool( Bucket );
 926                 break;
 927             }
 928         }
 929     }
 930
 931     TcpipReleaseSpinLock( &Endpoint->Lock, OldIrql );
 932 }
 933
 934 /* EOF */