// tdipnp.c
//
// 
// Requires DDK Only
// File created on 2/2/2005
//

#include "pch.h"
#ifdef CPR_WMI_TRACE
#include "tdipnp.tmh"
#endif

PCPR_TDI_SOCKET  g_Socket0 = NULL;
PCPR_TDI_SOCKET  g_Socket1 = NULL;
PCPR_TDI_SOCKET  g_Socket2 = NULL;
PCPR_TDI_SOCKET  g_Socket3 = NULL;

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiStartup
//      Registers tdi pnp handlers
//
//  Arguments:
//      IN  ClientName
//              Registry Path
//
//
//  Return Value:
//      NT status code
//
NTSTATUS CprTdiStartup(
    IN  PUNICODE_STRING ClientName
    )
{
    TDI_CLIENT_INTERFACE_INFO   TdiInterfaceInfo;
    NTSTATUS                    status = STATUS_SUCCESS;

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    // register tdi pnp handlers
    RtlZeroMemory(&TdiInterfaceInfo, sizeof(TDI_CLIENT_INTERFACE_INFO));

    TdiInterfaceInfo.MajorTdiVersion = TDI_CURRENT_MAJOR_VERSION;
    TdiInterfaceInfo.MinorTdiVersion = TDI_CURRENT_MINOR_VERSION;
    TdiInterfaceInfo.ClientName = ClientName;
    TdiInterfaceInfo.PnPPowerHandler = CprTdiPnPPowerChange;
    TdiInterfaceInfo.BindingHandler = CprTdiPnPBindingChange;
    TdiInterfaceInfo.AddAddressHandlerV2 = CprTdiPnPAddNetAddress;
    TdiInterfaceInfo.DelAddressHandlerV2 = CprTdiPnPDelNetAddress; 

    status = TdiRegisterPnPHandlers(&TdiInterfaceInfo, sizeof(TDI_CLIENT_INTERFACE_INFO), &g_Data.BindingHandle);

    CprDebugPrint1(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--. STATUS %x", status);

    return status;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiCleanup
//      Registers tdi pnp handlers
//
//  Arguments:
//      None
//
//  Return Value:
//      None
//
VOID CprTdiCleanup()
{
    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    TdiDeregisterPnPHandlers(g_Data.BindingHandle);
	g_Data.BindingHandle = NULL;
    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--");

    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiPnPPowerChange
//      Pnp and Power event callback
//
//  Arguments:
//      IN  DeviceName
//              transport device object name
//
//      IN  PowerEvent
//              pointer to NET_PNP_EVENT structure
//
//      IN  Context1
//              protocol specific context
//
//      IN  Context2
//              protocol specific context
//
//
//  Return Value:
//      NT status code
//
NTSTATUS CprTdiPnPPowerChange(
    IN  PUNICODE_STRING     DeviceName, 
    IN  PNET_PNP_EVENT      PowerEvent, 
    IN  PTDI_PNP_CONTEXT    Context1, 
    IN  PTDI_PNP_CONTEXT    Context2
    )
{
    NTSTATUS    status;

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    switch (PowerEvent->NetEvent)
    {
    case NetEventSetPower:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventSetPower");
        break;
    case NetEventQueryPower:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventQueryPower");
        break;
    case NetEventQueryRemoveDevice:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventQueryRemoveDevice");
        break;
    case NetEventCancelRemoveDevice:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventCancelRemoveDevice");
        break;
    case NetEventReconfigure:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventReconfigure");
        break;
    case NetEventBindList:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventBindList");
        break;
    case NetEventBindsComplete:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventBindsComplete");
        break;
    case NetEventPnPCapabilities:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "NetEventPnPCapabilities");
        break;
    default:
        CprDebugPrint1(NULL, DBG_TDI, DBG_INFO, "Unknown PowerEvent->NetEvent %x", PowerEvent->NetEvent);
        break;
    }

    status = STATUS_SUCCESS;

    CprDebugPrint1(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--. STATUS %x", status);

    return status;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiPnPBindingChange
//      Binding change callback
//
//  Arguments:
//      IN  PnPOpcode
//              Reason of calling this callback
//
//      IN  DeviceName
//              transport device object name
//
//      IN  MultiSZBindList
//              binding-order list
//
//
//  Return Value:
//      None
//
VOID CprTdiPnPBindingChange(
    IN  TDI_PNP_OPCODE      PnPOpcode, 
    IN  PUNICODE_STRING     DeviceName, 
    IN  PWSTR               MultiSZBindList
    )
{
    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    switch (PnPOpcode)
    {
    case TDI_PNP_OP_ADD:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_ADD");
        break;

    case TDI_PNP_OP_DEL:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_DEL");
        break;

    case TDI_PNP_OP_UPDATE:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_UPDATE");
        break;

    case TDI_PNP_OP_PROVIDERREADY:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_PROVIDERREADY");
        break;

    case TDI_PNP_OP_NETREADY:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_NETREADY");
        break;

    case TDI_PNP_OP_ADD_IGNORE_BINDING:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_ADD_IGNORE_BINDING");
        break;

    case TDI_PNP_OP_DELETE_IGNORE_BINDING:
        CprDebugPrint(NULL, DBG_TDI, DBG_INFO, "TDI_PNP_OP_DELETE_IGNORE_BINDING");
        break;

    default:
        CprDebugPrint1(NULL, DBG_TDI, DBG_INFO, "Unknown PnPOpcode %x", PnPOpcode);
        break;
    }

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--");

    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiPnPAddNetAddress
//      new transport address handler
//
//  Arguments:
//      IN  Address
//              pointer to TA_ADDRESS structure
//
//      IN  DeviceName
//              transport device object name
//
//      IN  Context
//              transport context
//
//
//  Return Value:
//      None
//
VOID CprTdiPnPAddNetAddress(
    IN  PTA_ADDRESS         Address, 
    IN  PUNICODE_STRING     DeviceName, 
    IN  PTDI_PNP_CONTEXT    Context
    )
{
    NTSTATUS        status;

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    CprTdiDumpAddress(Address);

    if (Address->AddressType == TDI_ADDRESS_TYPE_IP)
    {
/*
        // TCP server on port 2002
        if (g_Socket0 == NULL)
        {
            g_Socket0 = CprTdiCreateSocket(TCP_DEVICE_NAME);
            if (g_Socket0 != NULL)
            {
                TA_IP_ADDRESS   ipAddress;

                ipAddress.TAAddressCount = 1;                       
                ipAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                ipAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                ipAddress.Address[0].Address[0].sin_port = htons(2002);
                ipAddress.Address[0].Address[0].in_addr = 0;

                status = CprTdiOpenAddress(g_Socket0, (PTRANSPORT_ADDRESS)&ipAddress);
                if (NT_SUCCESS(status))
                {
                    CprTdiAllocateConnectSocketPool(g_Socket0, 4);

                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_CONNECT, CprTdiEventConnect, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_DISCONNECT, CprTdiEventDisconnect, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_RECEIVE, CprTdiEventReceive, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_CHAINED_RECEIVE, CprTdiEventChainedReceive, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_RECEIVE_EXPEDITED, CprTdiEventReceiveExpedited, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_CHAINED_RECEIVE_EXPEDITED, CprTdiEventChainedReceiveExpedited, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_RECEIVE_DATAGRAM, CprTdiEventReceiveDatagram, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_CHAINED_RECEIVE_DATAGRAM, CprTdiEventChainedReceiveDatagram, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_SEND_POSSIBLE, CprTdiEventSendPossible, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_ERROR, CprTdiEventError, g_Socket0);
                    CprTdiSetEventHandler(g_Socket0, TDI_EVENT_ERROR_EX, CprTdiEventErrorEx, g_Socket0);
                }
            }
        }
*/
/*        // TCP client to 127.0.0.1 port 2003
        if (g_Socket1 == NULL)
        {
            g_Socket1 = CprTdiCreateSocket(TCP_DEVICE_NAME);
            if (g_Socket1 != NULL)
            {
                TA_IP_ADDRESS   ipAddress;

                ipAddress.TAAddressCount = 1;                       
                ipAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                ipAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                ipAddress.Address[0].Address[0].sin_port = 0;
                ipAddress.Address[0].Address[0].in_addr = 0;

                status = CprTdiOpenAddress(g_Socket1, (PTRANSPORT_ADDRESS)&ipAddress);
                if (NT_SUCCESS(status))
                {
                    status = CprTdiOpenConnection(g_Socket1);
                    if (NT_SUCCESS(status))
                    {
                        status = CprTdiAssociateAddress(g_Socket1);
                        if (NT_SUCCESS(status))
                        {
                            TDI_CONNECTION_INFORMATION connectionInformation;
                            TA_IP_ADDRESS   remoteAddress;

                            remoteAddress.TAAddressCount = 1;                       
                            remoteAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                            remoteAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                            remoteAddress.Address[0].Address[0].sin_port = htons(2003);
                            remoteAddress.Address[0].Address[0].in_addr = inet_addr("127.0.0.1");

                            RtlZeroMemory(&connectionInformation, sizeof(TDI_CONNECTION_INFORMATION));

                            connectionInformation.RemoteAddress = &remoteAddress;
                            connectionInformation.RemoteAddressLength = sizeof(TA_IP_ADDRESS);

                            status = CprTdiConnect(g_Socket1, &connectionInformation, NULL);
                            if (NT_SUCCESS(status))
                            {
                                CprTdiDisconnect(g_Socket1, FALSE, NULL, NULL);
                            }
                        }
                    }
                }
            }
        }
*/
/*        // UDP sender to 127.0.0.1 port 2004
        if (g_Socket2 == NULL)
        {
            g_Socket2 = CprTdiCreateSocket(UDP_DEVICE_NAME);
            if (g_Socket2 != NULL)
            {
                TA_IP_ADDRESS   ipAddress;

                ipAddress.TAAddressCount = 1;                       
                ipAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                ipAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                ipAddress.Address[0].Address[0].sin_port = 0;
                ipAddress.Address[0].Address[0].in_addr = 0;

                status = CprTdiOpenAddress(g_Socket2, (PTRANSPORT_ADDRESS)&ipAddress);
                if (NT_SUCCESS(status))
                {
                    TDI_CONNECTION_INFORMATION connectionInformation;
                    TA_IP_ADDRESS   remoteAddress;
                    PVOID           buffer;
                    PMDL            mdl;

                    remoteAddress.TAAddressCount = 1;                       
                    remoteAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                    remoteAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                    remoteAddress.Address[0].Address[0].sin_port = htons(2004);
                    remoteAddress.Address[0].Address[0].in_addr = inet_addr("127.0.0.1");

                    RtlZeroMemory(&connectionInformation, sizeof(TDI_CONNECTION_INFORMATION));

                    connectionInformation.RemoteAddress = &remoteAddress;
                    connectionInformation.RemoteAddressLength = sizeof(TA_IP_ADDRESS);

                    buffer = ExAllocatePool(NonPagedPool, 32);
                    mdl = IoAllocateMdl(buffer, 32, FALSE, FALSE, NULL);
                    MmBuildMdlForNonPagedPool(mdl);

                    status = CprTdiSendDatagram(g_Socket2, mdl, 32, &connectionInformation, NULL);

                    IoFreeMdl(mdl);
                    ExFreePool(buffer);
                }
            }
        }
*/
/*        // UDP receive at port 2005
        if (g_Socket3 == NULL)
        {
            g_Socket3 = CprTdiCreateSocket(UDP_DEVICE_NAME);
            if (g_Socket3 != NULL)
            {
                TA_IP_ADDRESS   ipAddress;

                ipAddress.TAAddressCount = 1;                       
                ipAddress.Address[0].AddressLength = sizeof(TDI_ADDRESS_IP);
                ipAddress.Address[0].AddressType = TDI_ADDRESS_TYPE_IP;
                ipAddress.Address[0].Address[0].sin_port = htons(2005);
                ipAddress.Address[0].Address[0].in_addr = 0;

                status = CprTdiOpenAddress(g_Socket3, (PTRANSPORT_ADDRESS)&ipAddress);
                if (NT_SUCCESS(status))
                {
                    TDI_CONNECTION_INFORMATION connectionInformation;
                    TA_IP_ADDRESS   remoteAddress;
                    PVOID           buffer;
                    PMDL            mdl;

                    RtlZeroMemory(&connectionInformation, sizeof(TDI_CONNECTION_INFORMATION));

                    connectionInformation.RemoteAddress = &remoteAddress;
                    connectionInformation.RemoteAddressLength = sizeof(TA_IP_ADDRESS);

                    buffer = ExAllocatePool(NonPagedPool, 1024);
                    mdl = IoAllocateMdl(buffer, 1024, FALSE, FALSE, NULL);
                    MmBuildMdlForNonPagedPool(mdl);

                    status = CprTdiReceiveDatagram(g_Socket3, mdl, 1024, NULL, &connectionInformation);

                    IoFreeMdl(mdl);
                    ExFreePool(buffer);
                }
            }
        }
*/
    }

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--");

    return;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
//  CprTdiPnPDelNetAddress
//      deregister net address callback
//
//  Arguments:
//      IN  Address
//              pointer to TA_ADDRESS structure
//
//      IN  DeviceName
//              transport device object name
//
//      IN  Context
//              transport context
//
//
//  Return Value:
//      None
//
VOID CprTdiPnPDelNetAddress(
    IN  PTA_ADDRESS         Address, 
    IN  PUNICODE_STRING     DeviceName, 
    IN  PTDI_PNP_CONTEXT    Context
    )
{
    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"++");

    CprTdiDumpAddress(Address);

    CprDebugPrint(NULL, DBG_TDI, DBG_TRACE, __FUNCTION__"--");

    return;
}