lwip_glue.h File Reference

#include <lwip/tcp.h>
#include <lwip/pbuf.h>
#include <lwip/ip_addr.h>
#include <tcpip.h>

Include dependency graph for lwip_glue.h:

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

Go to the source code of this file.

Classes
struct	_QUEUE_ENTRY
struct	lwip_callback_msg

Macros
#define	LWIP_TAG   'PIwl'
#define	LWIP_MESSAGE_TAG   'sMwl'
#define	LWIP_QUEUE_TAG   'uQwl'

Typedefs
typedef struct tcp_pcb *	PTCP_PCB
typedef struct _QUEUE_ENTRY	QUEUE_ENTRY
typedef struct _QUEUE_ENTRY *	PQUEUE_ENTRY

Functions
NTSTATUS	LibTCPGetDataFromConnectionQueue (PCONNECTION_ENDPOINT Connection, PUCHAR RecvBuffer, UINT RecvLen, UINT *Received)
void	TCPConnectEventHandler (void *arg, const err_t err)
void	TCPAcceptEventHandler (void *arg, PTCP_PCB newpcb)
void	TCPSendEventHandler (void *arg, const u16_t space)
void	TCPFinEventHandler (void *arg, const err_t err)
void	TCPRecvEventHandler (void *arg)
PTCP_PCB	LibTCPSocket (void *arg)
VOID	LibTCPFreeSocket (PTCP_PCB pcb)
err_t	LibTCPBind (PCONNECTION_ENDPOINT Connection, ip4_addr_t *const ipaddr, const u16_t port)
PTCP_PCB	LibTCPListen (PCONNECTION_ENDPOINT Connection, const u8_t backlog)
err_t	LibTCPSend (PCONNECTION_ENDPOINT Connection, void *const dataptr, const u16_t len, ULONG *sent, const int safe)
err_t	LibTCPConnect (PCONNECTION_ENDPOINT Connection, ip4_addr_t *const ipaddr, const u16_t port)
err_t	LibTCPShutdown (PCONNECTION_ENDPOINT Connection, const int shut_rx, const int shut_tx)
err_t	LibTCPClose (PCONNECTION_ENDPOINT Connection, const int safe, const int callback)
err_t	LibTCPGetPeerName (PTCP_PCB pcb, ip4_addr_t *const ipaddr, u16_t *const port)
err_t	LibTCPGetHostName (PTCP_PCB pcb, ip4_addr_t *const ipaddr, u16_t *const port)
void	LibTCPAccept (PTCP_PCB pcb, struct tcp_pcb *listen_pcb, void *arg)
void	LibTCPSetNoDelay (PTCP_PCB pcb, BOOLEAN Set)
void	LibTCPGetSocketStatus (PTCP_PCB pcb, PULONG State)
void	LibIPInsertPacket (void *ifarg, const void *const data, const u32_t size)
void	LibIPInitialize (void)
void	LibIPShutdown (void)

Macro Definition Documentation

LWIP_MESSAGE_TAG

#define LWIP_MESSAGE_TAG   'sMwl'

Definition at line 11 of file lwip_glue.h.

LWIP_QUEUE_TAG

#define LWIP_QUEUE_TAG   'uQwl'

Definition at line 12 of file lwip_glue.h.

LWIP_TAG

#define LWIP_TAG   'PIwl'

Definition at line 10 of file lwip_glue.h.

Typedef Documentation

PQUEUE_ENTRY

typedef struct _QUEUE_ENTRY * PQUEUE_ENTRY

PTCP_PCB

typedef struct tcp_pcb* PTCP_PCB

Definition at line 15 of file lwip_glue.h.

QUEUE_ENTRY

typedef struct _QUEUE_ENTRY QUEUE_ENTRY

Function Documentation

LibIPInitialize()

void LibIPInitialize

(

void

)

Definition at line 33 of file ip.c.

{
    /* This completes asynchronously */
    tcpip_init(NULL, NULL);
}

Referenced by TCPStartup().

LibIPInsertPacket()

void LibIPInsertPacket	(	void *	ifarg,
		const void *const	data,
		const u32_t	size
	)

Definition at line 10 of file ip.c.

{
    struct pbuf *p;
 
    ASSERT(ifarg);
    ASSERT(data);
    ASSERT(size > 0);
 
    p = pbuf_alloc(PBUF_RAW, size, PBUF_RAM);
    if (p)
    {
        ASSERT(p->tot_len == p->len);
        ASSERT(p->len == size);
 
        RtlCopyMemory(p->payload, data, p->len);
 
        ((PNETIF)ifarg)->input(p, (PNETIF)ifarg);
    }
}

Referenced by TCPReceive().

LibIPShutdown()

void LibIPShutdown

(

void

)

Definition at line 40 of file ip.c.

{
    /* This is synchronous */
    sys_shutdown();
}

Referenced by TCPShutdown().

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,
		ip4_addr_t *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().

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

LibTCPConnect()

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

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);
}

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,
		ip4_addr_t *const	ipaddr,
		u16_t *const	port
	)

LibTCPGetPeerName()

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

Referenced by TCPCheckPeerForAccept().

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

LibTCPSend()

err_t LibTCPSend	(	PCONNECTION_ENDPOINT	Connection,
		void *const	dataptr,
		const u16_t	len,
		ULONG *	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().

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

LibTCPSocket()

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

TCPAcceptEventHandler()

void TCPAcceptEventHandler	(	void *	arg,
		PTCP_PCB	newpcb
	)

Definition at line 231 of file event.c.

{
    PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)arg;
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
    PIRP Irp;
    NTSTATUS Status;
 
    LockObject(Connection);
 
    while (!IsListEmpty(&Connection->ListenRequest))
    {
        PIO_STACK_LOCATION IrpSp;
 
        Entry = RemoveHeadList(&Connection->ListenRequest);
 
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Irp = Bucket->Request.RequestContext;
        IrpSp = IoGetCurrentIrpStackLocation( Irp );
 
        TI_DbgPrint(DEBUG_TCP,("[IP, TCPAcceptEventHandler] Getting the socket\n"));
 
        Status = TCPCheckPeerForAccept(newpcb,
                                       (PTDI_REQUEST_KERNEL)&IrpSp->Parameters);
 
        TI_DbgPrint(DEBUG_TCP,("Socket: Status: %x\n", Status));
 
        Bucket->Status = Status;
        Bucket->Information = 0;
 
        if (Status == STATUS_SUCCESS)
        {
            LockObject(Bucket->AssociatedEndpoint);
 
            /* sanity assert...this should never be in anything else but a CLOSED state */
            ASSERT( ((PTCP_PCB)Bucket->AssociatedEndpoint->SocketContext)->state == CLOSED );
 
            /*  free socket context created in FileOpenConnection, as we're using a new one */
            LibTCPClose(Bucket->AssociatedEndpoint, TRUE, FALSE);
 
            /* free previously created socket context (we don't use it, we use newpcb) */
            Bucket->AssociatedEndpoint->SocketContext = newpcb;
 
            UnlockObject(Bucket->AssociatedEndpoint);
 
            LibTCPAccept(newpcb, (PTCP_PCB)Connection->SocketContext, Bucket->AssociatedEndpoint);
        }
 
        DereferenceObject(Bucket->AssociatedEndpoint);
 
        CompleteBucket(Connection, Bucket, FALSE);
 
        if (Status == STATUS_SUCCESS)
        {
            break;
        }
    }
 
    UnlockObject(Connection);
}

Referenced by InternalAcceptEventHandler().

TCPConnectEventHandler()

void TCPConnectEventHandler	(	void *	arg,
		const err_t	err
	)

Definition at line 420 of file event.c.

{
    PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)arg;
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
 
    LockObject(Connection);
 
    while (!IsListEmpty(&Connection->ConnectRequest))
    {
        Entry = RemoveHeadList(&Connection->ConnectRequest);
 
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Bucket->Status = TCPTranslateError(err);
        Bucket->Information = 0;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
 
    UnlockObject(Connection);
}

Referenced by InternalConnectEventHandler().

TCPFinEventHandler()

void TCPFinEventHandler	(	void *	arg,
		const err_t	err
	)

Definition at line 182 of file event.c.

{
   PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)arg, LastConnection;
   const NTSTATUS Status = TCPTranslateError(err);
 
   ASSERT(Connection->SocketContext == NULL);
   ASSERT(Connection->AddressFile);
   ASSERT(err != ERR_OK);
 
   LockObject(Connection);
 
   /* Complete all outstanding requests now */
   FlushAllQueues(Connection, Status);
 
   LockObject(Connection->AddressFile);
 
   /* Unlink this connection from the address file */
   if (Connection->AddressFile->Connection == Connection)
   {
       Connection->AddressFile->Connection = Connection->Next;
       DereferenceObject(Connection);
   }
   else if (Connection->AddressFile->Listener == Connection)
   {
       Connection->AddressFile->Listener = NULL;
       DereferenceObject(Connection);
   }
   else
   {
       LastConnection = Connection->AddressFile->Connection;
       while (LastConnection->Next != Connection && LastConnection->Next != NULL)
           LastConnection = LastConnection->Next;
       if (LastConnection->Next == Connection)
       {
           LastConnection->Next = Connection->Next;
           DereferenceObject(Connection);
       }
   }
 
   UnlockObject(Connection->AddressFile);
 
   /* Remove the address file from this connection */
   DereferenceObject(Connection->AddressFile);
   Connection->AddressFile = NULL;
 
   UnlockObject(Connection);
}

Referenced by InternalErrorEventHandler(), InternalRecvEventHandler(), LibTCPCloseCallback(), and LibTCPShutdownCallback().

TCPRecvEventHandler()

void TCPRecvEventHandler

(

void *

arg

)

Definition at line 380 of file event.c.

{
    PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)arg;
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
    PIRP Irp;
    PMDL Mdl;
    UINT Received;
    UINT RecvLen;
    PUCHAR RecvBuffer;
    NTSTATUS Status;
 
    LockObject(Connection);
 
    while(!IsListEmpty(&Connection->ReceiveRequest))
    {
        Entry = RemoveHeadList(&Connection->ReceiveRequest);
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Irp = Bucket->Request.RequestContext;
        Mdl = Irp->MdlAddress;
 
        NdisQueryBuffer( Mdl, &RecvBuffer, &RecvLen );
 
        Status = LibTCPGetDataFromConnectionQueue(Connection, RecvBuffer, RecvLen, &Received);
        if (Status == STATUS_PENDING)
        {
            InsertHeadList(&Connection->ReceiveRequest, &Bucket->Entry);
            break;
        }
 
        Bucket->Status = Status;
        Bucket->Information = Received;
 
        CompleteBucket(Connection, Bucket, FALSE);
    }
    UnlockObject(Connection);
}

Referenced by InternalErrorEventHandler(), and InternalRecvEventHandler().

TCPSendEventHandler()

void TCPSendEventHandler	(	void *	arg,
		const u16_t	space
	)

Definition at line 294 of file event.c.

{
    PCONNECTION_ENDPOINT Connection = (PCONNECTION_ENDPOINT)arg;
    PTDI_BUCKET Bucket;
    PLIST_ENTRY Entry;
    PIRP Irp;
    NTSTATUS Status;
    PMDL Mdl;
    ULONG BytesSent;
 
    ReferenceObject(Connection);
    LockObject(Connection);
 
    while (!IsListEmpty(&Connection->SendRequest))
    {
        UINT SendLen = 0;
        PVOID SendBuffer = 0;
 
        Entry = RemoveHeadList(&Connection->SendRequest);
 
        UnlockObject(Connection);
 
        Bucket = CONTAINING_RECORD( Entry, TDI_BUCKET, Entry );
 
        Irp = Bucket->Request.RequestContext;
        Mdl = Irp->MdlAddress;
 
        TI_DbgPrint(DEBUG_TCP,
                    ("Getting the user buffer from %x\n", Mdl));
 
        NdisQueryBuffer( Mdl, &SendBuffer, &SendLen );
 
        TI_DbgPrint(DEBUG_TCP,
                    ("Writing %d bytes to %x\n", SendLen, SendBuffer));
 
        TI_DbgPrint(DEBUG_TCP, ("Connection: %x\n", Connection));
        TI_DbgPrint
        (DEBUG_TCP,
         ("Connection->SocketContext: %x\n",
          Connection->SocketContext));
 
        Status = TCPTranslateError(LibTCPSend(Connection,
                                              SendBuffer,
                                              SendLen, &BytesSent, TRUE));
 
        TI_DbgPrint(DEBUG_TCP,("TCP Bytes: %d\n", BytesSent));
 
        if( Status == STATUS_PENDING )
        {
            LockObject(Connection);
            InsertHeadList(&Connection->SendRequest, &Bucket->Entry);
            break;
        }
        else
        {
            TI_DbgPrint(DEBUG_TCP,
                        ("Completing Send request: %x %x\n",
                         Bucket->Request, Status));
 
            Bucket->Status = Status;
            Bucket->Information = (Bucket->Status == STATUS_SUCCESS) ? BytesSent : 0;
 
            CompleteBucket(Connection, Bucket, FALSE);
        }
 
        LockObject(Connection);
    }
 
    //  If we completed all outstanding send requests then finish all pending shutdown requests,
    //  cancel the timer and dereference the connection
    if (IsListEmpty(&Connection->SendRequest))
    {
        FlushShutdownQueue(Connection, STATUS_SUCCESS);
 
        if (KeCancelTimer(&Connection->DisconnectTimer))
        {
            DereferenceObject(Connection);
        }
    }
 
    UnlockObject(Connection);
 
    DereferenceObject(Connection);
}

Referenced by InternalSendEventHandler().