tcp.h File Reference

#include <pshpack1.h>
#include <poppack.h>

Include dependency graph for tcp.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	TCPv4_HEADER
struct	TCPv4_PSEUDO_HEADER
struct	_SLEEPING_THREAD
struct	_CLIENT_DATA

Macros
#define	TCPOPT_END_OF_LIST   0x0
#define	TCPOPT_NO_OPERATION   0x1
#define	TCPOPT_MAX_SEG_SIZE   0x2
#define	TCPOPTLEN_MAX_SEG_SIZE   0x4
#define	TCP_DATA_OFFSET(DataOffset)   (((DataOffset) & 0xF0) >> (4-2))
#define	TCP_MIN_RETRANSMISSION_TIMEOUT   1*1000 /* 1 tick */
#define	TCP_MAX_RETRANSMISSION_TIMEOUT   1*60*1000 /* 1 tick */
#define	TCP_ALPHA_RETRANSMISSION_TIMEOUT(x)   (((x)*8)/10) /* 0.8 */
#define	TCP_BETA_RETRANSMISSION_TIMEOUT(x)   (((x)*16)/10) /* 1.6 */
#define	SEL_CONNECT   1
#define	SEL_FIN   2
#define	SEL_RST   4
#define	SEL_ABRT   8
#define	SEL_READ   16
#define	SEL_WRITE   32
#define	SEL_ACCEPT   64
#define	SEL_OOB   128
#define	SEL_ERROR   256
#define	SEL_FINOUT   512
#define	FREAD   0x0001
#define	FWRITE   0x0002
#define	SRF_URG   TCP_URG
#define	SRF_ACK   TCP_ACK
#define	SRF_PSH   TCP_PSH
#define	SRF_RST   TCP_RST
#define	SRF_SYN   TCP_SYN
#define	SRF_FIN   TCP_FIN

Typedefs
typedef VOID(*	PTCP_COMPLETION_ROUTINE) (PVOID Context, NTSTATUS Status, ULONG Count)
typedef struct TCPv4_HEADER	TCPv4_HEADER
typedef struct TCPv4_HEADER *	PTCPv4_HEADER
typedef struct TCPv4_PSEUDO_HEADER	TCPv4_PSEUDO_HEADER
typedef struct TCPv4_PSEUDO_HEADER *	PTCPv4_PSEUDO_HEADER
typedef struct _SLEEPING_THREAD	SLEEPING_THREAD
typedef struct _SLEEPING_THREAD *	PSLEEPING_THREAD
typedef struct _CLIENT_DATA	CLIENT_DATA
typedef struct _CLIENT_DATA *	PCLIENT_DATA

Functions
NTSTATUS	TCPCheckPeerForAccept (PVOID Context, PTDI_REQUEST_KERNEL Request)
NTSTATUS	TCPListen (PCONNECTION_ENDPOINT Connection, UINT Backlog)
BOOLEAN	TCPAbortListenForSocket (PCONNECTION_ENDPOINT Listener, PCONNECTION_ENDPOINT Connection)
NTSTATUS	TCPAccept (PTDI_REQUEST Request, PCONNECTION_ENDPOINT Listener, PCONNECTION_ENDPOINT Connection, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
PCONNECTION_ENDPOINT	TCPAllocateConnectionEndpoint (PVOID ClientContext)
VOID	TCPFreeConnectionEndpoint (PCONNECTION_ENDPOINT Connection)
NTSTATUS	TCPSocket (PCONNECTION_ENDPOINT Connection, UINT Family, UINT Type, UINT Proto)
VOID	HandleSignalledConnection (PCONNECTION_ENDPOINT Connection)
PTCP_SEGMENT	TCPCreateSegment (PIP_PACKET IPPacket, PTCPv4_HEADER TCPHeader, ULONG SegmentLength)
VOID	TCPFreeSegment (PTCP_SEGMENT Segment)
VOID	TCPAddSegment (PCONNECTION_ENDPOINT Connection, PTCP_SEGMENT Segment, PULONG Acknowledged)
NTSTATUS	TCPConnect (PCONNECTION_ENDPOINT Connection, PTDI_CONNECTION_INFORMATION ConnInfo, PTDI_CONNECTION_INFORMATION ReturnInfo, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
NTSTATUS	TCPDisconnect (PCONNECTION_ENDPOINT Connection, UINT Flags, PLARGE_INTEGER Timeout, PTDI_CONNECTION_INFORMATION ConnInfo, PTDI_CONNECTION_INFORMATION ReturnInfo, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
NTSTATUS	TCPReceiveData (PCONNECTION_ENDPOINT Connection, PNDIS_BUFFER Buffer, ULONG ReceiveLength, PULONG BytesReceived, ULONG ReceiveFlags, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
NTSTATUS	TCPSendData (PCONNECTION_ENDPOINT Connection, PCHAR Buffer, ULONG DataSize, PULONG DataUsed, ULONG Flags, PTCP_COMPLETION_ROUTINE Complete, PVOID Context)
NTSTATUS	TCPClose (PCONNECTION_ENDPOINT Connection)
NTSTATUS	TCPTranslateError (const INT8 err)
UINT	TCPAllocatePort (const UINT HintPort)
VOID	TCPFreePort (const UINT Port)
NTSTATUS	TCPGetSockAddress (PCONNECTION_ENDPOINT Connection, PTRANSPORT_ADDRESS TransportAddress, BOOLEAN RemoteAddress)
NTSTATUS	TCPStartup (VOID)
NTSTATUS	TCPShutdown (VOID)
BOOLEAN	TCPRemoveIRP (PCONNECTION_ENDPOINT Connection, PIRP Irp)
NTSTATUS	TCPSetNoDelay (PCONNECTION_ENDPOINT Connection, BOOLEAN Set)
VOID	TCPUpdateInterfaceLinkStatus (PIP_INTERFACE IF)
VOID	TCPUpdateInterfaceIPInformation (PIP_INTERFACE IF)
VOID	FlushListenQueue (PCONNECTION_ENDPOINT Connection, const NTSTATUS Status)
VOID	FlushConnectQueue (PCONNECTION_ENDPOINT Connection, const NTSTATUS Status)
VOID	FlushReceiveQueue (PCONNECTION_ENDPOINT Connection, const NTSTATUS Status)
VOID	FlushSendQueue (PCONNECTION_ENDPOINT Connection, const NTSTATUS Status)
VOID	FlushShutdownQueue (PCONNECTION_ENDPOINT Connection, const NTSTATUS Status)
VOID	FlushAllQueues (PCONNECTION_ENDPOINT Connection, NTSTATUS Status)
VOID	CompleteBucket (PCONNECTION_ENDPOINT Connection, PTDI_BUCKET Bucket, const BOOLEAN Synchronous)
void	LibTCPDumpPcb (PVOID SocketContext)
NTSTATUS	TCPGetSocketStatus (PCONNECTION_ENDPOINT Connection, PULONG State)

Variables
LONG	TCP_IPIdentification
CLIENT_DATA	ClientInfo

Macro Definition Documentation

FREAD

#define FREAD   0x0001

Definition at line 84 of file tcp.h.

FWRITE

#define FWRITE   0x0002

Definition at line 85 of file tcp.h.

SEL_ABRT

#define SEL_ABRT   8

Definition at line 76 of file tcp.h.

SEL_ACCEPT

#define SEL_ACCEPT   64

Definition at line 79 of file tcp.h.

SEL_CONNECT

#define SEL_CONNECT   1

Definition at line 73 of file tcp.h.

SEL_ERROR

#define SEL_ERROR   256

Definition at line 81 of file tcp.h.

SEL_FIN

#define SEL_FIN   2

Definition at line 74 of file tcp.h.

SEL_FINOUT

#define SEL_FINOUT   512

Definition at line 82 of file tcp.h.

SEL_OOB

#define SEL_OOB   128

Definition at line 80 of file tcp.h.

SEL_READ

#define SEL_READ   16

Definition at line 77 of file tcp.h.

SEL_RST

#define SEL_RST   4

Definition at line 75 of file tcp.h.

SEL_WRITE

#define SEL_WRITE   32

Definition at line 78 of file tcp.h.

SRF_ACK

#define SRF_ACK   TCP_ACK

Definition at line 90 of file tcp.h.

SRF_FIN

#define SRF_FIN   TCP_FIN

Definition at line 94 of file tcp.h.

SRF_PSH

#define SRF_PSH   TCP_PSH

Definition at line 91 of file tcp.h.

SRF_RST

#define SRF_RST   TCP_RST

Definition at line 92 of file tcp.h.

SRF_SYN

#define SRF_SYN   TCP_SYN

Definition at line 93 of file tcp.h.

SRF_URG

#define SRF_URG   TCP_URG

Definition at line 89 of file tcp.h.

TCP_ALPHA_RETRANSMISSION_TIMEOUT

#define TCP_ALPHA_RETRANSMISSION_TIMEOUT

(

x

)

(((x)*8)/10) /* 0.8 */

Definition at line 68 of file tcp.h.

TCP_BETA_RETRANSMISSION_TIMEOUT

#define TCP_BETA_RETRANSMISSION_TIMEOUT

(

x

)

(((x)*16)/10) /* 1.6 */

Definition at line 71 of file tcp.h.

TCP_DATA_OFFSET

#define TCP_DATA_OFFSET

(

DataOffset

)

(((DataOffset) & 0xF0) >> (4-2))

Definition at line 34 of file tcp.h.

TCP_MAX_RETRANSMISSION_TIMEOUT

#define TCP_MAX_RETRANSMISSION_TIMEOUT   1*60*1000 /* 1 tick */

Definition at line 65 of file tcp.h.

TCP_MIN_RETRANSMISSION_TIMEOUT

#define TCP_MIN_RETRANSMISSION_TIMEOUT   1*1000 /* 1 tick */

Definition at line 62 of file tcp.h.

TCPOPT_END_OF_LIST

#define TCPOPT_END_OF_LIST   0x0

Definition at line 27 of file tcp.h.

TCPOPT_MAX_SEG_SIZE

#define TCPOPT_MAX_SEG_SIZE   0x2

Definition at line 29 of file tcp.h.

TCPOPT_NO_OPERATION

#define TCPOPT_NO_OPERATION   0x1

Definition at line 28 of file tcp.h.

TCPOPTLEN_MAX_SEG_SIZE

#define TCPOPTLEN_MAX_SEG_SIZE   0x4

Definition at line 31 of file tcp.h.

Typedef Documentation

CLIENT_DATA

typedef struct _CLIENT_DATA CLIENT_DATA

PCLIENT_DATA

typedef struct _CLIENT_DATA * PCLIENT_DATA

PSLEEPING_THREAD

typedef struct _SLEEPING_THREAD * PSLEEPING_THREAD

PTCP_COMPLETION_ROUTINE

typedef VOID(* PTCP_COMPLETION_ROUTINE) (PVOID Context, NTSTATUS Status, ULONG Count)

Definition at line 10 of file tcp.h.

PTCPv4_HEADER

typedef struct TCPv4_HEADER * PTCPv4_HEADER

PTCPv4_PSEUDO_HEADER

typedef struct TCPv4_PSEUDO_HEADER * PTCPv4_PSEUDO_HEADER

SLEEPING_THREAD

typedef struct _SLEEPING_THREAD SLEEPING_THREAD

TCPv4_HEADER

typedef struct TCPv4_HEADER TCPv4_HEADER

TCPv4_PSEUDO_HEADER

typedef struct TCPv4_PSEUDO_HEADER TCPv4_PSEUDO_HEADER

Function Documentation

CompleteBucket()

VOID CompleteBucket	(	PCONNECTION_ENDPOINT	Connection,
		PTDI_BUCKET	Bucket,
		const BOOLEAN	Synchronous
	)

Definition at line 38 of file event.c.

{
    ReferenceObject(Connection);
    Bucket->AssociatedEndpoint = Connection;
    if (Synchronous)
    {
        BucketCompletionWorker(Bucket);
    }
    else
    {
        ChewCreate(BucketCompletionWorker, Bucket);
    }
}

Referenced by DisconnectWorker(), FlushConnectQueue(), FlushListenQueue(), FlushReceiveQueue(), FlushSendQueue(), FlushShutdownQueue(), TCPAcceptEventHandler(), TCPConnectEventHandler(), TCPRecvEventHandler(), and TCPSendEventHandler().

FlushAllQueues()

VOID FlushAllQueues	(	PCONNECTION_ENDPOINT	Connection,
		NTSTATUS	Status
	)

Definition at line 157 of file event.c.

{
    // flush receive queue
    FlushReceiveQueue(Connection, Status);
 
    /* We completed the reads successfully but we need to return failure now */
    if (Status == STATUS_SUCCESS)
    {
        Status = STATUS_FILE_CLOSED;
    }
 
    // flush listen queue
    FlushListenQueue(Connection, Status);
 
    // flush send queue
    FlushSendQueue(Connection, Status);
 
    // flush connect queue
    FlushConnectQueue(Connection, Status);
 
    // flush shutdown queue
    FlushShutdownQueue(Connection, Status);
}

Referenced by TCPClose(), and TCPFinEventHandler().

FlushConnectQueue()

VOID FlushConnectQueue	(	PCONNECTION_ENDPOINT	Connection,
		const NTSTATUS	Status
	)

Definition at line 116 of file event.c.

{
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    ASSERT_TCPIP_OBJECT_LOCKED(Connection);
 
    while (!IsListEmpty(&Connection->ConnectRequest))
    {
        Entry = RemoveHeadList(&Connection->ConnectRequest);
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Bucket->Status = Status;
        Bucket->Information = 0;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
}

Referenced by FlushAllQueues().

FlushListenQueue()

VOID FlushListenQueue	(	PCONNECTION_ENDPOINT	Connection,
		const NTSTATUS	Status
	)

Definition at line 136 of file event.c.

{
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    ASSERT_TCPIP_OBJECT_LOCKED(Connection);
 
    while (!IsListEmpty(&Connection->ListenRequest))
    {
        Entry = RemoveHeadList(&Connection->ListenRequest);
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Bucket->Status = Status;
        Bucket->Information = 0;
 
        DereferenceObject(Bucket->AssociatedEndpoint);
        CompleteBucket(Connection, Bucket, FALSE);
    }
}

Referenced by FlushAllQueues().

FlushReceiveQueue()

VOID FlushReceiveQueue	(	PCONNECTION_ENDPOINT	Connection,
		const NTSTATUS	Status
	)

Definition at line 53 of file event.c.

{
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    ASSERT_TCPIP_OBJECT_LOCKED(Connection);
 
    while (!IsListEmpty(&Connection->ReceiveRequest))
    {
        Entry = RemoveHeadList(&Connection->ReceiveRequest);
 
        Bucket = CONTAINING_RECORD(Entry, TDI_BUCKET, Entry);
 
        Bucket->Information = 0;
        Bucket->Status = Status;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
}

Referenced by FlushAllQueues(), and TCPDisconnect().

FlushSendQueue()

VOID FlushSendQueue	(	PCONNECTION_ENDPOINT	Connection,
		const NTSTATUS	Status
	)

Definition at line 74 of file event.c.

{
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    ASSERT_TCPIP_OBJECT_LOCKED(Connection);
 
    while (!IsListEmpty(&Connection->SendRequest))
    {
        Entry = RemoveHeadList(&Connection->SendRequest);
 
        Bucket = CONTAINING_RECORD(Entry, TDI_BUCKET, Entry);
 
        Bucket->Information = 0;
        Bucket->Status = Status;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
}

Referenced by FlushAllQueues(), and TCPDisconnect().

FlushShutdownQueue()

VOID FlushShutdownQueue	(	PCONNECTION_ENDPOINT	Connection,
		const NTSTATUS	Status
	)

Definition at line 95 of file event.c.

{
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    ASSERT_TCPIP_OBJECT_LOCKED(Connection);
 
    while (!IsListEmpty(&Connection->ShutdownRequest))
    {
        Entry = RemoveHeadList(&Connection->ShutdownRequest);
 
        Bucket = CONTAINING_RECORD(Entry, TDI_BUCKET, Entry);
 
        Bucket->Information = 0;
        Bucket->Status = Status;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
}

Referenced by FlushAllQueues(), TCPDisconnect(), and TCPSendEventHandler().

HandleSignalledConnection()

VOID HandleSignalledConnection

(

PCONNECTION_ENDPOINT

Connection

)

LibTCPDumpPcb()

void LibTCPDumpPcb

(

PVOID

SocketContext

)

Definition at line 36 of file tcp.c.

{
    struct tcp_pcb *pcb = (struct tcp_pcb*)SocketContext;
    unsigned int addr = ntohl(pcb->remote_ip.addr);
 
    DbgPrint("\tState: %s\n", tcp_state_str[pcb->state]);
    DbgPrint("\tRemote: (%d.%d.%d.%d, %d)\n",
    (addr >> 24) & 0xFF,
    (addr >> 16) & 0xFF,
    (addr >> 8) & 0xFF,
    addr & 0xFF,
    pcb->remote_port);
}

Referenced by LogActiveObjects().

TCPAbortListenForSocket()

BOOLEAN TCPAbortListenForSocket	(	PCONNECTION_ENDPOINT	Listener,
		PCONNECTION_ENDPOINT	Connection
	)

Definition at line 107 of file accept.c.

{
    PLIST_ENTRY ListEntry;
    PTDI_BUCKET Bucket;
    BOOLEAN Found = FALSE;
 
    LockObject(Listener);
 
    ListEntry = Listener->ListenRequest.Flink;
    while (ListEntry != &Listener->ListenRequest)
    {
        Bucket = CONTAINING_RECORD(ListEntry, TDI_BUCKET, Entry);
 
        if (Bucket->AssociatedEndpoint == Connection)
        {
            DereferenceObject(Bucket->AssociatedEndpoint);
            RemoveEntryList( &Bucket->Entry );
            ExFreeToNPagedLookasideList(&TdiBucketLookasideList, Bucket);
            Found = TRUE;
            break;
        }
 
        ListEntry = ListEntry->Flink;
    }
 
    UnlockObject(Listener);
 
    return Found;
}

Referenced by DispCancelListenRequest().

TCPAccept()

NTSTATUS TCPAccept	(	PTDI_REQUEST	Request,
		PCONNECTION_ENDPOINT	Listener,
		PCONNECTION_ENDPOINT	Connection,
		PTCP_COMPLETION_ROUTINE	Complete,
		PVOID	Context
	)

Definition at line 139 of file accept.c.

{
    NTSTATUS Status;
    PTDI_BUCKET Bucket;
 
    LockObject(Listener);
 
    Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
 
    if (Bucket)
    {
        Bucket->AssociatedEndpoint = Connection;
        ReferenceObject(Bucket->AssociatedEndpoint);
 
        Bucket->Request.RequestNotifyObject = Complete;
        Bucket->Request.RequestContext = Context;
        InsertTailList( &Listener->ListenRequest, &Bucket->Entry );
        Status = STATUS_PENDING;
    }
    else
        Status = STATUS_NO_MEMORY;
 
    UnlockObject(Listener);
 
    return Status;
}

Referenced by DispTdiListen().

TCPAddSegment()

VOID TCPAddSegment	(	PCONNECTION_ENDPOINT	Connection,
		PTCP_SEGMENT	Segment,
		PULONG	Acknowledged
	)

TCPAllocateConnectionEndpoint()

PCONNECTION_ENDPOINT TCPAllocateConnectionEndpoint

(

PVOID

ClientContext

)

Definition at line 107 of file tcp.c.

{
    PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)
        ExAllocatePoolWithTag(NonPagedPool, sizeof(CONNECTION_ENDPOINT), CONN_ENDPT_TAG);
 
    if (!Connection)
        return Connection;
 
    TI_DbgPrint(DEBUG_CPOINT, ("Connection point file object allocated at (0x%X).\n", Connection));
 
    RtlZeroMemory(Connection, sizeof(CONNECTION_ENDPOINT));
 
    /* Initialize spin lock that protects the connection endpoint file object */
    ExInitializeResourceLite(&Connection->Resource);
    InitializeListHead(&Connection->ConnectRequest);
    InitializeListHead(&Connection->ListenRequest);
    InitializeListHead(&Connection->ReceiveRequest);
    InitializeListHead(&Connection->SendRequest);
    InitializeListHead(&Connection->ShutdownRequest);
    InitializeListHead(&Connection->PacketQueue);
 
    /* Initialize disconnect timer */
    KeInitializeTimer(&Connection->DisconnectTimer);
    KeInitializeDpc(&Connection->DisconnectDpc, DisconnectTimeoutDpc, Connection);
    Connection->DisconnectWorkItem = IoAllocateWorkItem(TCPDeviceObject);
    if (!Connection->DisconnectWorkItem)
    {
        ExDeleteResourceLite(&Connection->Resource);
        ExFreePoolWithTag( Connection, CONN_ENDPT_TAG );
        return NULL;
    }
 
    /* Save client context pointer */
    Connection->ClientContext = ClientContext;
 
    Connection->RefCount = 1;
    Connection->Free = ConnectionFree;
 
    /* Add connection endpoint to global list */
    ExInterlockedInsertTailList(&ConnectionEndpointListHead,
                                &Connection->ListEntry,
                                &ConnectionEndpointListLock);
 
    return Connection;
}

Referenced by DispTdiListen(), FileOpenConnection(), and TCPSocketObject::TCPSocketObject().

TCPAllocatePort()

UINT TCPAllocatePort

(

const UINT

HintPort

)

Definition at line 636 of file tcp.c.

{
    if (HintPort)
    {
        if (AllocatePort(&TCPPorts, HintPort))
            return HintPort;
        else
        {
            TI_DbgPrint(MID_TRACE,("We got a hint port but couldn't allocate it\n"));
            return (UINT)-1;
        }
    }
    else
        return AllocatePortFromRange( &TCPPorts, 1024, 5000 );
}

Referenced by FileOpenAddress(), TCPConnect(), and TCPListen().

TCPCheckPeerForAccept()

NTSTATUS TCPCheckPeerForAccept	(	PVOID	Context,
		PTDI_REQUEST_KERNEL	Request
	)

Definition at line 17 of file accept.c.

{
    struct tcp_pcb *newpcb = (struct tcp_pcb*)Context;
    NTSTATUS Status;
    PTDI_CONNECTION_INFORMATION WhoIsConnecting;
    PTA_IP_ADDRESS RemoteAddress;
    struct ip_addr ipaddr;
 
    if (Request->RequestFlags & TDI_QUERY_ACCEPT)
        DbgPrint("TDI_QUERY_ACCEPT NOT SUPPORTED!!!\n");
 
    WhoIsConnecting = (PTDI_CONNECTION_INFORMATION)Request->ReturnConnectionInformation;
    RemoteAddress = (PTA_IP_ADDRESS)WhoIsConnecting->RemoteAddress;
 
    RemoteAddress->TAAddressCount = 1;
    RemoteAddress->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
    RemoteAddress->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
 
    Status = TCPTranslateError(LibTCPGetPeerName(newpcb,
                                                 &ipaddr,
                                                 &RemoteAddress->Address[0].Address[0].sin_port));
 
    RemoteAddress->Address[0].Address[0].in_addr = ipaddr.addr;
 
    return Status;
}

Referenced by TCPAcceptEventHandler().

TCPClose()

NTSTATUS TCPClose

(

PCONNECTION_ENDPOINT

Connection

)

Definition at line 177 of file tcp.c.

{
    LockObject(Connection);
 
    FlushAllQueues(Connection, STATUS_CANCELLED);
 
    UnlockObject(Connection);
 
    LibTCPClose(Connection, FALSE, TRUE);
 
    DereferenceObject(Connection);
 
    return STATUS_SUCCESS;
}

Referenced by FileCloseAddress(), FileCloseConnection(), main(), and TCPSocketObject::~TCPSocketObject().

TCPConnect()

NTSTATUS TCPConnect	(	PCONNECTION_ENDPOINT	Connection,
		PTDI_CONNECTION_INFORMATION	ConnInfo,
		PTDI_CONNECTION_INFORMATION	ReturnInfo,
		PTCP_COMPLETION_ROUTINE	Complete,
		PVOID	Context
	)

Definition at line 301 of file tcp.c.

{
    NTSTATUS Status;
    struct ip_addr bindaddr, connaddr;
    IP_ADDRESS RemoteAddress;
    USHORT RemotePort;
    TA_IP_ADDRESS LocalAddress;
    PTDI_BUCKET Bucket;
    PNEIGHBOR_CACHE_ENTRY NCE;
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPConnect] Called\n"));
 
    Status = AddrBuildAddress
        ((PTRANSPORT_ADDRESS)ConnInfo->RemoteAddress,
         &RemoteAddress,
         &RemotePort);
 
    if (!NT_SUCCESS(Status))
    {
        TI_DbgPrint(DEBUG_TCP, ("Could not AddrBuildAddress in TCPConnect\n"));
        return Status;
    }
 
    /* Freed in TCPSocketState */
    TI_DbgPrint(DEBUG_TCP,
                ("Connecting to address %x:%x\n",
                 RemoteAddress.Address.IPv4Address,
                 RemotePort));
 
    LockObject(Connection);
 
    if (!Connection->AddressFile)
    {
        UnlockObject(Connection);
        return STATUS_INVALID_PARAMETER;
    }
 
    if (AddrIsUnspecified(&Connection->AddressFile->Address))
    {
        if (!(NCE = RouteGetRouteToDestination(&RemoteAddress)))
        {
            UnlockObject(Connection);
            return STATUS_NETWORK_UNREACHABLE;
        }
 
        bindaddr.addr = NCE->Interface->Unicast.Address.IPv4Address;
    }
    else
    {
        bindaddr.addr = Connection->AddressFile->Address.Address.IPv4Address;
    }
 
    Status = TCPTranslateError(LibTCPBind(Connection,
                                          &bindaddr,
                                          Connection->AddressFile->Port));
 
    if (!NT_SUCCESS(Status))
    {
        UnlockObject(Connection);
        return Status;
    }
 
    /* Copy bind address into connection */
    Connection->AddressFile->Address.Address.IPv4Address = bindaddr.addr;
    /* Check if we had an unspecified port */
    if (!Connection->AddressFile->Port)
    {
        UINT AllocatedPort;
 
        /* We did, so we need to copy back the port */
        Status = TCPGetSockAddress(Connection, (PTRANSPORT_ADDRESS)&LocalAddress, FALSE);
        if (!NT_SUCCESS(Status))
        {
            UnlockObject(Connection);
            return Status;
        }
 
        /* Allocate the port in the port bitmap */
        AllocatedPort = TCPAllocatePort(LocalAddress.Address[0].Address[0].sin_port);
        /* This should never fail unless all ports are in use */
        if (AllocatedPort == (UINT) -1)
        {
            DbgPrint("ERR: No more ports available.\n");
            UnlockObject(Connection);
            return STATUS_TOO_MANY_ADDRESSES;
        }
        Connection->AddressFile->Port = AllocatedPort;
    }
 
    connaddr.addr = RemoteAddress.Address.IPv4Address;
 
    Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
    if (!Bucket)
    {
        UnlockObject(Connection);
        return STATUS_NO_MEMORY;
    }
 
    Bucket->Request.RequestNotifyObject = (PVOID)Complete;
    Bucket->Request.RequestContext = Context;
 
    InsertTailList( &Connection->ConnectRequest, &Bucket->Entry );
 
    UnlockObject(Connection);
 
    Status = TCPTranslateError(LibTCPConnect(Connection,
                                                &connaddr,
                                                RemotePort));
    if (!NT_SUCCESS(Status))
    {
        LockObject(Connection);
        RemoveEntryList(&Bucket->Entry);
        UnlockObject(Connection);
        ExFreeToNPagedLookasideList(&TdiBucketLookasideList, Bucket);
    }
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPConnect] Leaving. Status = 0x%x\n", Status));
 
    return Status;
}

Referenced by DispTdiConnect(), and TCPSocketObject::TCPSocketObject().

TCPCreateSegment()

PTCP_SEGMENT TCPCreateSegment	(	PIP_PACKET	IPPacket,
		PTCPv4_HEADER	TCPHeader,
		ULONG	SegmentLength
	)

TCPDisconnect()

NTSTATUS TCPDisconnect	(	PCONNECTION_ENDPOINT	Connection,
		UINT	Flags,
		PLARGE_INTEGER	Timeout,
		PTDI_CONNECTION_INFORMATION	ConnInfo,
		PTDI_CONNECTION_INFORMATION	ReturnInfo,
		PTCP_COMPLETION_ROUTINE	Complete,
		PVOID	Context
	)

Definition at line 426 of file tcp.c.

{
    NTSTATUS Status = STATUS_INVALID_PARAMETER;
    PTDI_BUCKET Bucket;
    LARGE_INTEGER ActualTimeout;
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPDisconnect] Called\n"));
 
    LockObject(Connection);
 
    if (Connection->SocketContext)
    {
        if (Flags & TDI_DISCONNECT_RELEASE)
        {
            if (IsListEmpty(&Connection->SendRequest))
            {
                ReferenceObject(Connection);
                UnlockObject(Connection);
                Status = TCPTranslateError(LibTCPShutdown(Connection, 0, 1));
                LockObject(Connection);
                DereferenceObject(Connection);
            }
            else if (Timeout && Timeout->QuadPart == 0)
            {
                FlushSendQueue(Connection, STATUS_FILE_CLOSED);
                ReferenceObject(Connection);
                UnlockObject(Connection);
                LibTCPShutdown(Connection, 0, 1);
                LockObject(Connection);
                DereferenceObject(Connection);
                Status = STATUS_TIMEOUT;
            }
            else
            {
                /* Use the timeout specified or 1 second if none was specified */
                if (Timeout)
                {
                    ActualTimeout = *Timeout;
                }
                else
                {
                    ActualTimeout.QuadPart = -1000000;
                }
 
                /* We couldn't complete the request now because we need to wait for outstanding I/O */
                Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
                if (!Bucket)
                {
                    UnlockObject(Connection);
                    return STATUS_NO_MEMORY;
                }
 
                Bucket->Request.RequestNotifyObject = (PVOID)Complete;
                Bucket->Request.RequestContext = Context;
 
                InsertTailList(&Connection->ShutdownRequest, &Bucket->Entry);
 
                ReferenceObject(Connection);
                if (KeSetTimer(&Connection->DisconnectTimer, ActualTimeout, &Connection->DisconnectDpc))
                {
                    /* Timer was already in the queue. */
                    DereferenceObject(Connection);
                }
 
                Status = STATUS_PENDING;
            }
        }
 
        if ((Flags & TDI_DISCONNECT_ABORT) || !Flags)
        {
            FlushReceiveQueue(Connection, STATUS_FILE_CLOSED);
            FlushSendQueue(Connection, STATUS_FILE_CLOSED);
            FlushShutdownQueue(Connection, STATUS_FILE_CLOSED);
            ReferenceObject(Connection);
            UnlockObject(Connection);
            Status = TCPTranslateError(LibTCPShutdown(Connection, 1, 1));
            DereferenceObject(Connection);
        }
        else
        {
            UnlockObject(Connection);
        }
    }
    else
    {
        UnlockObject(Connection);
        /* We already got closed by the other side so just return success */
        Status = STATUS_SUCCESS;
    }
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPDisconnect] Leaving. Status = 0x%x\n", Status));
 
    return Status;
}

Referenced by DispTdiDisconnect().

TCPFreeConnectionEndpoint()

VOID TCPFreeConnectionEndpoint

(

PCONNECTION_ENDPOINT

Connection

)

Referenced by main(), and TCPSocketObject::~TCPSocketObject().

TCPFreePort()

VOID TCPFreePort

(

const UINT

Port

)

Definition at line 652 of file tcp.c.

{
    DeallocatePort(&TCPPorts, Port);
}

Referenced by AddrFileFree().

TCPFreeSegment()

VOID TCPFreeSegment

(

PTCP_SEGMENT

Segment

)

TCPGetSockAddress()

NTSTATUS TCPGetSockAddress	(	PCONNECTION_ENDPOINT	Connection,
		PTRANSPORT_ADDRESS	TransportAddress,
		BOOLEAN	RemoteAddress
	)

Definition at line 657 of file tcp.c.

{
    PTA_IP_ADDRESS AddressIP = (PTA_IP_ADDRESS)Address;
    struct ip_addr ipaddr;
    NTSTATUS Status;
 
    AddressIP->TAAddressCount = 1;
    AddressIP->Address[0].AddressLength = TDI_ADDRESS_LENGTH_IP;
    AddressIP->Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
 
    LockObject(Connection);
 
    if (GetRemote)
    {
        Status = TCPTranslateError(LibTCPGetPeerName(Connection->SocketContext,
                                    &ipaddr,
                                    &AddressIP->Address[0].Address[0].sin_port));
    }
    else
    {
        Status = TCPTranslateError(LibTCPGetHostName(Connection->SocketContext,
                                    &ipaddr,
                                    &AddressIP->Address[0].Address[0].sin_port));
    }
 
    UnlockObject(Connection);
 
    AddressIP->Address[0].Address[0].in_addr = ipaddr.addr;
 
    RtlZeroMemory(&AddressIP->Address[0].Address[0].sin_zero,
                  sizeof(AddressIP->Address[0].Address[0].sin_zero));
 
    return Status;
}

Referenced by InfoTdiQueryGetConnectionTcpTable(), TCPConnect(), and TCPListen().

TCPGetSocketStatus()

NTSTATUS TCPGetSocketStatus	(	PCONNECTION_ENDPOINT	Connection,
		PULONG	State
	)

Definition at line 749 of file tcp.c.

{
    if (!Connection)
        return STATUS_UNSUCCESSFUL;
 
    if (Connection->SocketContext == NULL)
        return STATUS_UNSUCCESSFUL;
 
    LibTCPGetSocketStatus(Connection->SocketContext, State);
    return STATUS_SUCCESS;
}

Referenced by InfoTdiQueryGetConnectionTcpTable().

TCPListen()

NTSTATUS TCPListen	(	PCONNECTION_ENDPOINT	Connection,
		UINT	Backlog
	)

Definition at line 47 of file accept.c.

{
    NTSTATUS Status = STATUS_SUCCESS;
    struct ip_addr AddressToBind;
    TA_IP_ADDRESS LocalAddress;
 
    ASSERT(Connection);
 
    LockObject(Connection);
 
    ASSERT_KM_POINTER(Connection->AddressFile);
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPListen] Called\n"));
 
    TI_DbgPrint(DEBUG_TCP, ("Connection->SocketContext %x\n",
        Connection->SocketContext));
 
    AddressToBind.addr = Connection->AddressFile->Address.Address.IPv4Address;
 
    Status = TCPTranslateError(LibTCPBind(Connection,
                                          &AddressToBind,
                                          Connection->AddressFile->Port));
 
    if (NT_SUCCESS(Status))
    {
        /* Check if we had an unspecified port */
        if (!Connection->AddressFile->Port)
        {
            /* We did, so we need to copy back the port */
            Status = TCPGetSockAddress(Connection, (PTRANSPORT_ADDRESS)&LocalAddress, FALSE);
            if (NT_SUCCESS(Status))
            {
                /* Allocate the port in the port bitmap */
                UINT AllocatedPort = TCPAllocatePort(LocalAddress.Address[0].Address[0].sin_port);
                /* This should never fail unless all ports are in use */
                if (AllocatedPort == (UINT) -1)
                {
                    DbgPrint("ERR: No more ports available.\n");
                    UnlockObject(Connection);
                    return STATUS_TOO_MANY_ADDRESSES;
                }
                Connection->AddressFile->Port = AllocatedPort;
            }
        }
    }
 
    if (NT_SUCCESS(Status))
    {
        Connection->SocketContext = LibTCPListen(Connection, Backlog);
        if (!Connection->SocketContext)
            Status = STATUS_UNSUCCESSFUL;
    }
 
    UnlockObject(Connection);
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPListen] Leaving. Status = %x\n", Status));
 
    return Status;
}

Referenced by DispTdiListen().

TCPReceiveData()

NTSTATUS TCPReceiveData	(	PCONNECTION_ENDPOINT	Connection,
		PNDIS_BUFFER	Buffer,
		ULONG	ReceiveLength,
		PULONG	BytesReceived,
		ULONG	ReceiveFlags,
		PTCP_COMPLETION_ROUTINE	Complete,
		PVOID	Context
	)

Definition at line 528 of file tcp.c.

{
    PTDI_BUCKET Bucket;
    PUCHAR DataBuffer;
    UINT DataLen, Received;
    NTSTATUS Status;
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Called for %d bytes (on socket %x)\n",
                           ReceiveLength, Connection->SocketContext));
 
    NdisQueryBuffer(Buffer, &DataBuffer, &DataLen);
 
    Status = LibTCPGetDataFromConnectionQueue(Connection, DataBuffer, DataLen, &Received);
 
    if (Status == STATUS_PENDING)
    {
        Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
        if (!Bucket)
        {
            TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Failed to allocate bucket\n"));
 
            return STATUS_NO_MEMORY;
        }
 
        Bucket->Request.RequestNotifyObject = Complete;
        Bucket->Request.RequestContext = Context;
 
        LockObject(Connection);
        InsertTailList( &Connection->ReceiveRequest, &Bucket->Entry );
        UnlockObject(Connection);
        TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Queued read irp\n"));
 
        TI_DbgPrint(DEBUG_TCP,("[IP, TCPReceiveData] Leaving. Status = STATUS_PENDING\n"));
 
        (*BytesReceived) = 0;
    }
    else
    {
        (*BytesReceived) = Received;
    }
 
    return Status;
}

Referenced by DispTdiReceive().

TCPRemoveIRP()

BOOLEAN TCPRemoveIRP	(	PCONNECTION_ENDPOINT	Connection,
		PIRP	Irp
	)

Definition at line 695 of file tcp.c.

{
    PLIST_ENTRY Entry;
    PLIST_ENTRY ListHead[5];
    PTDI_BUCKET Bucket;
    UINT i = 0;
    BOOLEAN Found = FALSE;
 
    ListHead[0] = &Endpoint->SendRequest;
    ListHead[1] = &Endpoint->ReceiveRequest;
    ListHead[2] = &Endpoint->ConnectRequest;
    ListHead[3] = &Endpoint->ListenRequest;
    ListHead[4] = &Endpoint->ShutdownRequest;
 
    LockObject(Endpoint);
 
    for( i = 0; i < 5; i++ )
    {
        for( Entry = ListHead[i]->Flink;
             Entry != ListHead[i];
             Entry = Entry->Flink )
        {
            Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
            if( Bucket->Request.RequestContext == Irp )
            {
                RemoveEntryList( &Bucket->Entry );
                ExFreeToNPagedLookasideList(&TdiBucketLookasideList, Bucket);
                Found = TRUE;
                break;
            }
        }
    }
 
    UnlockObject(Endpoint);
 
    return Found;
}

Referenced by DispCancelRequest().

TCPSendData()

NTSTATUS TCPSendData	(	PCONNECTION_ENDPOINT	Connection,
		PCHAR	Buffer,
		ULONG	DataSize,
		PULONG	DataUsed,
		ULONG	Flags,
		PTCP_COMPLETION_ROUTINE	Complete,
		PVOID	Context
	)

Definition at line 579 of file tcp.c.

{
    NTSTATUS Status;
    PTDI_BUCKET Bucket;
 
    ReferenceObject(Connection);
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Called for %d bytes (on socket %x)\n",
                           SendLength, Connection->SocketContext));
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection = %x\n", Connection));
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Connection->SocketContext = %x\n",
                           Connection->SocketContext));
 
    Status = TCPTranslateError(LibTCPSend(Connection,
                                          BufferData,
                                          SendLength,
                                          BytesSent,
                                          FALSE));
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Send: %x, %d\n", Status, SendLength));
 
    /* Keep this request around ... there was no data yet */
    if (Status == STATUS_PENDING)
    {
        /* Freed in TCPSocketState */
        Bucket = ExAllocateFromNPagedLookasideList(&TdiBucketLookasideList);
        if (!Bucket)
        {
            DereferenceObject(Connection);
            TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Failed to allocate bucket\n"));
            return STATUS_NO_MEMORY;
        }
 
        Bucket->Request.RequestNotifyObject = Complete;
        Bucket->Request.RequestContext = Context;
 
        LockObject(Connection);
        InsertTailList( &Connection->SendRequest, &Bucket->Entry );
        TI_DbgPrint(DEBUG_TCP,("[IP, TCPSendData] Queued write irp\n"));
        UnlockObject(Connection);
    }
 
 
    TI_DbgPrint(DEBUG_TCP, ("[IP, TCPSendData] Leaving. Status = %x\n", Status));
    DereferenceObject(Connection);
 
    return Status;
}

Referenced by DispTdiSend(), TCPSocketObject::recv(), and TCPSocketObject::send().

TCPSetNoDelay()

NTSTATUS TCPSetNoDelay	(	PCONNECTION_ENDPOINT	Connection,
		BOOLEAN	Set
	)

Definition at line 734 of file tcp.c.

{
    if (!Connection)
        return STATUS_UNSUCCESSFUL;
 
    if (Connection->SocketContext == NULL)
        return STATUS_UNSUCCESSFUL;
 
    LibTCPSetNoDelay(Connection->SocketContext, Set);
    return STATUS_SUCCESS;
}

Referenced by SetConnectionInfo().

TCPShutdown()

NTSTATUS TCPShutdown

(

VOID

)

Definition at line 243 of file tcp.c.

{
    if (!TCPInitialized)
        return STATUS_SUCCESS;
 
    ExDeleteNPagedLookasideList(&TdiBucketLookasideList);
 
    LibIPShutdown();
 
    /* Deregister this protocol with IP layer */
    IPRegisterProtocol(IPPROTO_TCP, NULL);
 
    TCPInitialized = FALSE;
 
    PortsShutdown( &TCPPorts );
 
    return STATUS_SUCCESS;
}

Referenced by TiUnload().

TCPSocket()

NTSTATUS TCPSocket	(	PCONNECTION_ENDPOINT	Connection,
		UINT	Family,
		UINT	Type,
		UINT	Proto
	)

Definition at line 153 of file tcp.c.

{
    NTSTATUS Status;
 
    LockObject(Connection);
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSocket] Called: Connection %x, Family %d, Type %d, "
                           "Proto %d, sizeof(CONNECTION_ENDPOINT) = %d\n",
                           Connection, Family, Type, Proto, sizeof(CONNECTION_ENDPOINT)));
 
    Connection->SocketContext = LibTCPSocket(Connection);
    if (Connection->SocketContext)
        Status = STATUS_SUCCESS;
    else
        Status = STATUS_INSUFFICIENT_RESOURCES;
 
    UnlockObject(Connection);
 
    TI_DbgPrint(DEBUG_TCP,("[IP, TCPSocket] Leaving. Status = 0x%x\n", Status));
 
    return Status;
}

Referenced by DispTdiListen(), FileOpenConnection(), and TCPSocketObject::TCPSocketObject().

TCPStartup()

NTSTATUS TCPStartup

(

VOID

)

Definition at line 208 of file tcp.c.

{
    NTSTATUS Status;
 
    Status = PortsStartup(&TCPPorts, 1, 0xffff);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }
 
    ExInitializeNPagedLookasideList(&TdiBucketLookasideList,
                                    NULL,
                                    NULL,
                                    0,
                                    sizeof(TDI_BUCKET),
                                    TDI_BUCKET_TAG,
                                    0);
 
    /* Initialize our IP library */
    LibIPInitialize();
 
    /* Register this protocol with IP layer */
    IPRegisterProtocol(IPPROTO_TCP, TCPReceive);
 
    TCPInitialized = TRUE;
 
    return STATUS_SUCCESS;
}

Referenced by DriverEntry().

TCPTranslateError()

NTSTATUS TCPTranslateError

(

const INT8

err

)

Definition at line 267 of file tcp.c.

{
    NTSTATUS Status;
 
    switch (err)
    {
        case ERR_OK: Status = STATUS_SUCCESS; return Status; //0
        case ERR_MEM: Status = STATUS_INSUFFICIENT_RESOURCES; break; //-1
        case ERR_BUF: Status = STATUS_BUFFER_TOO_SMALL; break; //-2
        case ERR_TIMEOUT: Status = STATUS_TIMEOUT; break; // -3
        case ERR_RTE: Status = STATUS_NETWORK_UNREACHABLE; break; //-4
        case ERR_INPROGRESS: Status = STATUS_PENDING; return Status; //-5
        case ERR_VAL: Status = STATUS_INVALID_PARAMETER; break; //-6
        case ERR_WOULDBLOCK: Status = STATUS_CANT_WAIT; break; //-7
        case ERR_USE: Status = STATUS_ADDRESS_ALREADY_EXISTS; break; //-8
        case ERR_ISCONN: Status = STATUS_UNSUCCESSFUL; break; //-9 (FIXME)
        case ERR_ABRT: Status = STATUS_LOCAL_DISCONNECT; break; //-10
        case ERR_RST: Status = STATUS_REMOTE_DISCONNECT; break; //-11
        case ERR_CLSD: Status = STATUS_FILE_CLOSED; break; //-12
        case ERR_CONN: Status = STATUS_INVALID_CONNECTION; break; //-13
        case ERR_ARG: Status = STATUS_INVALID_PARAMETER; break; //-14
        case ERR_IF: Status = STATUS_UNEXPECTED_NETWORK_ERROR; break; //-15
        default:
            DbgPrint("Invalid error value: %d\n", err);
            ASSERT(FALSE);
            Status = STATUS_UNSUCCESSFUL;
            break;
    }
 
    TI_DbgPrint(DEBUG_TCP,("TCP operation failed: 0x%x (%d)\n", Status, err));
 
    return Status;
}

Referenced by TCPCheckPeerForAccept(), TCPConnectEventHandler(), TCPFinEventHandler(), TCPListen(), and TCPSendEventHandler().

TCPUpdateInterfaceIPInformation()

VOID TCPUpdateInterfaceIPInformation

(

PIP_INTERFACE

IF

)

Definition at line 144 of file if.c.

{
    struct ip_addr ipaddr;
    struct ip_addr netmask;
    struct ip_addr gw;
 
    gw.addr = 0;
 
    GetInterfaceIPv4Address(IF,
                            ADE_UNICAST,
                            (PULONG)&ipaddr.addr);
 
    GetInterfaceIPv4Address(IF,
                            ADE_ADDRMASK,
                            (PULONG)&netmask.addr);
 
    netif_set_addr(IF->TCPContext, &ipaddr, &netmask, &gw);
 
    if (ipaddr.addr != 0)
    {
        netif_set_up(IF->TCPContext);
        netif_set_default(IF->TCPContext);
    }
    else
    {
        netif_set_down(IF->TCPContext);
    }
}

Referenced by IPAddInterfaceRoute(), ReconfigureAdapter(), and TCPInterfaceInit().

TCPUpdateInterfaceLinkStatus()

VOID TCPUpdateInterfaceLinkStatus

(

PIP_INTERFACE

IF

)

Definition at line 82 of file if.c.

{
    ULONG OperationalStatus;
 
    GetInterfaceConnectionStatus(IF, &OperationalStatus);
 
    if (OperationalStatus == MIB_IF_OPER_STATUS_OPERATIONAL)
        netif_set_link_up(IF->TCPContext);
    else
        netif_set_link_down(IF->TCPContext);
}

Referenced by ReconfigureAdapter(), and TCPInterfaceInit().

Variable Documentation

ClientInfo

CLIENT_DATA ClientInfo

extern

Referenced by CallNextHookEx(), ClientThreadSetupHelper(), ClosePin(), co_HOOK_CallHooks(), co_UserActivateKeyboardLayout(), EventCallback(), FxLibraryCommonRegisterClient(), GetEnhancedVerifierOptions(), InsertPinHandle(), IntRestoreTebWndCallback(), IntSetTebWndCallback(), IsClientInfoValid(), NtUserCallNextHookEx(), NtUserMessageCall(), UserFreeWindowInfo(), ValidateHwnd(), ValidateHwndNoErr(), WdmAudCapabilities(), WdmAudCloseAllMixers(), WdmAudControlCloseMixer(), WdmAudControlOpen(), WdmAudControlOpenMidi(), WdmAudControlOpenMixer(), WdmAudControlOpenWave(), WdmAudDeviceControl(), WdmAudGetMixerEvent(), and WdmAudIoctlClose().

TCP_IPIdentification

LONG TCP_IPIdentification

extern

Definition at line 15 of file tcp.c.