/* ------------------------------------------------------------------
 * Copyright (C) 2008 PacketVideo
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
 * express or implied.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 * -------------------------------------------------------------------
 */
#ifndef PVMF_SOCKET_NODE_H_INCLUDED
#define PVMF_SOCKET_NODE_H_INCLUDED

#ifndef OSCL_BASE_H_INCLUDED
#include "oscl_base.h"
#endif
#ifndef OSCLCONFIG_IO_H_INCLUDED
#include "osclconfig_io.h"
#endif
#ifndef OSCL_FILE_IO_H_INCLUDED
#include "oscl_file_io.h"
#endif
#ifndef OSCL_PRIQUEUE_H_INCLUDED
#include "oscl_priqueue.h"
#endif
#ifndef OSCL_SCHEDULER_AO_H_INCLUDED
#include "oscl_scheduler_ao.h"
#endif
#ifndef OSCL_SOCKET_TYPES_H_INCLUDED
#include "oscl_socket_types.h"
#endif
#ifndef OSCL_SOCKET_H_INCLUDED
#include "oscl_socket.h"
#endif
#ifndef OSCL_DNS_H_INCLUDED
#include "oscl_dns.h"
#endif
#include "oscl_tickcount.h"
#include "oscl_mem_mempool.h"

#ifndef PVMF_FORMAT_TYPE_H_INCLUDED
#include "pvmf_format_type.h"
#endif
#ifndef PVMF_SIMPLE_MEDIA_BUFFER_H_INCLUDED
#include "pvmf_simple_media_buffer.h"
#endif
#ifndef PVMF_MEDIA_DATA_H_INCLUDED
#include "pvmf_media_data.h"
#endif
#ifndef PVMF_NODE_INTERFACE_H_INCLUDED
#include "pvmf_node_interface.h"
#endif

#ifndef PVMI_DATA_STREAM_INTERFACE_H_INCLUDED
#include "pvmi_data_stream_interface.h"
#endif

#include "pvmf_node_utils.h"
#include "pvmf_socket_port.h"

#ifndef PVMF_SOCKET_NODE_EXTENSION_INTERFACE_H_INCLUDED
#include "pvmf_socket_node_extension_interface.h"
#endif

#ifndef PVMF_SM_TUNABLES_H_INCLUDED
#include "pvmf_sm_tunables.h"
#endif

#include "pvmf_socket_node_events.h"
#include "pvmf_media_frag_group.h"

//Enable socket node stats unless this is a release build.
#include "osclconfig.h"
#if(OSCL_RELEASE_BUILD)
#define ENABLE_SOCKET_NODE_STATS 0
#else
#define ENABLE_SOCKET_NODE_STATS 1
#endif

//Logger macros
#define PVMF_SOCKETNODE_LOGSTACKTRACE(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_STACK_TRACE,m);
#define PVMF_SOCKETNODE_LOGINFO(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_INFO,m);
#define PVMF_SOCKETNODE_LOGERROR(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_ERR,m);
#define PVMF_SOCKETNODE_LOGWARNING(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iLogger,PVLOGMSG_WARNING,m);
#define PVMF_SOCKETNODE_LOGDATATRAFFIC_I(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iDataPathLogger,PVLOGMSG_INFO,m);
#define PVMF_SOCKETNODE_LOGDATATRAFFIC_E(m) PVLOGGER_LOGMSG(PVLOGMSG_INST_REL,iDataPathLogger,PVLOGMSG_ERR,m);

//memory allocator type for this node.
typedef OsclMemAllocator PVMFSocketNodeAllocator;

//Node command type.
typedef PVMFGenericNodeCommand<PVMFSocketNodeAllocator> PVMFSocketNodeCommandBase;
class PVMFSocketNodeCommand: public PVMFSocketNodeCommandBase
{
    public:

};

//Default vector reserve size
#define PVMF_SOCKET_NODE_COMMAND_VECTOR_RESERVE 10

//Starting value for command IDs
#define PVMF_SOCKET_NODE_COMMAND_ID_START 6000

class PVLogger;
class PVMFSocketPort;

/**
 * Mem pool class
 */
class PVMFSocketNodeMemPool
{
    public:
        PVMFSocketNodeMemPool(uint32 aMemPoolNumBufs = DEFAULT_NUM_MEDIA_MSGS_IN_JITTER_BUFFER);

        virtual ~PVMFSocketNodeMemPool()
        {
            if (iMediaDataMemPool != NULL)
            {
                iMediaDataMemPool->removeRef();
                iMediaDataMemPool = NULL;
            }
        };

        OsclSharedPtr<PVMFMediaDataImpl> getMediaDataImpl(uint32 size)
        {
            return (iSocketAllocSharedPtr->createSharedBuffer(size));
        }

        void resizeSocketDataBuffer(OsclSharedPtr<PVMFMediaDataImpl>& aSharedBuffer)
        {
            if (iSocketAllocSharedPtr.GetRep() != NULL)
            {
                iSocketAllocSharedPtr->ResizeMemoryFragment(aSharedBuffer);
            }
        }

        void notifyfreechunkavailable(OsclMemPoolFixedChunkAllocatorObserver& aObserver,
                                      uint32 aSize,
                                      OsclAny* aContextData = NULL)
        {
            if (iSocketAllocSharedPtr.GetRep() != NULL)
            {
                iSocketAllocSharedPtr->notifyfreechunkavailable(aObserver, aSize, aContextData);
            }
        }

        void CancelFreeChunkAvailableCallback()
        {
            if (iSocketAllocSharedPtr.GetRep() != NULL)
            {
                iSocketAllocSharedPtr->CancelFreeChunkAvailableCallback();
            }
        }

        OsclSharedPtr<PVMFSharedSocketDataBufferAlloc> iSocketAllocSharedPtr;

        // Memory pool for media data objects
        OsclMemPoolFixedChunkAllocator* iMediaDataMemPool;

        int32 iPortTag;

        // Allocator created in this node, for TCP only.
        // (For UDP, the JB node owns the allocator and passes
        // it in during the call to setSocketPortMemAllocator)
        PVMFSMSharedBufferAllocWithReSize* iInternalAlloc;

        // Allocator for multiple receives, for UDP only.
        PVMFMediaFragGroupCombinedAlloc<PVMFSocketNodeAllocator>* iMediaFragGroupAlloc;
        OsclMemPoolFixedChunkAllocator* iMediaFragGroupAllocMempool;
};

/*
** Socket address structure
*/

enum PROTOCOL
{
    INVALID_PROTOCOL,
    INET_TCP,
    INET_UDP
};

struct SOCKET_ADDR
{
    PROTOCOL iProtocol;

    OsclNetworkAddress iLocalAdd;
    OsclNetworkAddress iRemoteAdd;

    OSCL_HeapString<PVMFSocketNodeAllocator> iRemoteHost;	//could be either DNS or ip address

    //each socket maps to a port, hence a port tag is needed for unique identification
    int32 iTag;
};

class PVMFSocketNode;

/*
** Socket activity class is used to save Oscl socket or DNS results
*/
class PVMFSocketActivity
{
    public:
        PVMFSocketActivity(): iValid(false)
        {
        }
        PVMFSocketActivity(PVMFStatus aStatus, int32 aId, int32 aFxn, int32 aEvent, int32 aError)
        {
            Set(aStatus, aId, aFxn, aEvent, aError);
        }
        void Set(PVMFStatus aStatus, int32 aId, int32 aFxn, int32 aEvent, int32 aError)
        {
            iValid = true;
            iStatus = aStatus;
            iId = aId;
            iFxn = aFxn;
            iEvent = aEvent;
            iError = aError;
        }
        bool iValid;
        PVMFStatus iStatus;
        int32 iId;
        int32 iFxn;
        int32 iEvent;
        int32 iError;

    private:

};


/*
** The Socket port state keeps track of the Connect, Receive, and Send operations on
** a port, including wait states.  Note there may be simultaneous send & receive on
** a port, so it is necessary to keep separate status.  Connect operations cannot
** be concurrent with either send or receive operations, but for simplicity, the
** connect status is also maintained separately.
**
** The port state also contains information about sequences of operations.
*/

//Individual asynchronous operations and wait states that make up a connect or
//disconnect sequence.
enum TPVSocketPortConnectOperation
{
    EPVSocketPortConnectOperation_None
    , EPVSocketPortConnectOperation_GetHostByName
    , EPVSocketPortConnectOperation_Connect
    , EPVSocketPortConnectOperation_Shutdown
    , EPVSocketPortConnectOperation_WaitOnConnectedPort //for sending EOS during disconnect.
    , EPVSocketPortConnectOperation_WaitOnSendRecvIdle //for shutdown & cleanup.
    , EPVSocketPortConnectOperation_Last
};

//Individual asynchronous operations and wait states that make up a send sequence.
enum TPVSocketPortSendOperation
{
    EPVSocketPortSendOperation_None
    , EPVSocketPortSendOperation_Send
    , EPVSocketPortSendOperation_SendTo
    , EPVSocketPortSendOperation_Last
};

//Individual asynchronous operations and wait states that make up a receive sequence.
enum TPVSocketPortRecvOperation
{
    EPVSocketPortRecvOperation_None
    , EPVSocketPortRecvOperation_Recv
    , EPVSocketPortRecvOperation_RecvFrom
    , EPVSocketPortRecvOperation_WaitOnConnectedPort
    , EPVSocketPortRecvOperation_WaitOnMemory
    , EPVSocketPortRecvOperation_Last
};

//Sequences that may require multiple asynchronous operations
//and/or wait states.  There can only be one of these sequences active
//on a port at a time. For definitions of the operations that make
//up these sequences, please see the comments in the StartSequence
//implementation.
enum TPVSocketPortSequence
{
    EPVSocketPortSequence_None
    , EPVSocketPortSequence_RequestPort
    , EPVSocketPortSequence_InputConnectMsg
    , EPVSocketPortSequence_InputDataMsg
    , EPVSocketPortSequence_InputDisconnectMsg
    , EPVSocketPortSequence_SocketCleanup
    , EPVSocketPortSequence_Last
};

class SocketNodePortStats;

class SocketPortState
{
    public:
        SocketPortState(): iSequence(EPVSocketPortSequence_None)
                , iSequenceStatus(PVMFSuccess)
                , iConnectOperation(EPVSocketPortConnectOperation_None)
                , iConnectOperationStatus(PVMFSuccess)
                , iConnectOperationCanceled(false)
                , iSendOperation(EPVSocketPortSendOperation_None)
                , iSendOperationStatus(PVMFSuccess)
                , iSendOperationCanceled(false)
                , iRecvOperation(EPVSocketPortRecvOperation_None)
                , iRecvOperationStatus(PVMFSuccess)
                , iRecvOperationCanceled(false)
        {}

        TPVSocketPortSequence iSequence;
        PVMFStatus iSequenceStatus;

        TPVSocketPortConnectOperation iConnectOperation;
        PVMFStatus iConnectOperationStatus;
        bool iConnectOperationCanceled;

        TPVSocketPortSendOperation iSendOperation;
        PVMFStatus iSendOperationStatus;
        bool iSendOperationCanceled;

        TPVSocketPortRecvOperation iRecvOperation;
        PVMFStatus iRecvOperationStatus;
        bool iRecvOperationCanceled;
};

#if(ENABLE_SOCKET_NODE_STATS)
/*
** SocketNodeStats and SocketNodePortStats are used for tracking performance
** of socket node.
*/

//SocketNodePortStats contains all data that is maintained on a per-port basis.
class SocketNodePortStats
{
    public:
        SocketNodePortStats()
        {
            oscl_memset(this, 0, sizeof(SocketNodePortStats));
        }
        //port events.
        uint32 iNumPortEventConnectedPortReady;
        uint32 iNumPortEventConnect;
        uint32 iNumPortEventIncomingMsg;

        //incoming messages
        uint32 iNumDequeueIncomingConnectMsg;
        uint32 iNumDequeueIncomingDisconnectMsg;
        uint32 iNumDequeueIncomingDataMsg;

        //outgoing messages
        uint32 iNumQueueOutgoingUDPMsg;
        uint32 iNumQueueOutgoingTCPMsg;
        uint32 iNumQueueOutgoingEOSMsg;

        //socket receive results that had to be queued while
        //waiting on connected port
        uint32 iNumQueueSocketRecv;

        //number of times wait states were entered.
        uint32 iNumWaitOnMemory;
        uint32 iNumWaitOnConnectedPort;
        uint32 iNumWaitOnSendRecvIdle;

        //memory pool callbacks.
        uint32 iNumFreeChunkCallback;

        //Oscl socket & OScl DNS callbacks
        uint32 iNumSocketCallback;
        uint32 iNumDNSCallback;

        //number of Oscl socket and Oscl DNS calls.
        uint32 iNumSend;
        uint32 iNumSendTo;
        uint32 iNumRecv;
        uint32 iNumRecvFrom;
        uint32 iNumRecvFromPackets;
        uint32 iMaxRecvFromPackets;
        uint32 iNumGetHostByName;
        uint32 iNumConnect;
        uint32 iNumShutdown;

        //Latency times through this node.
        uint32 iMaxConnectOperationTime[EPVSocketPortConnectOperation_Last];
        uint32 iMaxSendOperationTime[EPVSocketPortSendOperation_Last];
        uint32 iMaxRecvOperationTime[EPVSocketPortRecvOperation_Last];

        uint32 iConnectOperationTime[EPVSocketPortConnectOperation_Last];
        uint32 iSendOperationTime[EPVSocketPortSendOperation_Last];
        uint32 iRecvOperationTime[EPVSocketPortRecvOperation_Last];

        void StartConnectTime(TPVSocketPortConnectOperation aOp)
        {
            iConnectOperationTime[aOp] = OsclTickCount::TicksToMsec(OsclTickCount::TickCount());
        }
        void EndConnectTime(TPVSocketPortConnectOperation aOp)
        {
            uint32 delta = OsclTickCount::TicksToMsec(OsclTickCount::TickCount()) - iConnectOperationTime[aOp];
            if (delta > iMaxConnectOperationTime[aOp])
                iMaxConnectOperationTime[aOp] = delta;
        }
        void StartRecvTime(TPVSocketPortRecvOperation aOp)
        {
            iRecvOperationTime[aOp] = OsclTickCount::TicksToMsec(OsclTickCount::TickCount());
        }
        void EndRecvTime(TPVSocketPortRecvOperation aOp)
        {
            uint32 delta = OsclTickCount::TicksToMsec(OsclTickCount::TickCount()) - iRecvOperationTime[aOp];
            if (delta > iMaxRecvOperationTime[aOp])
                iMaxRecvOperationTime[aOp] = delta;
        }
        void StartSendTime(TPVSocketPortSendOperation aOp)
        {
            iSendOperationTime[aOp] = OsclTickCount::TicksToMsec(OsclTickCount::TickCount());
        }
        void EndSendTime(TPVSocketPortSendOperation aOp)
        {
            uint32 delta = OsclTickCount::TicksToMsec(OsclTickCount::TickCount()) - iSendOperationTime[aOp];
            if (delta > iMaxSendOperationTime[aOp])
                iMaxSendOperationTime[aOp] = delta;
        }
        void Log(PVLogger* iLogger, OSCL_String& aMime)
        {
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats:PORT '%s'", aMime.get_cstr()));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num PortEventConnectedPortReady", iNumPortEventConnectedPortReady));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num PortEventConnect", iNumPortEventConnect));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num PortEventIncomingMsg", iNumPortEventIncomingMsg));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num DequeueIncomingConnectMsg", iNumDequeueIncomingConnectMsg));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num DequeueIncomingDisconnectMsg", iNumDequeueIncomingDisconnectMsg));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num DequeueIncomingDataMsg", iNumDequeueIncomingDataMsg));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num QueueOutgoingUDPMsg", iNumQueueOutgoingUDPMsg));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num QueueOutgoingTCPMsg", iNumQueueOutgoingTCPMsg));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num QueueOutgoingEOSMsg", iNumQueueOutgoingEOSMsg));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num QueueSocketRecv", iNumQueueSocketRecv));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num WaitOnMemory", iNumWaitOnMemory));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num WaitOnConnectedPort", iNumWaitOnConnectedPort));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num WaitOnSendRecvIdle", iNumWaitOnSendRecvIdle));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num FreeChunkCallback", iNumFreeChunkCallback));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num SocketCallback", iNumSocketCallback));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num DNSCallback", iNumDNSCallback));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num Send", iNumSend));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num SendTo", iNumSendTo));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num Recv", iNumRecv));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num RecvFrom", iNumRecvFrom));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num RecvFrom Packets", iNumRecvFromPackets));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max RecvFrom Packets", iMaxRecvFromPackets));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num GetHostByName", iNumGetHostByName));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num Connect", iNumConnect));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Num Shutdown", iNumShutdown));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Connect GetHostByName Time (msec)", iMaxConnectOperationTime[EPVSocketPortConnectOperation_GetHostByName]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Connect Time (msec)", iMaxConnectOperationTime[EPVSocketPortConnectOperation_Connect]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Connect Shutdown Time (msec)", iMaxConnectOperationTime[EPVSocketPortConnectOperation_Shutdown]));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Send Time (msec)", iMaxSendOperationTime[EPVSocketPortSendOperation_Send]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max SendTo Time (msec)", iMaxSendOperationTime[EPVSocketPortSendOperation_SendTo]));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Recv Time (msec)", iMaxRecvOperationTime[EPVSocketPortRecvOperation_Recv]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max RecvFrom Time (msec)", iMaxRecvOperationTime[EPVSocketPortRecvOperation_RecvFrom]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Recv Wait On Connected Port Time (msec)", iMaxRecvOperationTime[EPVSocketPortRecvOperation_WaitOnConnectedPort]));
            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats: %8d Max Recv Wait On Memory Time (msec)", iMaxRecvOperationTime[EPVSocketPortRecvOperation_WaitOnMemory]));

            PVLOGGER_LOGMSG(PVLOGMSG_INST_PROF, iLogger, PVLOGMSG_ERR,
                            (0, "SocketNodeStats:@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@"));
        }
};

//SocketNodeStats contains all data that is maintained on a per-node basis.
class SocketNodeStats
{
    public:
        SocketNodeStats()
        {
            oscl_memset(this, 0, sizeof(SocketNodeStats));
        }

        PVLogger* iLogger;
        bool iLogged;
        void Init()
        {
            iLogged = false;
            iLogger = PVLogger::GetLoggerObject("pvplayerdiagnostics.socketnode");
        }
        void Logoff()
        {
            iLogger = NULL;
        }

        //Run calls
        uint32 iNumRun;

        //Node cmds.
        uint32 iNumQueueNodeCmd;

        //Number of UDP bind operations.
        uint32 iNumBind;

        void Log(PVMFPortVector<PVMFSocketPort, PVMFSocketNodeAllocator>& aPortVec);
};
#endif

/*
** SocketPortConfig contains all the information associated with a port including
** the Oscl socket, memory pool, and status.
*/
class SocketPortConfig : public OsclMemPoolFixedChunkAllocatorObserver
{
    public:
        SocketPortConfig()
        {
            iPVMFPort = NULL;
            iSockId = 0;
            iUDPSocket = NULL;
            iTCPSocket = NULL;
            iDNS = NULL;
            iMemPool	= NULL;
            iContainer = NULL;
            iTag = PVMF_SOCKET_NODE_PORT_TYPE_UNKNOWN;
            iRTP = false;
        };

        void DoSetSocketPortMemAllocator(PVLogger*, OsclSharedPtr<PVMFSharedSocketDataBufferAlloc> aAlloc);
        void CleanupMemPools();

        void freechunkavailable(OsclAny* aContextData);

        SocketPortState iState;

        PVMFSocketPort *iPVMFPort;
        SOCKET_ADDR	iAddr;
        uint32	iSockId;
        OsclUDPSocket* iUDPSocket;
        OsclTCPSocket* iTCPSocket;
        OsclDNS *iDNS;
        OsclNetworkAddress iSourceAddr;//arg for recv from calls.
        Oscl_Vector<uint32, OsclMemAllocator> iRecvFromPacketLen;//arg for recv from calls.

        //socket pending request and state
        PVMFSharedMediaDataPtr iPendingRecvMediaData, iPendingSendMediaData;

        //Fixed chunk memory pool for media messages
        PVMFSocketNodeMemPool *iMemPool;

        PVMFSocketNode* iContainer;
        int32 iTag;

        PVMFSocketActivity iSocketRecvActivity;

        OSCL_HeapString<OsclMemAllocator> iMime;
        bool iRTP;

#if(ENABLE_SOCKET_NODE_STATS)
        SocketNodePortStats iPortStats;
#endif
};

/*
** DnsCache is used to cache DNS lookup results to avoid unnecessary lookups of a previously
** used host.
*/
class PVMFDnsCache
{
    public:
        PVMFDnsCache(uint32 aNumOfRecords = 4): iNumOfRecords(aNumOfRecords), iAddrIP(NULL), iAddrDNS(NULL)
        {
        };
        ~PVMFDnsCache()
        {
            for (uint32 i = 0; i < iNumOfRecords; i++)
            {
                if (iAddrDNS)
                {
                    if (NULL != iAddrDNS[i])
                    {
                        OSCL_ARRAY_DELETE(iAddrDNS[i]);
                        iAddrDNS[i] = NULL;
                    }
                }
                if (iAddrIP)
                {
                    if (NULL != iAddrIP[i])
                    {
                        OSCL_ARRAY_DELETE(iAddrIP[i]);
                        iAddrIP[i] = NULL;
                    }
                }
            }
            OSCL_ARRAY_DELETE(iAddrIP);
            OSCL_ARRAY_DELETE(iAddrDNS);
        }
        void NewL(void)
        {
            iAddrIP = OSCL_ARRAY_NEW(char*, iNumOfRecords);
            iAddrDNS = OSCL_ARRAY_NEW(char*, iNumOfRecords);
            if ((NULL == iAddrIP) || (NULL == iAddrIP))
            {
                OSCL_ARRAY_DELETE(iAddrIP);
                OSCL_ARRAY_DELETE(iAddrDNS);
                OSCL_LEAVE(OsclErrNoMemory);
            }
            for (uint32 i = 0; i < iNumOfRecords; i++)
                iAddrDNS[i] = iAddrIP[i] = NULL;
        };

        //if name is not in record, add one; if it does, update it
        bool UpdateCacheRecord(char *name, char *ipAddr)
        {
            for (uint32 i = 0; i < iNumOfRecords; i++)
            {
                if (NULL == iAddrDNS[i])
                {//new record
                    int32 tmpLen = oscl_strlen(name);
                    iAddrDNS[i] = OSCL_ARRAY_NEW(char, tmpLen + 4);
                    oscl_strncpy(iAddrDNS[i], name, tmpLen + 2);
                    iAddrIP[i] = OSCL_ARRAY_NEW(char, 32);
                    oscl_strncpy(iAddrIP[i], ipAddr, 30);
                    return true;
                }
                if (0 == oscl_strcmp(iAddrDNS[i], name))
                {//update record
                    if (oscl_strlen(ipAddr) + 1 > 32)
                    {
                        return false;
                    }
                    oscl_strncpy(iAddrIP[i], ipAddr, 30);
                    return true;
                }
            }
            return false;
        }
        //find the ip address corresponds to name. len is the size of ipAddr bufferr
        bool QueryGetHostByName(const char *name, char *ipAddr, const uint32 len)
        {
            for (uint32 i = 0; i < iNumOfRecords; i++)
            {
                if (NULL == iAddrDNS[i])
                    return false;
                if (0 == oscl_strcmp(iAddrDNS[i], name))
                {
                    if (oscl_strlen(iAddrIP[i]) + 1 > len)
                    {
                        return false;
                    }
                    oscl_strncpy(ipAddr, iAddrIP[i], 30);
                    return true;
                }
            }
            return false;
        }
    private:
        uint32 iNumOfRecords;
        char** iAddrIP;
        char** iAddrDNS;
};

/*
** Memory pool sizes.
*/
#define SIMPLE_MEDIA_BUF_CLASS_SIZE 128 /*oscl_mem_aligned_size(sizeof(PVMFSimpleMediaBuffer) + oscl_mem_aligned_size(sizeof(OsclRefCounterSA<SimpleMediaBufferCombinedCleanupSA>)*/
#define MEDIA_DATA_CLASS_SIZE 128 /*oscl_mem_aligned_size(sizeof(PVMFMediaData)) + oscl_mem_aligned_size(sizeof(OsclRefCounterDA)) + oscl_mem_aligned_size(sizeof(MediaDataCleanupDA)) + sizeof(PVMFMediaMsgHeader))*/

/*
** The Socket Node
*/
class PVMFSocketNode
            : public PVMFNodeInterface
            , public OsclActiveObject
            , public OsclSocketObserver
            , public OsclDNSObserver
            , public PVMFSocketNodeExtensionInterface
{
    public:

        OSCL_IMPORT_REF PVMFSocketNode(int32 aPriority);
        OSCL_IMPORT_REF ~PVMFSocketNode();


        //**********begin PVMFSocketNodeExtensionInterface
        OSCL_IMPORT_REF void addRef();
        OSCL_IMPORT_REF void removeRef();
        OSCL_IMPORT_REF bool queryInterface(const PVUuid& uuid, PVInterface*& iface);
        OSCL_IMPORT_REF PVMFStatus AllocateConsecutivePorts(PvmfMimeString* aPortConfig,
                uint32& aLowerPortNum,
                uint32& aHigherPortNum, uint32& aStartPortNum);
        OSCL_IMPORT_REF PVMFStatus SetMaxTCPRecvBufferSize(uint32 aBufferSize);
        OSCL_IMPORT_REF PVMFStatus GetMaxTCPRecvBufferSize(uint32& aSize);
        OSCL_IMPORT_REF PVMFStatus SetMaxTCPRecvBufferCount(uint32 aBufferSize);
        OSCL_IMPORT_REF PVMFStatus GetMaxTCPRecvBufferCount(uint32& aSize);

        //**********end PVMFSocketNodeExtensionInterface

        //************ begin OsclSocketObserver
        OSCL_IMPORT_REF void HandleSocketEvent(int32 aId, TPVSocketFxn aFxn, TPVSocketEvent aEvent, int32 aError);
        //************ end OsclSocketObserver

        //************ begin OsclDNSObserver
        OSCL_IMPORT_REF void HandleDNSEvent(int32 aId, TPVDNSFxn aFxn, TPVDNSEvent aEvent, int32 aError);
        //************ end OsclDNSObserver

        //from PVMFNodeInterface
        OSCL_IMPORT_REF PVMFStatus ThreadLogon();
        OSCL_IMPORT_REF PVMFStatus ThreadLogoff();
        OSCL_IMPORT_REF PVMFStatus GetCapability(PVMFNodeCapability& aNodeCapability);
        OSCL_IMPORT_REF PVMFPortIter* GetPorts(const PVMFPortFilter* aFilter = NULL);
        OSCL_IMPORT_REF PVMFCommandId QueryUUID(PVMFSessionId, const PvmfMimeString& aMimeType,
                                                Oscl_Vector<PVUuid, PVMFSocketNodeAllocator>& aUuids,
                                                bool aExactUuidsOnly = false,
                                                const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId QueryInterface(PVMFSessionId, const PVUuid& aUuid,
                PVInterface*& aInterfacePtr,
                const OsclAny* aContext = NULL);

        OSCL_IMPORT_REF PVMFCommandId RequestPort(PVMFSessionId aSession
                , int32 aPortTag
                , const PvmfMimeString* aPortConfig = NULL
                                                      , const OsclAny* aContext = NULL);

        OSCL_IMPORT_REF PVMFCommandId ReleasePort(PVMFSessionId, PVMFPortInterface& aPort, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Init(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Prepare(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Start(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Stop(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Flush(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Pause(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId Reset(PVMFSessionId, const OsclAny* aContext = NULL);
        OSCL_IMPORT_REF PVMFCommandId CancelAllCommands(PVMFSessionId, const OsclAny* aContextData = NULL);
        OSCL_IMPORT_REF PVMFCommandId CancelCommand(PVMFSessionId, PVMFCommandId aCmdId, const OsclAny* aContextData = NULL);

        //from PVMFPortActivityHandler
        void HandlePortActivity(const PVMFPortActivity& aActivity);

        //These are some extra APIs that are used by Streaming Manager and are unique to socket node.
        OSCL_IMPORT_REF bool GetPortConfig(PVMFPortInterface &aPort, OsclNetworkAddress &aLocalAdd, OsclNetworkAddress &aRemoteAdd);
        OSCL_IMPORT_REF bool SetPortConfig(PVMFPortInterface &aPort, OsclNetworkAddress aLocalAdd, OsclNetworkAddress aRemoteAdd);

        OSCL_IMPORT_REF bool setSocketPortMemAllocator(PVMFPortInterface* aPort,
                OsclSharedPtr<PVMFSharedSocketDataBufferAlloc> aAlloc);


    private:
        friend class SocketPortConfig;

        //from OsclActiveObject
        void Run();

        /*********************************************
        * Socket extension interface
        **********************************************/

        // Reference counter for extension
        uint32 iExtensionRefCount;

        /*********************************************
        * Command Processing and Event Notification
        **********************************************/

        //Command queue type
        typedef PVMFNodeCommandQueue<PVMFSocketNodeCommand, PVMFSocketNodeAllocator> PVMFSocketNodeCmdQ;

        PVMFSocketNodeCmdQ iPendingCmdQueue;
        PVMFSocketNodeCmdQ iCurrentCmdQueue;
        PVMFSocketNodeCmdQ iCancelCmdQueue;

        void MoveCmdToCancelQueue(PVMFSocketNodeCommand& aCmd);

        void CommandComplete(PVMFSocketNodeCmdQ&,
                             PVMFSocketNodeCommand&,
                             PVMFStatus,
                             OsclAny* aData = NULL,
                             PVUuid* aEventUUID = NULL,
                             int32* aEventCode = NULL);

        void ReportErrorEvent(PVMFEventType aEventType,
                              OsclAny* aEventData = NULL,
                              PVUuid* aEventUUID = NULL,
                              int32* aEventCode = NULL);

        void ReportInfoEvent(PVMFEventType aEventType,
                             OsclAny* aEventData = NULL,
                             PVUuid* aEventUUID = NULL,
                             int32* aEventCode = NULL);

        PVMFCommandId QueueCommandL(PVMFSocketNodeCommand& aCmd);

        bool CanProcessCommand();
        void ProcessCommand(PVMFSocketNodeCmdQ& aCmdQ, PVMFSocketNodeCommand&);

        //Command handlers.
        PVMFStatus DoRequestPort(PVMFSocketNodeCommand& aCmd, PVMFSocketPort* &port);
        PVMFStatus DoReset(PVMFSocketNodeCommand&);
        PVMFStatus DoQueryUuid(PVMFSocketNodeCommand&);
        PVMFStatus DoQueryInterface(PVMFSocketNodeCommand&);
        PVMFStatus DoReleasePort(PVMFSocketNodeCommand&);
        PVMFStatus DoInit(PVMFSocketNodeCommand&);
        PVMFStatus DoPrepare(PVMFSocketNodeCommand&);
        PVMFStatus DoStart(PVMFSocketNodeCommand&);
        PVMFStatus DoStop(PVMFSocketNodeCommand&);
        PVMFStatus DoFlush(PVMFSocketNodeCommand&);
        PVMFStatus DoPause(PVMFSocketNodeCommand&);
        PVMFStatus DoCancelAllCommands(PVMFSocketNodeCommand&);
        PVMFStatus DoCancelCommand(PVMFSocketNodeCommand&);

        PVMFStatus DoCancelCurrentCommand(PVMFSocketNodeCmdQ& aCmdQ, PVMFSocketNodeCommand& aCmd);
        PVMFStatus DoStopNodeActivity();
        PVMFSocketPort* iRequestedPort;

        //node state
        void ChangeExternalState(TPVMFNodeInterfaceState aNewState)
        {
            iInterfaceState = aNewState;
        }

        //node capability
        PVMFNodeCapability iCapability;

        //for error messages.
        int32 iCommandErrorCode;
        int32 iErrorEventErrorCode;
        void ReportSocketNodeError(PVMFStatus aStatus, PVMFSocketNodeErrorEventType aEvent)
        {
            PVUuid eventuuid = PVMFSocketNodeEventTypeUUID;
            iErrorEventErrorCode = aEvent;
            ReportErrorEvent(aStatus, NULL, &eventuuid, &iErrorEventErrorCode);
        }

        //Used to stop all port activity, this var counts down from N to 0, or
        //has a value of (-1) to indicate it's inactive
        int32 iNumStopPortActivityPending;

        /*********************************************
        * Oscl Socket Handling
        **********************************************/

        void HandleRecvComplete(SocketPortConfig& tmpSockConfig, PVMFStatus, PVMFSocketActivity*);
        void HandleRecvFromComplete(SocketPortConfig& tmpSockConfig, PVMFStatus, PVMFSocketActivity*);

        OsclSocketServ	*iSockServ;

        const int TIMEOUT_CONNECT;
        const int TIMEOUT_SEND;
        const int TIMEOUT_SENDTO;
        const int TIMEOUT_RECV;
        const int TIMEOUT_RECVFROM;
        const int TIMEOUT_SHUTDOWN;
        const int UDP_PORT_RANGE;
        const int MAX_UDP_PACKET_SIZE;

        int32 iMaxTcpRecvBufferSize;
        int32 iMaxTcpRecvBufferCount;

        /*********************************************
        * Oscl DNS Handling
        **********************************************/

        PVMFDnsCache	iDnsCache;

        /*********************************************
        * Port Data Handling
        **********************************************/

        bool CanProcessIncomingMsg(SocketPortConfig& aSockConfig);

        void ProcessIncomingMsg(SocketPortConfig& aSockConfig);

        bool ParseTransportConfig(OSCL_String *aPortConfig,
                                  SOCKET_ADDR &aSockConfig,
                                  OSCL_String& aMime);
        bool ParseTransportConfig(char *aPortConfig,
                                  int32 aLen,
                                  SOCKET_ADDR &aSockConfig,
                                  OSCL_String& aMime);

        /*********************************************
        * Port & Socket Creation
        **********************************************/

        PVMFStatus AllocatePortMemPool(int32 tag, PVMFSocketNodeMemPool* & aMemPool);
        PVMFStatus AddPort(int32 tag, PVMFSocketPort* &port);
        void CleanupTCP(SocketPortConfig& tmpSockConfig);
        void CleanupUDP(SocketPortConfig& tmpSockConfig);
        void CleanupDNS(SocketPortConfig& tmpSockConfig);
        void CleanupPorts();

        OsclAny* CreateOsclSocketAndBind(SOCKET_ADDR &, uint32);

        uint32 iSocketID;
        bool iInSocketCallback;

        Oscl_Vector<OsclTCPSocket*, OsclMemAllocator> iClosedTCPSocketVector;
        void CleanupClosedTCPSockets();
        Oscl_Vector<OsclUDPSocket*, OsclMemAllocator> iClosedUDPSocketVector;
        void CleanupClosedUDPSockets();
        Oscl_Vector<OsclDNS*, OsclMemAllocator> iClosedDNSVector;
        void CleanupClosedDNS();

        /*********************************************
        * Port Data
        **********************************************/

        PVMFPortVector<PVMFSocketPort, PVMFSocketNodeAllocator> iPortVector;
        Oscl_Vector<SocketPortConfig*, PVMFSocketNodeAllocator> iAllocatedPortVector;

        SocketPortConfig* FindSocketPortConfig(SOCKET_ADDR& aSockConfig);
        bool MatchSocketAddr(SOCKET_ADDR& aSockAddr, SocketPortConfig& aSockConfig);
        SocketPortConfig* FindSocketPortConfig(uint32 aId);

        /*********************************************
        * Operation and Sequence Handlers
        **********************************************/

        PVMFStatus StartSequence(SocketPortConfig&, TPVSocketPortSequence, OsclAny* param = NULL);
        void SequenceComplete(SocketPortConfig& tmpSockConfig, PVMFStatus);

        bool CanReceive(SocketPortConfig& aConfig);

        PVMFStatus StartConnectOperation(SocketPortConfig& aSockConfig, TPVSocketPortConnectOperation aOperation);
        PVMFStatus StartRecvOperation(SocketPortConfig& aSockConfig);
        PVMFStatus StartSendOperation(SocketPortConfig& aSockConfig, PVMFSharedMediaMsgPtr& aMsg);
        void StartRecvWaitOnMemory(SocketPortConfig& aSockConfig, int32 aSize = 0);
        void StartRecvWaitOnConnectedPort(SocketPortConfig& aSockConfig, PVMFSocketActivity& aSocketActivity);

        PVMFStatus ConnectOperationComplete(SocketPortConfig& tmpSockConfig, PVMFStatus, PVMFSocketActivity*);
        PVMFStatus SendOperationComplete(SocketPortConfig& tmpSockConfig, PVMFStatus, PVMFSocketActivity*);
        PVMFStatus RecvOperationComplete(SocketPortConfig& tmpSockConfig, PVMFStatus, PVMFSocketActivity*);

        PVMFStatus CancelSendOperation(SocketPortConfig& tmpSockConfig);
        PVMFStatus CancelRecvOperation(SocketPortConfig& tmpSockConfig);
        PVMFStatus CancelConnectOperation(SocketPortConfig& tmpSockConfig);

        /*********************************************
        * Loggers, Error Trap, Allocator
        **********************************************/

        PVLogger *iLogger;
        PVLogger *iDataPathLogger;

        void LogRTPHeaderFields(SocketPortConfig& aSockConfig,
                                OsclRefCounterMemFrag& memFragIn);

        OsclErrorTrapImp* iOsclErrorTrapImp;

        PVMFSocketNodeAllocator iAlloc;

#if(ENABLE_SOCKET_NODE_STATS)
        SocketNodeStats iSocketNodeStats;
#endif
};

#endif //PVMF_SOCKET_NODE_H_INCLUDED