tcp.c File Reference

#include <debug.h>
#include <lwip/tcpip.h>
#include "lwip_glue.h"

Include dependency graph for tcp.c:

Go to the source code of this file.

Functions
NTSTATUS	TCPTranslateError (const err_t err)
void	LibTCPDumpPcb (PVOID SocketContext)
static void	LibTCPEmptyQueue (PCONNECTION_ENDPOINT Connection)
void	LibTCPEnqueuePacket (PCONNECTION_ENDPOINT Connection, struct pbuf *p)
PQUEUE_ENTRY	LibTCPDequeuePacket (PCONNECTION_ENDPOINT Connection)
NTSTATUS	LibTCPGetDataFromConnectionQueue (PCONNECTION_ENDPOINT Connection, PUCHAR RecvBuffer, UINT RecvLen, UINT *Received)
static BOOLEAN	WaitForEventSafely (PRKEVENT Event)
static err_t	InternalSendEventHandler (void *arg, PTCP_PCB pcb, const u16_t space)
static err_t	InternalRecvEventHandler (void *arg, PTCP_PCB pcb, struct pbuf *p, const err_t err)
static err_t	InternalAcceptEventHandler (void *arg, PTCP_PCB newpcb, const err_t err)
static err_t	InternalConnectEventHandler (void *arg, PTCP_PCB pcb, const err_t err)
static void	InternalErrorEventHandler (void *arg, const err_t err)
static void	LibTCPSocketCallback (void *arg)
struct tcp_pcb *	LibTCPSocket (void *arg)
static void	LibTCPFreeSocketCallback (void *arg)
void	LibTCPFreeSocket (PTCP_PCB pcb)
static void	LibTCPBindCallback (void *arg)
err_t	LibTCPBind (PCONNECTION_ENDPOINT Connection, struct ip_addr *const ipaddr, const u16_t port)
static void	LibTCPListenCallback (void *arg)
PTCP_PCB	LibTCPListen (PCONNECTION_ENDPOINT Connection, const u8_t backlog)
static void	LibTCPSendCallback (void *arg)
err_t	LibTCPSend (PCONNECTION_ENDPOINT Connection, void *const dataptr, const u16_t len, u32_t *sent, const int safe)
static void	LibTCPConnectCallback (void *arg)
err_t	LibTCPConnect (PCONNECTION_ENDPOINT Connection, struct ip_addr *const ipaddr, const u16_t port)
static void	LibTCPShutdownCallback (void *arg)
err_t	LibTCPShutdown (PCONNECTION_ENDPOINT Connection, const int shut_rx, const int shut_tx)
static void	LibTCPCloseCallback (void *arg)
err_t	LibTCPClose (PCONNECTION_ENDPOINT Connection, const int safe, const int callback)
void	LibTCPAccept (PTCP_PCB pcb, struct tcp_pcb *listen_pcb, void *arg)
err_t	LibTCPGetHostName (PTCP_PCB pcb, struct ip_addr *const ipaddr, u16_t *const port)
err_t	LibTCPGetPeerName (PTCP_PCB pcb, struct ip_addr *const ipaddr, u16_t *const port)
void	LibTCPSetNoDelay (PTCP_PCB pcb, BOOLEAN Set)
void	LibTCPGetSocketStatus (PTCP_PCB pcb, PULONG State)

Variables
static const char *const	tcp_state_str []
KEVENT	TerminationEvent
NPAGED_LOOKASIDE_LIST	MessageLookasideList
NPAGED_LOOKASIDE_LIST	QueueEntryLookasideList

Function Documentation

InternalAcceptEventHandler()

static err_t InternalAcceptEventHandler ( void *  arg, PTCP_PCB  newpcb, const err_t  err  )

static

Definition at line 267 of file tcp.c.

{
    /* Make sure the socket didn't get closed */
    if (!arg)
        return ERR_CLSD;
 
    TCPAcceptEventHandler(arg, newpcb);
 
    /* Set in LibTCPAccept (called from TCPAcceptEventHandler) */
    if (newpcb->callback_arg)
        return ERR_OK;
    else
        return ERR_CLSD;
}

Referenced by LibTCPListenCallback().

InternalConnectEventHandler()

static err_t InternalConnectEventHandler ( void *  arg, PTCP_PCB  pcb, const err_t  err  )

static

Definition at line 284 of file tcp.c.

{
    /* Make sure the socket didn't get closed */
    if (!arg)
        return ERR_OK;
 
    TCPConnectEventHandler(arg, err);
 
    return ERR_OK;
}

Referenced by LibTCPConnectCallback().

InternalErrorEventHandler()

static void InternalErrorEventHandler ( void *  arg, const err_t  err  )

static

Definition at line 297 of file tcp.c.

{
    PCONNECTION_ENDPOINT Connection = arg;
 
    /* Make sure the socket didn't get closed */
    if (!arg || Connection->SocketContext == NULL) return;
 
    /* The PCB is dead now */
    Connection->SocketContext = NULL;
 
    /* Give them one shot to receive the remaining data */
    Connection->ReceiveShutdown = TRUE;
    Connection->ReceiveShutdownStatus = TCPTranslateError(err);
    TCPRecvEventHandler(Connection);
 
    /* Terminate the connection */
    TCPFinEventHandler(Connection, err);
}

Referenced by LibTCPAccept(), and LibTCPSocketCallback().

InternalRecvEventHandler()

static err_t InternalRecvEventHandler ( void *  arg, PTCP_PCB  pcb, struct pbuf *  p, const err_t  err  )

static

Definition at line 213 of file tcp.c.

{
    PCONNECTION_ENDPOINT Connection = arg;
 
    /* Make sure the socket didn't get closed */
    if (!arg)
    {
        if (p)
            pbuf_free(p);
 
        return ERR_OK;
    }
 
    if (p)
    {
        LibTCPEnqueuePacket(Connection, p);
 
        tcp_recved(pcb, p->tot_len);
 
        TCPRecvEventHandler(arg);
    }
    else if (err == ERR_OK)
    {
        /* Complete pending reads with 0 bytes to indicate a graceful closure,
         * but note that send is still possible in this state so we don't close the
         * whole socket here (by calling tcp_close()) as that would violate TCP specs
         */
        Connection->ReceiveShutdown = TRUE;
        Connection->ReceiveShutdownStatus = STATUS_SUCCESS;
 
        /* If we already did a send shutdown, we're in TIME_WAIT so we can't use this PCB anymore */
        if (Connection->SendShutdown)
        {
            Connection->SocketContext = NULL;
            tcp_arg(pcb, NULL);
        }
 
        /* Indicate the graceful close event */
        TCPRecvEventHandler(arg);
 
        /* If the PCB is gone, clean up the connection */
        if (Connection->SendShutdown)
        {
            TCPFinEventHandler(Connection, ERR_CLSD);
        }
    }
 
    return ERR_OK;
}

Referenced by LibTCPAccept(), and LibTCPConnectCallback().

InternalSendEventHandler()

static err_t InternalSendEventHandler ( void *  arg, PTCP_PCB  pcb, const u16_t  space  )

static

Definition at line 201 of file tcp.c.

{
    /* Make sure the socket didn't get closed */
    if (!arg) return ERR_OK;
 
    TCPSendEventHandler(arg, space);
 
    return ERR_OK;
}

Referenced by LibTCPAccept(), and LibTCPConnectCallback().

LibTCPAccept()

void LibTCPAccept	(	PTCP_PCB	pcb,
		struct tcp_pcb *	listen_pcb,
		void *	arg
	)

Definition at line 830 of file tcp.c.

{
    ASSERT(arg);
 
    tcp_arg(pcb, NULL);
    tcp_recv(pcb, InternalRecvEventHandler);
    tcp_sent(pcb, InternalSendEventHandler);
    tcp_err(pcb, InternalErrorEventHandler);
    tcp_arg(pcb, arg);
 
    tcp_accepted(listen_pcb);
}

Referenced by TCPAcceptEventHandler().

LibTCPBind()

err_t LibTCPBind	(	PCONNECTION_ENDPOINT	Connection,
		struct ip_addr *const	ipaddr,
		const u16_t	port
	)

Definition at line 415 of file tcp.c.

{
    struct lwip_callback_msg *msg;
    err_t ret;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
        msg->Input.Bind.Connection = Connection;
        msg->Input.Bind.IpAddress = ipaddr;
        msg->Input.Bind.Port = port;
 
        tcpip_callback_with_block(LibTCPBindCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Bind.Error;
        else
            ret = ERR_CLSD;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return ERR_MEM;
}

Referenced by TCPConnect(), and TCPListen().

LibTCPBindCallback()

static void LibTCPBindCallback ( void *  arg )

static

Definition at line 390 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
    PTCP_PCB pcb = msg->Input.Bind.Connection->SocketContext;
 
    ASSERT(msg);
 
    if (!msg->Input.Bind.Connection->SocketContext)
    {
        msg->Output.Bind.Error = ERR_CLSD;
        goto done;
    }
 
    /* We're guaranteed that the local address is valid to bind at this point */
    pcb->so_options |= SOF_REUSEADDR;
 
    msg->Output.Bind.Error = tcp_bind(pcb,
                                      msg->Input.Bind.IpAddress,
                                      ntohs(msg->Input.Bind.Port));
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPBind().

LibTCPClose()

err_t LibTCPClose	(	PCONNECTION_ENDPOINT	Connection,
		const int	safe,
		const int	callback
	)

Definition at line 798 of file tcp.c.

{
    err_t ret;
    struct lwip_callback_msg *msg;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
 
        msg->Input.Close.Connection = Connection;
        msg->Input.Close.Callback = callback;
 
        if (safe)
            LibTCPCloseCallback(msg);
        else
            tcpip_callback_with_block(LibTCPCloseCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Close.Error;
        else
            ret = ERR_CLSD;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return ERR_MEM;
}

Referenced by TCPAcceptEventHandler(), and TCPClose().

LibTCPCloseCallback()

static void LibTCPCloseCallback ( void *  arg )

static

Definition at line 748 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
    PTCP_PCB pcb = msg->Input.Close.Connection->SocketContext;
 
    /* Empty the queue even if we're already "closed" */
    LibTCPEmptyQueue(msg->Input.Close.Connection);
 
    /* Check if we've already been closed */
    if (msg->Input.Close.Connection->Closing)
    {
        msg->Output.Close.Error = ERR_OK;
        goto done;
    }
 
    /* Enter "closing" mode if we're doing a normal close */
    if (msg->Input.Close.Callback)
        msg->Input.Close.Connection->Closing = TRUE;
 
    /* Check if the PCB was already "closed" but the client doesn't know it yet */
    if (!msg->Input.Close.Connection->SocketContext)
    {
        msg->Output.Close.Error = ERR_OK;
        goto done;
    }
 
    /* Clear the PCB pointer and stop callbacks */
    msg->Input.Close.Connection->SocketContext = NULL;
    tcp_arg(pcb, NULL);
 
    /* This may generate additional callbacks but we don't care,
     * because they're too inconsistent to rely on */
    msg->Output.Close.Error = tcp_close(pcb);
 
    if (msg->Output.Close.Error)
    {
        /* Restore the PCB pointer */
        msg->Input.Close.Connection->SocketContext = pcb;
        msg->Input.Close.Connection->Closing = FALSE;
    }
    else if (msg->Input.Close.Callback)
    {
        TCPFinEventHandler(msg->Input.Close.Connection, ERR_CLSD);
    }
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPClose().

LibTCPConnect()

err_t LibTCPConnect	(	PCONNECTION_ENDPOINT	Connection,
		struct ip_addr *const	ipaddr,
		const u16_t	port
	)

Definition at line 622 of file tcp.c.

{
    struct lwip_callback_msg *msg;
    err_t ret;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
        msg->Input.Connect.Connection = Connection;
        msg->Input.Connect.IpAddress = ipaddr;
        msg->Input.Connect.Port = port;
 
        tcpip_callback_with_block(LibTCPConnectCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
        {
            ret = msg->Output.Connect.Error;
        }
        else
            ret = ERR_CLSD;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return ERR_MEM;
}

Referenced by TCPConnect().

LibTCPConnectCallback()

static void LibTCPConnectCallback ( void *  arg )

static

Definition at line 595 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
    err_t Error;
 
    ASSERT(arg);
 
    if (!msg->Input.Connect.Connection->SocketContext)
    {
        msg->Output.Connect.Error = ERR_CLSD;
        goto done;
    }
 
    tcp_recv((PTCP_PCB)msg->Input.Connect.Connection->SocketContext, InternalRecvEventHandler);
    tcp_sent((PTCP_PCB)msg->Input.Connect.Connection->SocketContext, InternalSendEventHandler);
 
    Error = tcp_connect((PTCP_PCB)msg->Input.Connect.Connection->SocketContext,
                        msg->Input.Connect.IpAddress, ntohs(msg->Input.Connect.Port),
                        InternalConnectEventHandler);
 
    msg->Output.Connect.Error = Error == ERR_OK ? ERR_INPROGRESS : Error;
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPConnect().

LibTCPDequeuePacket()

PQUEUE_ENTRY LibTCPDequeuePacket

(

PCONNECTION_ENDPOINT

Connection

)

Definition at line 86 of file tcp.c.

{
    PLIST_ENTRY Entry;
    PQUEUE_ENTRY qp = NULL;
 
    if (IsListEmpty(&Connection->PacketQueue)) return NULL;
 
    Entry = RemoveHeadList(&Connection->PacketQueue);
 
    qp = CONTAINING_RECORD(Entry, QUEUE_ENTRY, ListEntry);
 
    return qp;
}

Referenced by LibTCPGetDataFromConnectionQueue().

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().

LibTCPEmptyQueue()

static void LibTCPEmptyQueue ( PCONNECTION_ENDPOINT  Connection )

static

Definition at line 52 of file tcp.c.

{
    PLIST_ENTRY Entry;
    PQUEUE_ENTRY qp = NULL;
 
    ReferenceObject(Connection);
 
    while (!IsListEmpty(&Connection->PacketQueue))
    {
        Entry = RemoveHeadList(&Connection->PacketQueue);
        qp = CONTAINING_RECORD(Entry, QUEUE_ENTRY, ListEntry);
 
        /* We're in the tcpip thread here so this is safe */
        pbuf_free(qp->p);
 
        ExFreeToNPagedLookasideList(&QueueEntryLookasideList, qp);
    }
 
    DereferenceObject(Connection);
}

Referenced by LibTCPCloseCallback().

LibTCPEnqueuePacket()

void LibTCPEnqueuePacket	(	PCONNECTION_ENDPOINT	Connection,
		struct pbuf *	p
	)

Definition at line 73 of file tcp.c.

{
    PQUEUE_ENTRY qp;
 
    qp = (PQUEUE_ENTRY)ExAllocateFromNPagedLookasideList(&QueueEntryLookasideList);
    qp->p = p;
    qp->Offset = 0;
 
    LockObject(Connection);
    InsertTailList(&Connection->PacketQueue, &qp->ListEntry);
    UnlockObject(Connection);
}

Referenced by InternalRecvEventHandler().

LibTCPFreeSocket()

void LibTCPFreeSocket

(

PTCP_PCB

pcb

)

Definition at line 375 of file tcp.c.

{
    struct lwip_callback_msg msg;
 
    KeInitializeEvent(&msg.Event, NotificationEvent, FALSE);
    msg.Input.FreeSocket.pcb = pcb;
 
    tcpip_callback_with_block(LibTCPFreeSocketCallback, &msg, 1);
 
    WaitForEventSafely(&msg.Event);
}

LibTCPFreeSocketCallback()

static void LibTCPFreeSocketCallback ( void *  arg )

static

Definition at line 363 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
 
    ASSERT(msg);
 
    /* Calling tcp_close will free it */
    tcp_close(msg->Input.FreeSocket.pcb);
 
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPFreeSocket().

LibTCPGetDataFromConnectionQueue()

NTSTATUS LibTCPGetDataFromConnectionQueue	(	PCONNECTION_ENDPOINT	Connection,
		PUCHAR	RecvBuffer,
		UINT	RecvLen,
		UINT *	Received
	)

Definition at line 100 of file tcp.c.

{
    PQUEUE_ENTRY qp;
    struct pbuf* p;
    NTSTATUS Status;
    UINT ReadLength, PayloadLength, Offset, Copied;
 
    (*Received) = 0;
 
    LockObject(Connection);
 
    if (!IsListEmpty(&Connection->PacketQueue))
    {
        while ((qp = LibTCPDequeuePacket(Connection)) != NULL)
        {
            p = qp->p;
 
            /* Calculate the payload length first */
            PayloadLength = p->tot_len;
            PayloadLength -= qp->Offset;
            Offset = qp->Offset;
 
            /* Check if we're reading the whole buffer */
            ReadLength = MIN(PayloadLength, RecvLen);
            ASSERT(ReadLength != 0);
            if (ReadLength != PayloadLength)
            {
                /* Save this one for later */
                qp->Offset += ReadLength;
                InsertHeadList(&Connection->PacketQueue, &qp->ListEntry);
                qp = NULL;
            }
 
            Copied = pbuf_copy_partial(p, RecvBuffer, ReadLength, Offset);
            ASSERT(Copied == ReadLength);
 
            /* Update trackers */
            RecvLen -= ReadLength;
            RecvBuffer += ReadLength;
            (*Received) += ReadLength;
 
            if (qp != NULL)
            {
                /* Use this special pbuf free callback function because we're outside tcpip thread */
                pbuf_free_callback(qp->p);
 
                ExFreeToNPagedLookasideList(&QueueEntryLookasideList, qp);
            }
            else
            {
                /* If we get here, it means we've filled the buffer */
                ASSERT(RecvLen == 0);
            }
 
            ASSERT((*Received) != 0);
            Status = STATUS_SUCCESS;
 
            if (!RecvLen)
                break;
        }
    }
    else
    {
        if (Connection->ReceiveShutdown)
            Status = Connection->ReceiveShutdownStatus;
        else
            Status = STATUS_PENDING;
    }
 
    UnlockObject(Connection);
 
    return Status;
}

Referenced by TCPReceiveData(), and TCPRecvEventHandler().

LibTCPGetHostName()

err_t LibTCPGetHostName	(	PTCP_PCB	pcb,
		struct ip_addr *const	ipaddr,
		u16_t *const	port
	)

Definition at line 844 of file tcp.c.

{
    if (!pcb)
        return ERR_CLSD;
 
    *ipaddr = pcb->local_ip;
    *port = pcb->local_port;
 
    return ERR_OK;
}

Referenced by TCPGetSockAddress().

LibTCPGetPeerName()

err_t LibTCPGetPeerName	(	PTCP_PCB	pcb,
		struct ip_addr *const	ipaddr,
		u16_t *const	port
	)

Definition at line 856 of file tcp.c.

{
    if (!pcb)
        return ERR_CLSD;
 
    *ipaddr = pcb->remote_ip;
    *port = pcb->remote_port;
 
    return ERR_OK;
}

Referenced by TCPCheckPeerForAccept(), and TCPGetSockAddress().

LibTCPGetSocketStatus()

void LibTCPGetSocketStatus	(	PTCP_PCB	pcb,
		PULONG	State
	)

Definition at line 879 of file tcp.c.

{
    /* Translate state from enum tcp_state -> MIB_TCP_STATE */
    *State = pcb->state + 1;
}

Referenced by TCPGetSocketStatus().

LibTCPListen()

PTCP_PCB LibTCPListen	(	PCONNECTION_ENDPOINT	Connection,
		const u8_t	backlog
	)

Definition at line 469 of file tcp.c.

{
    struct lwip_callback_msg *msg;
    PTCP_PCB ret;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
        msg->Input.Listen.Connection = Connection;
        msg->Input.Listen.Backlog = backlog;
 
        tcpip_callback_with_block(LibTCPListenCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Listen.NewPcb;
        else
            ret = NULL;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return NULL;
}

Referenced by TCPListen().

LibTCPListenCallback()

static void LibTCPListenCallback ( void *  arg )

static

Definition at line 445 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
 
    ASSERT(msg);
 
    if (!msg->Input.Listen.Connection->SocketContext)
    {
        msg->Output.Listen.NewPcb = NULL;
        goto done;
    }
 
    msg->Output.Listen.NewPcb = tcp_listen_with_backlog((PTCP_PCB)msg->Input.Listen.Connection->SocketContext, msg->Input.Listen.Backlog);
 
    if (msg->Output.Listen.NewPcb)
    {
        tcp_accept(msg->Output.Listen.NewPcb, InternalAcceptEventHandler);
    }
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPListen().

LibTCPSend()

err_t LibTCPSend	(	PCONNECTION_ENDPOINT	Connection,
		void *const	dataptr,
		const u16_t	len,
		u32_t *	sent,
		const int	safe
	)

Definition at line 557 of file tcp.c.

{
    err_t ret;
    struct lwip_callback_msg *msg;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
        msg->Input.Send.Connection = Connection;
        msg->Input.Send.Data = dataptr;
        msg->Input.Send.DataLength = len;
 
        if (safe)
            LibTCPSendCallback(msg);
        else
            tcpip_callback_with_block(LibTCPSendCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Send.Error;
        else
            ret = ERR_CLSD;
 
        if (ret == ERR_OK)
            *sent = msg->Output.Send.Information;
        else
            *sent = 0;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return ERR_MEM;
}

Referenced by TCPSendData(), and TCPSendEventHandler().

LibTCPSendCallback()

static void LibTCPSendCallback ( void *  arg )

static

Definition at line 498 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
    PTCP_PCB pcb = msg->Input.Send.Connection->SocketContext;
    ULONG SendLength;
    UCHAR SendFlags;
 
    ASSERT(msg);
 
    if (!msg->Input.Send.Connection->SocketContext)
    {
        msg->Output.Send.Error = ERR_CLSD;
        goto done;
    }
 
    if (msg->Input.Send.Connection->SendShutdown)
    {
        msg->Output.Send.Error = ERR_CLSD;
        goto done;
    }
 
    SendFlags = TCP_WRITE_FLAG_COPY;
    SendLength = msg->Input.Send.DataLength;
    if (tcp_sndbuf(pcb) == 0)
    {
        /* No buffer space so return pending */
        msg->Output.Send.Error = ERR_INPROGRESS;
        goto done;
    }
    else if (tcp_sndbuf(pcb) < SendLength)
    {
        /* We've got some room so let's send what we can */
        SendLength = tcp_sndbuf(pcb);
 
        /* Don't set the push flag */
        SendFlags |= TCP_WRITE_FLAG_MORE;
    }
 
    msg->Output.Send.Error = tcp_write(pcb,
                                       msg->Input.Send.Data,
                                       SendLength,
                                       SendFlags);
    if (msg->Output.Send.Error == ERR_OK)
    {
        /* Queued successfully so try to send it */
        tcp_output((PTCP_PCB)msg->Input.Send.Connection->SocketContext);
        msg->Output.Send.Information = SendLength;
    }
    else if (msg->Output.Send.Error == ERR_MEM)
    {
        /* The queue is too long */
        msg->Output.Send.Error = ERR_INPROGRESS;
    }
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPSend().

LibTCPSetNoDelay()

void LibTCPSetNoDelay	(	PTCP_PCB	pcb,
		BOOLEAN	Set
	)

Definition at line 868 of file tcp.c.

{
    if (Set)
        pcb->flags |= TF_NODELAY;
    else
        pcb->flags &= ~TF_NODELAY;
}

Referenced by TCPSetNoDelay().

LibTCPShutdown()

err_t LibTCPShutdown	(	PCONNECTION_ENDPOINT	Connection,
		const int	shut_rx,
		const int	shut_tx
	)

Definition at line 717 of file tcp.c.

{
    struct lwip_callback_msg *msg;
    err_t ret;
 
    msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
 
        msg->Input.Shutdown.Connection = Connection;
        msg->Input.Shutdown.shut_rx = shut_rx;
        msg->Input.Shutdown.shut_tx = shut_tx;
 
        tcpip_callback_with_block(LibTCPShutdownCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Shutdown.Error;
        else
            ret = ERR_CLSD;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return ERR_MEM;
}

Referenced by DisconnectWorker(), and TCPDisconnect().

LibTCPShutdownCallback()

static void LibTCPShutdownCallback ( void *  arg )

static

Definition at line 654 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
    PTCP_PCB pcb = msg->Input.Shutdown.Connection->SocketContext;
 
    if (!msg->Input.Shutdown.Connection->SocketContext)
    {
        msg->Output.Shutdown.Error = ERR_CLSD;
        goto done;
    }
 
    /* LwIP makes the (questionable) assumption that SHUTDOWN_RDWR is equivalent to tcp_close().
     * This assumption holds even if the shutdown calls are done separately (even through multiple
     * WinSock shutdown() calls). This assumption means that lwIP has the right to deallocate our
     * PCB without telling us if we shutdown TX and RX. To avoid these problems, we'll clear the
     * socket context if we have called shutdown for TX and RX.
     */
    if (msg->Input.Shutdown.shut_rx != msg->Input.Shutdown.shut_tx) {
        if (msg->Input.Shutdown.shut_rx) {
            msg->Output.Shutdown.Error = tcp_shutdown(pcb, TRUE, FALSE);
        }
        if (msg->Input.Shutdown.shut_tx) {
            msg->Output.Shutdown.Error = tcp_shutdown(pcb, FALSE, TRUE);
        }
    }
    else if (msg->Input.Shutdown.shut_rx) {
        /* We received both RX and TX requests, which seems to mean closing connection from TDI.
         * So call tcp_close, otherwise we risk to be put in TCP_WAIT_* states, which makes further
         * attempts to close the socket to fail in this state.
         */
        msg->Output.Shutdown.Error = tcp_close(pcb);
    }
    else {
        /* This case shouldn't happen */
        DbgPrint("Requested socket shutdown(0, 0) !\n");
    }
 
    if (!msg->Output.Shutdown.Error)
    {
        if (msg->Input.Shutdown.shut_rx)
        {
            msg->Input.Shutdown.Connection->ReceiveShutdown = TRUE;
            msg->Input.Shutdown.Connection->ReceiveShutdownStatus = STATUS_FILE_CLOSED;
        }
 
        if (msg->Input.Shutdown.shut_tx)
            msg->Input.Shutdown.Connection->SendShutdown = TRUE;
 
        if (msg->Input.Shutdown.Connection->ReceiveShutdown &&
            msg->Input.Shutdown.Connection->SendShutdown)
        {
            /* The PCB is not ours anymore */
            msg->Input.Shutdown.Connection->SocketContext = NULL;
            tcp_arg(pcb, NULL);
            TCPFinEventHandler(msg->Input.Shutdown.Connection, ERR_CLSD);
        }
    }
 
done:
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPShutdown().

LibTCPSocket()

struct tcp_pcb * LibTCPSocket

(

void *

arg

)

Definition at line 336 of file tcp.c.

{
    struct lwip_callback_msg *msg = ExAllocateFromNPagedLookasideList(&MessageLookasideList);
    struct tcp_pcb *ret;
 
    if (msg)
    {
        KeInitializeEvent(&msg->Event, NotificationEvent, FALSE);
        msg->Input.Socket.Arg = arg;
 
        tcpip_callback_with_block(LibTCPSocketCallback, msg, 1);
 
        if (WaitForEventSafely(&msg->Event))
            ret = msg->Output.Socket.NewPcb;
        else
            ret = NULL;
 
        ExFreeToNPagedLookasideList(&MessageLookasideList, msg);
 
        return ret;
    }
 
    return NULL;
}

Referenced by TCPSocket().

LibTCPSocketCallback()

static void LibTCPSocketCallback ( void *  arg )

static

Definition at line 318 of file tcp.c.

{
    struct lwip_callback_msg *msg = arg;
 
    ASSERT(msg);
 
    msg->Output.Socket.NewPcb = tcp_new();
 
    if (msg->Output.Socket.NewPcb)
    {
        tcp_arg(msg->Output.Socket.NewPcb, msg->Input.Socket.Arg);
        tcp_err(msg->Output.Socket.NewPcb, InternalErrorEventHandler);
    }
 
    KeSetEvent(&msg->Event, IO_NO_INCREMENT, FALSE);
}

Referenced by LibTCPSocket().

TCPTranslateError()

NTSTATUS TCPTranslateError

(

const err_t

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 DisconnectWorker(), InternalErrorEventHandler(), TCPConnect(), TCPDisconnect(), TCPGetSockAddress(), and TCPSendData().

WaitForEventSafely()

static BOOLEAN WaitForEventSafely ( PRKEVENT  Event )

static

Definition at line 176 of file tcp.c.

{
    PVOID WaitObjects[] = {Event, &TerminationEvent};
 
    if (KeWaitForMultipleObjects(2,
                                 WaitObjects,
                                 WaitAny,
                                 Executive,
                                 KernelMode,
                                 FALSE,
                                 NULL,
                                 NULL) == STATUS_WAIT_0)
    {
        /* Signalled by the caller's event */
        return TRUE;
    }
    else /* if KeWaitForMultipleObjects() == STATUS_WAIT_1 */
    {
        /* Signalled by our termination event */
        return FALSE;
    }
}

Referenced by LibTCPBind(), LibTCPClose(), LibTCPConnect(), LibTCPFreeSocket(), LibTCPListen(), LibTCPSend(), LibTCPShutdown(), and LibTCPSocket().

Variable Documentation

MessageLookasideList

NPAGED_LOOKASIDE_LIST MessageLookasideList

extern

Definition at line 10 of file sys_arch.c.

Referenced by LibTCPBind(), LibTCPClose(), LibTCPConnect(), LibTCPListen(), LibTCPSend(), LibTCPShutdown(), LibTCPSocket(), sys_init(), and sys_shutdown().

QueueEntryLookasideList

NPAGED_LOOKASIDE_LIST QueueEntryLookasideList

extern

Definition at line 11 of file sys_arch.c.

Referenced by LibTCPEmptyQueue(), LibTCPEnqueuePacket(), LibTCPGetDataFromConnectionQueue(), sys_init(), and sys_shutdown().

tcp_state_str

const char* const tcp_state_str[]

static

Initial value:

= {
  "CLOSED",
  "LISTEN",
  "SYN_SENT",
  "SYN_RCVD",
  "ESTABLISHED",
  "FIN_WAIT_1",
  "FIN_WAIT_2",
  "CLOSE_WAIT",
  "CLOSING",
  "LAST_ACK",
  "TIME_WAIT"
}

Definition at line 6 of file tcp.c.

Referenced by LibTCPDumpPcb().

TerminationEvent

KEVENT TerminationEvent

extern

Definition at line 9 of file sys_arch.c.

Referenced by sys_arch_mbox_fetch(), sys_arch_sem_wait(), sys_init(), sys_shutdown(), and WaitForEventSafely().