AampCurlStore.cpp

Go to the documentation of this file.

/*
 * If not stated otherwise in this file or this component's license file the
 * following copyright and licenses apply:
 *
 * Copyright 2022 RDK Management
 *
 * 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.
*/
 
/**
 * @file AampCurlStore.cpp
 * @brief Advanced Adaptive Media Player (AAMP) Curl store
 */
 
#include "AampCurlStore.h"
#include "AampDefine.h"
 
#define CURL_EASY_SETOPT(curl, CURLoption, option)\
        if (curl_easy_setopt(curl, CURLoption, option) != 0) {\
                        logprintf("Failed at curl_easy_setopt ");\
        }  //CID:132698,135078 - checked return
 
// Curl callback functions
static pthread_mutex_t gCurlShMutex = PTHREAD_MUTEX_INITIALIZER;
/**
 * @brief
 * @param curl ptr to CURL instance
 * @param data curl data lock
 * @param acess curl access lock
 * @param user_ptr CurlCallbackContext pointer
 * @retval void
 */
static void curl_lock_callback(CURL *curl, curl_lock_data data, curl_lock_access access, void *user_ptr)
{
        pthread_mutex_t *pCurlShareLock = NULL;
        CurlDataShareLock *locks =(CurlDataShareLock *)user_ptr;
 
        (void)access; /* unused */
        (void)curl; /* unused */
 
        if(locks)
        {
                switch ( data )
                {
                        case CURL_LOCK_DATA_DNS:
                        pCurlShareLock = &(locks->mDnsCurlShareMutex);
                        break;
                        case CURL_LOCK_DATA_SSL_SESSION:
                        pCurlShareLock = &(locks->mSslCurlShareMutex);
                        break;
 
                        default:
                        pCurlShareLock = &(locks->mCurlSharedlock);
                        break;
                }
 
                pthread_mutex_lock(pCurlShareLock);
        }
        else
        {
                pthread_mutex_lock(&gCurlShMutex);
        }
}
 
/**
 * @brief
 * @param curl ptr to CURL instance
 * @param data curl data lock
 * @param acess curl access lock
 * @param user_ptr CurlCallbackContext pointer
 * @retval void
 */
static void curl_unlock_callback(CURL *curl, curl_lock_data data, void *user_ptr)
{
        pthread_mutex_t *pCurlShareLock = NULL;
        CurlDataShareLock *locks =(CurlDataShareLock *)user_ptr;
 
        (void)curl; /* unused */
 
        if(locks)
        {
                switch ( data )
                {
                        case CURL_LOCK_DATA_DNS:
                        pCurlShareLock = &(locks->mDnsCurlShareMutex);
                        break;
                        case CURL_LOCK_DATA_SSL_SESSION:
                        pCurlShareLock = &(locks->mSslCurlShareMutex);
                        break;
 
                        default:
                        pCurlShareLock = &(locks->mCurlSharedlock);
                        break;
                }
 
                pthread_mutex_unlock(pCurlShareLock);
        }
        else
        {
                pthread_mutex_unlock(&gCurlShMutex);
        }
}
 
/**
 * @brief write callback to be used by CURL
 * @param ptr pointer to buffer containing the data
 * @param size size of the buffer
 * @param nmemb number of bytes
 * @param userdata CurlCallbackContext pointer
 * @retval size consumed or 0 if interrupted
 */
static size_t write_callback(char *ptr, size_t size, size_t nmemb, void *userdata)
{
        size_t ret = 0;
        CurlCallbackContext *context = (CurlCallbackContext *)userdata;
        if(context)
        {
                ret = context->aamp->HandleSSLWriteCallback( ptr, size, nmemb, userdata);
        }
        return ret;
}
 
/**
 * @brief callback invoked on http header by curl
 * @param ptr pointer to buffer containing the data
 * @param size size of the buffer
 * @param nmemb number of bytes
 * @param user_data  CurlCallbackContext pointer
 * @retval
 */
static size_t header_callback(const char *ptr, size_t size, size_t nmemb, void *user_data)
{
        size_t ret = 0;
        CurlCallbackContext *context = static_cast<CurlCallbackContext *>(user_data);
        if(context)
        {
                ret = context->aamp->HandleSSLHeaderCallback(ptr, size, nmemb, user_data);
        }
        return ret;
}
 
/**
 * @brief
 * @param clientp app-specific as optionally set with CURLOPT_PROGRESSDATA
 * @param dltotal total bytes expected to download
 * @param dlnow downloaded bytes so far
 * @param ultotal total bytes expected to upload
 * @param ulnow uploaded bytes so far
 * @retval
 */
static int progress_callback(
        void *clientp, // app-specific as optionally set with CURLOPT_PROGRESSDATA
        double dltotal, // total bytes expected to download
        double dlnow, // downloaded bytes so far
        double ultotal, // total bytes expected to upload
        double ulnow // uploaded bytes so far
        )
{
        int ret = 0;
        CurlProgressCbContext *context = (CurlProgressCbContext *)clientp;
 
        if(context)
        {
                ret = context->aamp->HandleSSLProgressCallback ( clientp, dltotal, dlnow, ultotal, ulnow );
        }
        return ret;
}
 
/**
 * @brief
 * @param curl ptr to CURL instance
 * @param ssl_ctx SSL context used by CURL
 * @param user_ptr data pointer set as param to CURLOPT_SSL_CTX_DATA
 * @retval CURLcode CURLE_OK if no errors, otherwise corresponding CURL code
 */
CURLcode ssl_callback(CURL *curl, void *ssl_ctx, void *user_ptr)
{
        PrivateInstanceAAMP *context = (PrivateInstanceAAMP *)user_ptr;
        AAMPLOG_TRACE("priv aamp :%p", context);
        CURLcode rc = CURLE_OK;
        pthread_mutex_lock(&context->mLock);
        if (!context->mDownloadsEnabled)
        {
                rc = CURLE_ABORTED_BY_CALLBACK ; // CURLE_ABORTED_BY_CALLBACK
        }
        pthread_mutex_unlock(&context->mLock);
        return rc;
}
 
/**
 * @brief
 * @param handle ptr to CURL instance
 * @param type type of data passed in the callback
 * @param data data pointer, NOT null terminated
 * @param size size of the data
 * @param userp user pointer set with CURLOPT_DEBUGDATA
 * @retval return 0
 */
static int eas_curl_debug_callback(CURL *handle, curl_infotype type, char *data, size_t size, void *userp)
{
        (void)handle;
        (void)userp;
        if(type == CURLINFO_TEXT || type == CURLINFO_HEADER_IN)
        {
                //limit log spam to only TEXT and HEADER_IN
                size_t len = size;
                while( len>0 && data[len-1]<' ' ) len--;
                std::string printable(data,len);
                switch (type)
                {
                case CURLINFO_TEXT:
                        AAMPLOG_WARN("curl: %s", printable.c_str() );
                        break;
                case CURLINFO_HEADER_IN:
                        AAMPLOG_WARN("curl header: %s", printable.c_str() );
                        break;
                default:
                        break; //CID:94999 - Resolve deadcode
                }
        }
        return 0;
}
 
/**
 * @fn CreateCurlStore
 * @brief CreateCurlStore - Create a new curl store for given host
 */
CurlSocketStoreStruct *CurlStore::CreateCurlStore ( const std::string &hostname )
{
        CurlSocketStoreStruct *CurlSock = new curlstorestruct();
        CurlDataShareLock *locks = new curldatasharelock();
        if ( NULL == CurlSock || NULL == locks )
        {
                AAMPLOG_WARN("Failed to alloc memory for curl store");
                return NULL;
        }
 
        CurlSock->timestamp = aamp_GetCurrentTimeMS();
        CurlSock->pstShareLocks = locks;
        CurlSock->mCurlStoreUserCount += 1;
 
        CURLSHcode sh;
        CurlSock->mCurlShared = curl_share_init();
        sh = curl_share_setopt(CurlSock->mCurlShared, CURLSHOPT_USERDATA, (void*)locks);
        sh = curl_share_setopt(CurlSock->mCurlShared, CURLSHOPT_LOCKFUNC, curl_lock_callback);
        sh = curl_share_setopt(CurlSock->mCurlShared, CURLSHOPT_UNLOCKFUNC, curl_unlock_callback);
        sh = curl_share_setopt(CurlSock->mCurlShared, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
        sh = curl_share_setopt(CurlSock->mCurlShared, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
 
        if ( umCurlSockDataStore.size() >= MaxCurlSockStore )
        {
                // Remove not recently used handle.
                RemoveCurlSock();
        }
 
        umCurlSockDataStore[hostname]=CurlSock;
        AAMPLOG_INFO("Curl store for %s created, Added shared ctx %p in curlstore %p, size:%lu maxsize:%d", hostname.c_str(),
                                        CurlSock->mCurlShared, CurlSock, umCurlSockDataStore.size(), MaxCurlSockStore);
        return CurlSock;
}
 
/**
 * @fn GetCurlHandle
 * @brief GetCurlHandle - Get a free curl easy handle for given url & curl index
 */
CURL* CurlStore::GetCurlHandle(void *pAamp,std::string url, AampCurlInstance startIdx )
{
        CURL * curl = NULL;
        assert (startIdx <= eCURLINSTANCE_MAX);
 
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)pAamp;
        std::string HostName;
        HostName = aamp_getHostFromURL ( url );
 
        if (ISCONFIGSET(eAAMPConfig_EnableCurlStore) && !( aamp_IsLocalHost(HostName) ))
        {
                GetFromCurlStore ( HostName, startIdx, &curl );
        }
        else
        {
                curl = curl_easy_init();
        }
 
        return curl;
}
 
/**
 * @fn SaveCurlHandle
 * @brief SaveCurlHandle - Save a curl easy handle for given host & curl index
 */
void CurlStore::SaveCurlHandle (void *pAamp, std::string url, AampCurlInstance startIdx, CURL *curl )
{
        assert (startIdx <= eCURLINSTANCE_MAX);
 
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)pAamp;
        std::string HostName;
        HostName = aamp_getHostFromURL ( url );
 
        if (ISCONFIGSET(eAAMPConfig_EnableCurlStore) && !( aamp_IsLocalHost(HostName) ))
        {
                KeepInCurlStore ( HostName, startIdx, curl );
        }
        else
        {
                curl_easy_cleanup(curl);
        }
}
 
/**
 * @fn CurlEasyInitWithOpt
 * @brief CurlEasyInitWithOpt - Create a curl easy handle with set of aamp opts
 */
CURL* CurlStore::CurlEasyInitWithOpt ( void *privContext, const std::string &proxyName, int instId )
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)privContext;
        std::string UserAgentString;
        UserAgentString=aamp->mConfig->GetUserAgentString();
 
        CURL *curlEasyhdl = curl_easy_init();
        if (ISCONFIGSET(eAAMPConfig_CurlLogging))
        {
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_VERBOSE, 1L);
        }
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_NOSIGNAL, 1L);
        //curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback); // unused
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_PROGRESSFUNCTION, progress_callback);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_HEADERFUNCTION, header_callback);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_WRITEFUNCTION, write_callback);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_TIMEOUT, DEFAULT_CURL_TIMEOUT);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_CONNECTTIMEOUT, DEFAULT_CURL_CONNECTTIMEOUT);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_WHATEVER);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_FOLLOWLOCATION, 1L);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_NOPROGRESS, 0L); // enable progress meter (off by default)
 
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_USERAGENT, UserAgentString.c_str());
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_ACCEPT_ENCODING, "");//Enable all the encoding formats supported by client
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_SSL_CTX_FUNCTION, ssl_callback); //Check for downloads disabled in btw ssl handshake
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_SSL_CTX_DATA, aamp);
        long dns_cache_timeout = 3*60;
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_DNS_CACHE_TIMEOUT, dns_cache_timeout);
        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_SHARE, aamp->mCurlShared);
        //CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_TCP_KEEPALIVE, 1 );
 
        aamp->curlDLTimeout[instId] = DEFAULT_CURL_TIMEOUT * 1000;
 
        if (!proxyName.empty())
        {
                /* use this proxy */
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_PROXY, proxyName.c_str());
                /* allow whatever auth the proxy speaks */
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_PROXYAUTH, CURLAUTH_ANY);
        }
 
        if(aamp->IsEASContent())
        {
                //enable verbose logs so we can debug field issues
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_VERBOSE, 1);
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_DEBUGFUNCTION, eas_curl_debug_callback);
                //set eas specific timeouts to handle faster cycling through bad hosts and faster total timeout
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_TIMEOUT, EAS_CURL_TIMEOUT);
                CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_CONNECTTIMEOUT, EAS_CURL_CONNECTTIMEOUT);
 
                aamp->curlDLTimeout[instId] = EAS_CURL_TIMEOUT * 1000;
 
                //on ipv6 box force curl to use ipv6 mode only (DELIA-20209)
                struct stat tmpStat;
                bool isv6(::stat( "/tmp/estb_ipv6", &tmpStat) == 0);
                if(isv6)
                {
                        CURL_EASY_SETOPT(curlEasyhdl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V6);
                }
                AAMPLOG_WARN("aamp eas curl config: timeout=%ld, connecttimeout%ld, ipv6=%d", EAS_CURL_TIMEOUT, EAS_CURL_CONNECTTIMEOUT, isv6);
        }
        //log_current_time("curl initialized");
 
        return curlEasyhdl;
}
 
/**
 * @fn CurlInit
 * @brief CurlInit - Initialize or get easy handles for given host & curl index from curl store
 */
void CurlStore::CurlInit(void *privContext, AampCurlInstance startIdx, unsigned int instanceCount, std::string proxyName, const std::string &RemoteHost)
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)privContext;
 
        int instanceEnd = startIdx + instanceCount;
        assert (instanceEnd <= eCURLINSTANCE_MAX);
 
        std::string HostName;
        bool IsRemotehost = true, CurlFdHost=false;
        AampCurlStoreErrorCode CurlStoreErrCode=eCURL_STORE_HOST_NOT_AVAILABLE;
 
        if(RemoteHost.size())
        {
                HostName = RemoteHost;
                CurlFdHost = true;
        }
        else
        {
                HostName = aamp->mOrigManifestUrl.hostname;
                IsRemotehost = aamp->mOrigManifestUrl.isRemotehost;
        }
 
        if ( IsRemotehost )
        {
                if (ISCONFIGSET(eAAMPConfig_EnableCurlStore))
                {
                        AAMPLOG_INFO("Check curl store for host:%s inst:%d-%d Fds[%p:%p]\n", HostName.c_str(), startIdx, instanceEnd, aamp->curl[startIdx], aamp->curlhost[startIdx]->curl );
                        CurlStoreErrCode = GetFromCurlStoreBulk(HostName, startIdx, instanceEnd, aamp, CurlFdHost );
                        AAMPLOG_TRACE("From curl store for inst:%d-%d Fds[%p:%p] ShHdl:%p\n", startIdx, instanceEnd, aamp->curl[startIdx], aamp->curlhost[startIdx]->curl, aamp->mCurlShared );
                }
                else
                {
                        if(NULL==aamp->mCurlShared)
                        {
                                aamp->mCurlShared = curl_share_init();
                                curl_share_setopt(aamp->mCurlShared, CURLSHOPT_USERDATA, (void*)NULL);
                                curl_share_setopt(aamp->mCurlShared, CURLSHOPT_LOCKFUNC, curl_lock_callback);
                                curl_share_setopt(aamp->mCurlShared, CURLSHOPT_UNLOCKFUNC, curl_unlock_callback);
                                curl_share_setopt(aamp->mCurlShared, CURLSHOPT_SHARE, CURL_LOCK_DATA_DNS);
 
                                if (ISCONFIGSET(eAAMPConfig_EnableSharedSSLSession))
                                {
                                        curl_share_setopt(aamp->mCurlShared, CURLSHOPT_SHARE, CURL_LOCK_DATA_SSL_SESSION);
                                }
                        }
                }
        }
 
        if(eCURL_STORE_HOST_SOCK_AVAILABLE != CurlStoreErrCode)
        {
                CURL **CurlFd = NULL;
                for (unsigned int i = startIdx; i < instanceEnd; i++)
                {
                        if(CurlFdHost)
                        {
                                CurlFd = &aamp->curlhost[i]->curl;
                        }
                        else
                        {
                                CurlFd = &aamp->curl[i];
                        }
 
                        if (NULL == *CurlFd )
                        {
                                *CurlFd = CurlEasyInitWithOpt(aamp, proxyName, i);
                                AAMPLOG_INFO("Created new curl handle:%p for inst:%d", *CurlFd, i );
                        }
                }
        }
}
 
/**
 * @fn CurlTerm
 * @brief CurlTerm - Terminate or store easy handles in curlstore
 */
void CurlStore::CurlTerm(void *privContext, AampCurlInstance startIdx, unsigned int instanceCount, const std::string &RemoteHost )
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)privContext;
        int instanceEnd = startIdx + instanceCount;
        std::string HostName;
        bool IsRemotehost = true, CurlFdHost=false;
 
        if(RemoteHost.size())
        {
                HostName = RemoteHost;
                CurlFdHost = true;
        }
        else
        {
                HostName = aamp->mOrigManifestUrl.hostname;
                IsRemotehost = aamp->mOrigManifestUrl.isRemotehost;
        }
 
        if( ISCONFIGSET(eAAMPConfig_EnableCurlStore)  && ( IsRemotehost ))
        {
                AAMPLOG_INFO("Store unused curl handle:%p in Curlstore for inst:%d-%d", aamp->curl[startIdx], startIdx, instanceEnd );
                KeepInCurlStoreBulk ( HostName, startIdx, instanceEnd, aamp, CurlFdHost);
                ShowCurlStoreData(ISCONFIGSET(eAAMPConfig_TraceLogging));
        }
        else
        {
                for (unsigned int i = startIdx; i < instanceEnd; i++)
                {
                        if (aamp->curl[i])
                        {
                                curl_easy_cleanup(aamp->curl[i]);
                                aamp->curl[i] = NULL;
                                aamp->curlDLTimeout[i] = 0;
                        }
                }
        }
}
 
CurlStore* CurlStore::CurlInstance = NULL;
pthread_mutex_t CurlStore::mCurlInstLock = PTHREAD_MUTEX_INITIALIZER;
int CurlStore::MaxCurlSockStore=MAX_CURL_SOCK_STORE;
 
/**
 * @fn GetCurlStoreInstance
 * @brief GetCurlStoreInstance - Get static curlstore singleton object
 */
CurlStore *CurlStore::GetCurlStoreInstance ( void *pContext )
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP *)pContext;
 
        pthread_mutex_lock(&mCurlInstLock);
        if ( NULL == CurlInstance )
        {
                int MaxSockStoreSize=0;
                CurlInstance = new CurlStore();
 
                if ( NULL == CurlInstance )
                {
                        AAMPLOG_WARN("Failed to alloc mem for Curl instance");
                        return NULL;
                }
 
                GETCONFIGVALUE(eAAMPConfig_MaxCurlSockStore,MaxSockStoreSize);
                if( MAX_CURL_SOCK_STORE != MaxSockStoreSize)
                {
                        MaxCurlSockStore = MaxSockStoreSize;
                }
                AAMPLOG_INFO("Max sock store size:%d", MaxCurlSockStore);
        }
        pthread_mutex_unlock(&mCurlInstLock);
        return CurlInstance;
}
 
/**
 * @fn GetCurlHandleFromFreeQ
 * @brief GetCurlHandleFromFreeQ - Get curl handle from free queue
 */
CURL *CurlStore::GetCurlHandleFromFreeQ ( CurlSocketStoreStruct *CurlSock, int instId )
{
        CURL *curlhdl = NULL;
        long long MaxAge = CurlSock->timestamp-eCURL_MAX_AGE_TIME;
 
        for (int i = instId; i < instId+1 && !CurlSock->mFreeQ.empty(); )
        {
                CurlHandleStruct mObj = CurlSock->mFreeQ.front();
 
                if( MaxAge > mObj.eHdlTimestamp )
                {
                        CurlSock->mFreeQ.pop_front();
                        AAMPLOG_TRACE("Remove old curl hdl:%p", mObj.curl);
                        curl_easy_cleanup(mObj.curl);
                        mObj.curl = NULL;
                        continue;
                }
 
                if ( mObj.curlId == i )
                {
                        CurlSock->mFreeQ.pop_front();
                        curlhdl = mObj.curl;
                        break;
                }
 
                for(auto it=CurlSock->mFreeQ.begin()+1; it!=CurlSock->mFreeQ.end(); ++it)
                {
                        if (( MaxAge < it->eHdlTimestamp ) && ( it->curlId == i ))
                        {
                                curlhdl=it->curl;
                                CurlSock->mFreeQ.erase(it);
                                break;
                        }
                }
 
                ++i;
        }
 
        return curlhdl;
}
 
/**
 * @fn GetFromCurlStoreBulk
 * @brief GetFromCurlStoreBulk - Get free curl easy handle in bulk for given host & curl indices
 */
AampCurlStoreErrorCode CurlStore::GetFromCurlStoreBulk ( const std::string &hostname, AampCurlInstance CurlIndex, int count, void *priv, bool CurlFdHost )
{
        PrivateInstanceAAMP *aamp = (PrivateInstanceAAMP*)priv;
        AampCurlStoreErrorCode ret = eCURL_STORE_HOST_SOCK_AVAILABLE;
 
        pthread_mutex_lock(&mCurlInstLock);
        CurlSockDataIter it = umCurlSockDataStore.find(hostname);
 
        if (it != umCurlSockDataStore.end())
        {
                int CurlFdCount=0,loop=0;
                CURL **CurlFd=NULL;
                CurlSocketStoreStruct *CurlSock = it->second;
                CurlSock->mCurlStoreUserCount += 1;
                CurlSock->timestamp = aamp_GetCurrentTimeMS();
                aamp->mCurlShared = CurlSock->mCurlShared;
 
                for( loop = (int)CurlIndex; loop < count; )
                {
                        if(CurlFdHost)
                        {
                                CurlFd=&aamp->curlhost[loop]->curl;
                        }
                        else
                        {
                                CurlFd=&aamp->curl[loop];
                        }
 
                        if (!CurlSock->mFreeQ.empty())
                        {
                                *CurlFd= GetCurlHandleFromFreeQ ( CurlSock, loop );
                                if(NULL!=*CurlFd)
                                {
                                        CURL_EASY_SETOPT(*CurlFd, CURLOPT_SSL_CTX_DATA, aamp);
                                        ++CurlFdCount;
                                }
                                else
                                {
                                        ret = eCURL_STORE_SOCK_NOT_AVAILABLE;
                                }
                                ++loop;
                        }
                        else
                        {
                                AAMPLOG_TRACE("Queue is empty");
                                ret = eCURL_STORE_SOCK_NOT_AVAILABLE;
                                break;
                        }
                }
 
                AAMPLOG_INFO ("%d fd(s) got from CurlStore User count:%d", CurlFdCount, CurlSock->mCurlStoreUserCount);
 
                if ( umCurlSockDataStore.size() > MaxCurlSockStore )
                {
                        // Remove not recently used handle.
                        RemoveCurlSock();
                }
        }
        else
        {
                AAMPLOG_TRACE("Curl Inst %d for %s not in store", CurlIndex, hostname.c_str());
                ret = eCURL_STORE_HOST_NOT_AVAILABLE;
 
                CurlSocketStoreStruct *CurlSock = CreateCurlStore(hostname);
 
                if(NULL != CurlSock)
                {
                        aamp->mCurlShared = CurlSock->mCurlShared;
                }
        }
 
        pthread_mutex_unlock(&mCurlInstLock);
        return ret;
}
 
/**
 * @fn GetFromCurlStore
 * @brief GetFromCurlStore - Get a free curl easy handle for given host & curl index
 */
AampCurlStoreErrorCode CurlStore::GetFromCurlStore ( const std::string &hostname, AampCurlInstance CurlIndex, CURL **curl )
{
        AampCurlStoreErrorCode ret = eCURL_STORE_HOST_SOCK_AVAILABLE;
        CurlSocketStoreStruct *CurlSock = NULL;
        *curl = NULL;
 
        pthread_mutex_lock(&mCurlInstLock);
        CurlSockDataIter it = umCurlSockDataStore.find(hostname);
 
        if (it != umCurlSockDataStore.end())
        {
                CurlSock = it->second;
                CurlSock->mCurlStoreUserCount += 1;
                CurlSock->timestamp = aamp_GetCurrentTimeMS();
                long long MaxAge = CurlSock->timestamp-eCURL_MAX_AGE_TIME;
 
                for( int loop = (int)CurlIndex; loop < CurlIndex+1; )
                {
                        if (!CurlSock->mFreeQ.empty())
                        {
                                *curl = GetCurlHandleFromFreeQ ( CurlSock, loop);
 
                                if(NULL==*curl)
                                {
                                        ret = eCURL_STORE_SOCK_NOT_AVAILABLE;
                                }
                                ++loop;
                        }
                        else
                        {
                                AAMPLOG_TRACE("Queue is empty");
                                ret = eCURL_STORE_SOCK_NOT_AVAILABLE;
                                break;
                        }
                }
        }
 
        if ( NULL == *curl )
        {
                AAMPLOG_TRACE("Curl Inst %d for %s not available", CurlIndex, hostname.c_str());
 
                if(NULL == CurlSock)
                {
                        ret = eCURL_STORE_HOST_NOT_AVAILABLE;
 
                        CurlSock = CreateCurlStore(hostname);
                }
 
                *curl = curl_easy_init();
                CURL_EASY_SETOPT(*curl, CURLOPT_SHARE, CurlSock->mCurlShared);
        }
 
        pthread_mutex_unlock(&mCurlInstLock);
        return ret;
}
 
/**
 * @fn KeepInCurlStoreBulk
 * @brief KeepInCurlStoreBulk - Store curl easy handle in bulk for given host & curl index
 */
void CurlStore::KeepInCurlStoreBulk ( const std::string &hostname, AampCurlInstance CurlIndex, int count, void *priv, bool CurlFdHost )
{
        PrivateInstanceAAMP *aamp =  (PrivateInstanceAAMP*)priv;
        CurlSocketStoreStruct *CurlSock = NULL;
 
        pthread_mutex_lock(&mCurlInstLock);
        CurlSockDataIter it = umCurlSockDataStore.find(hostname);
 
        if(it != umCurlSockDataStore.end())
        {
                CurlSock = it->second;
                CurlSock->timestamp = aamp_GetCurrentTimeMS();
                CurlSock->mCurlStoreUserCount -= 1;
 
                for( int loop = (int)CurlIndex; loop < count; ++loop)
                {
                        CurlHandleStruct mObj;
                        if(CurlFdHost)
                        {
                                mObj.curl = aamp->curlhost[loop]->curl;
                                aamp->curlhost[loop]->curl = NULL;
                        }
                        else
                        {
                                mObj.curl = aamp->curl[loop];
                                aamp->curl[loop] = NULL;
                        }
 
                        mObj.eHdlTimestamp = CurlSock->timestamp;
                        mObj.curlId = loop;
                        CurlSock->mFreeQ.push_back(mObj);
                        AAMPLOG_TRACE("Curl Inst %d CurlCtx:%p stored at %lu", loop, mObj.curl, CurlSock->mFreeQ.size());
                }
 
                AAMPLOG_TRACE ("CurlStore User count:%d for:%s", CurlSock->mCurlStoreUserCount, hostname.c_str());
                if ( umCurlSockDataStore.size() > MaxCurlSockStore )
                {
                        // Remove not recently used handle.
                        RemoveCurlSock();
                }
        }
        else
        {
                AAMPLOG_INFO("Host %s not in store, Curl Inst %d-%d", hostname.c_str(), CurlIndex,count);
        }
 
        pthread_mutex_unlock(&mCurlInstLock);
}
 
/**
 * @fn KeepInCurlStore
 * @brief KeepInCurlStore - Store a curl easy handle for given host & curl index
 */
void CurlStore::KeepInCurlStore ( const std::string &hostname, AampCurlInstance CurlIndex, CURL *curl )
{
        CurlSocketStoreStruct *CurlSock = NULL;
        pthread_mutex_lock(&mCurlInstLock);
        CurlSockDataIter it = umCurlSockDataStore.find(hostname);
        if(it != umCurlSockDataStore.end())
        {
                CurlSock = it->second;
                CurlSock->timestamp = aamp_GetCurrentTimeMS();
                CurlSock->mCurlStoreUserCount -= 1;
 
                CurlHandleStruct mObj;
                mObj.curl = curl;
                mObj.eHdlTimestamp = CurlSock->timestamp;
                mObj.curlId = (int)CurlIndex;
                CurlSock->mFreeQ.push_back(mObj);
                AAMPLOG_TRACE("Curl Inst %d for %s CurlCtx:%p stored at %lu, User:%d", CurlIndex, hostname.c_str(),
                                                curl,CurlSock->mFreeQ.size(), CurlSock->mCurlStoreUserCount);
        }
        else
        {
                AAMPLOG_INFO("Host %s not in store, Curlfd:%p", hostname.c_str(), curl);
        }
        pthread_mutex_unlock(&mCurlInstLock);
}
 
/**
 * @fn RemoveCurlSock
 * @brief RemoveCurlSock - Remove not recently used entry from curl store
 */
void CurlStore::RemoveCurlSock ( void )
{
        unsigned long long time=aamp_GetCurrentTimeMS() + 1;
 
        CurlSockDataIter it=umCurlSockDataStore.begin();
        CurlSockDataIter RemIt=umCurlSockDataStore.end();
 
        for(; it != umCurlSockDataStore.end(); ++it )
        {
                CurlSocketStoreStruct *CurlSock = it->second;
                if( !CurlSock->mCurlStoreUserCount && ( time > CurlSock->timestamp ) )
                {
                        time = CurlSock->timestamp;
                        RemIt = it;
                }
        }
 
        if( umCurlSockDataStore.end() != RemIt )
        {
                CurlSocketStoreStruct *RmCurlSock = RemIt->second;
                AAMPLOG_INFO("Removing host:%s lastused:%lld UserCount:%d", (RemIt->first).c_str(), RmCurlSock->timestamp, RmCurlSock->mCurlStoreUserCount);
 
                for(auto it = RmCurlSock->mFreeQ.begin(); it != RmCurlSock->mFreeQ.end(); )
                {
                        if(it->curl)
                        {
                                curl_easy_cleanup(it->curl);
                        }
                        it=RmCurlSock->mFreeQ.erase(it);
                }
                std::deque<CurlHandleStruct>().swap(RmCurlSock->mFreeQ);
 
                if(RmCurlSock->mCurlShared)
                {
                        CurlDataShareLock *locks = RmCurlSock->pstShareLocks;
                        curl_share_cleanup(RmCurlSock->mCurlShared);
 
                        pthread_mutex_destroy(&locks->mCurlSharedlock);
                        pthread_mutex_destroy(&locks->mDnsCurlShareMutex);
                        pthread_mutex_destroy(&locks->mSslCurlShareMutex);
                        SAFE_DELETE(RmCurlSock->pstShareLocks);
                }
 
                SAFE_DELETE(RmCurlSock);
                umCurlSockDataStore.erase(RemIt);
 
                ShowCurlStoreData();
        }
        else
        {
                /**
                 * Lets extend the size of curlstore, since all entries are busy..
                 * Later it will get shrunk to user configured size.
                 */
        }
}
 
/**
 * @fn ShowCurlStoreData
 * @brief ShowCurlStoreData - Print curl store details
 */
void CurlStore::ShowCurlStoreData ( bool trace )
{
        if(trace)
        {
                AAMPLOG_INFO("Curl Store Size:%lu, MaxSize:%d", umCurlSockDataStore.size(), MaxCurlSockStore);
 
                CurlSockDataIter it=umCurlSockDataStore.begin();
                for(int loop=1; it != umCurlSockDataStore.end(); ++it,++loop )
                {
                        CurlSocketStoreStruct *CurlSock = it->second;
                        AAMPLOG_INFO("%d.Host:%s ShHdl:%p LastUsed:%lld UserCount:%d", loop, (it->first).c_str(), CurlSock->mCurlShared, CurlSock->timestamp, CurlSock->mCurlStoreUserCount);
                        AAMPLOG_INFO("%d.Total Curl fds:%lu,", loop, CurlSock->mFreeQ.size());
 
                        for(auto it = CurlSock->mFreeQ.begin(); it != CurlSock->mFreeQ.end(); ++it)
                        {
                                AAMPLOG_TRACE("CurlFd:%p Time:%lld Inst:%d", it->curl, it->eHdlTimestamp, it->curlId);
                        }
                }
        }
}