#include "CookieArray.h"

#include "CookieClientDataArray.h"

#include "CookieClientData.h"

    CCookieClientDataArray::GetInstance()->Ref();

// RCookieManager::DoGetCookies

// RCookieManager::GetCookieSharableFlagFromServer

// ---------------------------------------------------------

//

TInt RCookieManager::GetCookieSharableFlagFromServer(TBool& aCookieSharableFlag )const

    {

    TPckg<TBool> cookieSharableFlag(aCookieSharableFlag);

    return SendReceive( EGetCookieSharableFlag, TIpcArgs( &cookieSharableFlag ) );

    }

// ---------------------------------------------------------

// RCookieManager::DoGetCookieSize

									  TPckg<TInt>& aPkgSize,TDesC& aAppuidPtr ) const

    return SendReceive( EGetCookieSize, TIpcArgs( &aAppuidPtr,aRequestUri.Length(), 

// ---------------------------------------------------------

// RCookieManager::DestroyCookiesFromMemory

// ---------------------------------------------------------

//

TInt RCookieManager::DestroyCookiesFromMemory( TInt& aDeleteStatus )

    {

    CLOG(( EClient, 0, _L("-> RCookieManager::DestroyCookies") ));

    TPckg<TInt> pkgStatus( aDeleteStatus );

    TInt ret = SendReceive( EDestroyCookies, TIpcArgs( &pkgStatus ) ) ;

    CLOG(( EClient, 0, 

        _L("<- RCookieManager::DestroyCookies cleared %d cookies, errcode%d"),

        aDeleteStatus, ret ) );

    return ret;

    }

								   const TDesC8& aUri,TDesC& aAppUidPtr ) const

                                      &aPackedCookie, &aUri,&aAppUidPtr ) );

    TBool cookiefound(EFalse);

    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();

    if(cookieclientdataarray) // redundant check

        {

    TInt clientarraycount = cookieclientdataarray->Count();

    if ( clientarraycount!=0 )

        {

        TInt clerr = GetClientSideCookies(aUri,aCookies,cookiefound,0);

        }

      } 

    if(!cookiefound)

        {

	//Appuid value only takes 8 chars

    HBufC* appbuf = HBufC::New(8);

    TPtr ptr(appbuf->Des());

    TUint32 appUid(0);

    ptr.AppendNum(appUid,EHex);    

	User::LeaveIfError( DoGetCookieSize( aUri, pkgSize,ptr ) );

    delete appbuf;

      }

			//Appuid value only takes 8 chars

            HBufC* appbuf = HBufC::New(8); // harendra: 8 chars needed

            TPtr ptr(appbuf->Des());

            TUint32 appUid(0);

            ptr.AppendNum(appUid,EHex);    

            err = DoStoreCookie( *buf, aUri.UriDes(),ptr );

            delete appbuf;

			//err = DoStoreCookie( *buf, aUri.UriDes() );

// RCookieManager::SetAppUidL This method is no longer being 

// used in CookieFilter.As this method is exported so in order

// to provide backward compatibilty this API implementation is changed 

    TUint32 groupid = RProcess().SecureId().iId;

    CCookieClientData* cookieclientdata = CCookieClientDataArray::GetInstance()->Find(groupid, const_cast<TUint32&> (aAppUid));

    if(cookieclientdata)

        {

        cookieclientdata->SetWidgetUid(aAppUid);

        }

    else

        {

        TBool cookieSharableFlag(EFalse);

        TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);

        CCookieClientData* cookieclientdata = CCookieClientData::NewL(groupid, aAppUid, cookieSharableFlag,ETrue);

        cookieclientdata->SetInitFlag(ETrue);

        CCookieClientDataArray::GetInstance()->AddClientGroupDataL(cookieclientdata);

        }

    //Appuid value only takes 8 chars

    HBufC* buf = HBufC::NewLC(8);

// ---------------------------------------------------------

// RCookieManager::Close

// ---------------------------------------------------------

//

EXPORT_C void RCookieManager::Close()

    {

    CLOG(( EClient, 0, _L("-> RCookieManager::Close") ));

    CCookieClientDataArray::GetInstance()->DeRef();

    TInt deletestatus =0;

    DestroyCookiesFromMemory(deletestatus);

    CLOG(( EClient, 0, _L("-> RCookieManager::Close deletestatus = %d"), deletestatus ));

    RSessionBase::Close();

    CLOG(( EClient, 0, _L("<- RCookieManager::Close") ));

    }

// ---------------------------------------------------------

// RCookieManager::StoreCookie Newly Added

// ---------------------------------------------------------

//

EXPORT_C TInt RCookieManager::StoreCookie( const CCookie& aCookie,

                                 const TUriC8& aUri,TUint32& aAppUid )

    {

    CLOG( ( EClient, 0, _L( "-> RCookieManager::StoreCookie" ) ) );

    StoreCookieAtClientSide(&aCookie,aUri.UriDes(),aAppUid);

    TInt err;

    TInt cookieSize = aCookie.Size( EFalse );

    HBufC8* buf = HBufC8::New( cookieSize );

    if ( buf )

        {

        CLOG( ( EClient, 0,

                _L( "RCookieManager::StoreCookie, cookie size:%d" ), 

                cookieSize ) );

        TPtr8 bufDes( buf->Des() );

        err = iCookiePacker.CliPackCookie( bufDes, aCookie );

        if ( !err )

            {

            //Appuid value only takes 8 chars

            HBufC* appbuf = HBufC::New(8);

            TPtr ptr(appbuf->Des());

            ptr.AppendNum(aAppUid,EHex);    

            err = DoStoreCookie( *buf, aUri.UriDes(),ptr );

            delete appbuf;

            }

        delete buf;

        }

    else

        {

        err = KErrNoMemory;

        }

    CLOG( ( EClient, 0,

            _L( "<- RCookieManager::StoreCookie errcode%d" ), err ) );

    return err;

    }

// ---------------------------------------------------------

// RCookieManager::GetCookiesL Newly Added

// ---------------------------------------------------------

//

EXPORT_C void RCookieManager::GetCookiesL( const TDesC8& aUri,

                                        RPointerArray<CCookie>& aCookies,

                                        TBool& aCookie2Reqd,TUint32& aAppUid )

    {

    CLOG( ( EClient, 0, _L( "-> RCookieManager::GetCookiesL" ) ) );

    TBool cookiefound(EFalse);

    CCookieClientDataArray* cookieclientdataarray = CCookieClientDataArray::GetInstance();

    if(cookieclientdataarray)

        {

         TInt clientarraycount = cookieclientdataarray->Count();

         if (clientarraycount == 0)

           {

            TUint32 groupid = RProcess().SecureId().iId;

            TBool cookieSharableFlag(EFalse);

            TInt err = GetCookieSharableFlagFromServer(cookieSharableFlag);

            CCookieClientData* cookieclientdata = CCookieClientData::NewL(groupid, aAppUid, cookieSharableFlag,ETrue);

            cookieclientdata->SetInitFlag(ETrue);

            cookieclientdataarray->AddClientGroupDataL(cookieclientdata);

           }

         else

           {

            CLOG( ( EClient, 0, _L( "-> RCookieManager::GetClientSideCookies:" ) ) );

            //Gets the Cookie objects for aUri in case it is present

            //TInt clerr = cookieclientdata->GetClientSideCookies(aUri,aCookies,cookiefound);

            TInt clerr = GetClientSideCookies(aUri,aCookies,cookiefound,aAppUid);

            CLOG( ( EClient, 0, _L( "RCookieManager::GetClientSideCookies:cookiefound = %d" ), cookiefound ) );

           }

        } 

    if(!cookiefound)

        {

            aCookie2Reqd = EFalse;

            //Appuid value only takes 8 chars

            HBufC* appuidbuf = HBufC::NewL(8);

            TPtr ptr(appuidbuf->Des());

            ptr.AppendNum(aAppUid,EHex);    

            TInt size = 0;

            TPckg<TInt> pkgSize( size );

            User::LeaveIfError( DoGetCookieSize( aUri, pkgSize, ptr ) );

            delete appuidbuf;

        if ( size )

            {

            HBufC8* buf = HBufC8::NewLC( size );

            TPtr8 des( buf->Des() );

            User::LeaveIfError( DoGetCookies( des ) );

            // it seems this is the only place where we cannot avoid leaving

            // ==> we allocate memory for cookies when we fill up the cookie array.

            iCookiePacker.UnpackCookiesFromBufferL( *buf, aCookies );

            TInt count = aCookies.Count();

            for(TInt j=0; j<count; j++)

                {

                CLOG( ( EClient, 0, _L( "-> RCookieManager::StoreClientSideCookies: aUri=%S" ), &aUri ) );

                //cookieclientdata->StoreCookieAtClientSide( aCookies[j],aUri );

                StoreCookieAtClientSide( aCookies[j],aUri,aAppUid );

                }

            TInt i = 0;

            TBool anyCookie2( EFalse );

            TBool anyUnknownVersion( EFalse );

            for ( ; i < count; i++ )

                {

                if ( aCookies[i]->FromCookie2() )

                    {

                    anyCookie2 = ETrue;

                    anyUnknownVersion |= aCookies[i]->IsUnknownVersion();

                    }

                }

            // if there were no new-style cookies or a new version info is detected

            // then we have to send an extra cookie header indicating that we're 

            // able to process new-style cookies

            if ( !anyCookie2 || anyUnknownVersion )

                {

                aCookie2Reqd = ETrue;

                }

            CleanupStack::PopAndDestroy();  // buf

            }

      }

    CLOG( ( EClient, 0, _L( "<- RCookieManager::GetCookiesL" ) ) );

    }

// ---------------------------------------------------------

// RCookieManager::Close for Widget related destruction during 

//uninstallation process of a widget

// ---------------------------------------------------------

//

EXPORT_C TInt RCookieManager::ClearAllAppUidCookies(const TUint32& aAppUid)

    {

    CLOG(( EClient, 0, _L("-> RCookieManager::ClearCookies") ));

    //Client side cookie deletion specific to a appuid

    CCookieClientDataArray::GetInstance()->DestroyClientData(aAppUid);

    //Server side Cookie deletion specific to a appuid

    //Appuid value only takes 8 chars

    HBufC* buf = HBufC::NewLC(8);

    TPtr ptr(buf->Des());

    ptr.AppendNum(aAppUid,EHex);

    TInt error = SendReceive(EClearAppUidCookies,TIpcArgs(ptr.Length(),&ptr)); 

    CleanupStack::PopAndDestroy();

    return error;

    }