/*
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:   Parses the XML command file (VPN command file)
*
*/



#include <e32std.h>

// XML parser includes
#include "XwImpl.h"
#include "XppImpl.h"

#include "cmdfilexmltags.h"
#include "cmdfileparser.h"
#include "policyinstaller_constants.h"
#include "log_r6.h"


CCmdFileParser::CCmdFileParser()
    {
    }

CCmdFileParser::~CCmdFileParser() 
    {
    LOG_("-> CCmdFileParser::~CCmdFileParser()");
    ReleaseResources();
    LOG_("<- CCmdFileParser::~CCmdFileParser()");
    }

void CCmdFileParser::ParseL(const TDesC8& aInputData)
    {
    LOG_("-> CCmdFileParser::ParseL()");
    // Release any allocated resources, for a clean parse
    ReleaseResources();

    iParserStack = new (ELeave) CArrayFixFlat<HBufC8*>(3);
    iParsedValuesArray = new (ELeave) CArrayFixFlat<HBufC8*>(3);

    // Parse XML and extract the parameters
    ParseXmlL(aInputData);

    iParseReady = ETrue;

    LOG_("<- CCmdFileParser::ParseL()");
    }

void CCmdFileParser::ReleaseResources() 
    {
    LOG_("-> CCmdFileParser::ReleaseResources()");

    iParseReady = EFalse;

    delete iFileContents;
    iFileContents = NULL;

    delete iPKCS12Pwd;
    iPKCS12Pwd = NULL;

    delete iFileName;
    iFileName = NULL;

    // Delete parser stack entries before deleting
    // the stack pointer
    if (iParserStack) 
        {
        LOG_(" Deleting items from parser stack");

        for (TInt i = iParserStack->Count() - 1; i >= 0; i--) 
            {
            LOG_1(" Deleting at %d", i);
            delete iParserStack->At(i);
            iParserStack->At(i) = NULL;
            }

        LOG_(" Reset parser");
        iParserStack->Reset();
        }

    delete iParserStack;
    iParserStack = NULL;

    // Delete parsed values entries before deleting
    // the array pointer
    if (iParsedValuesArray) 
        {
        LOG_(" Deleting items from parsed values");
        for (TInt i = iParsedValuesArray->Count() - 1; i >= 0; i--) 
            {
            LOG_1(" Deleting at %d", i);
            delete iParsedValuesArray->At(i);
            iParsedValuesArray->At(i) = NULL;
            }

        LOG_(" Reset parsed values");
        iParsedValuesArray->Reset();
        }

    delete iParsedValuesArray;
    iParsedValuesArray = NULL;

    LOG_("<- CCmdFileParser::ReleaseResources()");
    }

void CCmdFileParser::PushNodeL(const TDesC8& aName) 
    {
    LOG_("-> CCmdFileParser::PushNodeL()");

    HBufC8* node = aName.AllocLC();

    LOG8_1("   PUSH Node: '%S'", node);

    iParserStack->AppendL(node);
    CleanupStack::Pop(node);

    LOG_("<- CCmdFileParser::PushNodeL()");
    }

void CCmdFileParser::PopNode() 
    {
    LOG_("-> CCmdFileParser::PopNode()");

    // Just pop, unless we ought to stop
    TInt lastIdx = iParserStack->Count()-1;
    if (lastIdx >= 0) 
        {
        LOG8_1("   POP Node: '%S'", iParserStack->At(lastIdx));
        LOG_1("    Removing from parserstack index %d", lastIdx);

        delete iParserStack->At(lastIdx);
        iParserStack->Delete(lastIdx);
        }

    LOG_("<- CCmdFileParser::PopNode()");
    }

TBool CCmdFileParser::IsTopmostNode(const TDesC8& aName) const
    {
    LOG_("-> CCmdFileParser::IsTopmostNode()");
    LOG8_1("  CHECKING: '%S'", &aName);

    TBool ret(EFalse);
    if (iParserStack) 
        {
        TInt lastIdx = iParserStack->Count()-1;
        TPtrC8 top = *(iParserStack->At(lastIdx));

        LOG8_1("  FOUND: '%S'", &top);

        if (aName.Compare(top) == 0)
            {
            ret = ETrue;
            }
        }

    LOG_1("<- CCmdFileParser::IsTopmostNode() val: %d", ret);

    return ret;
    }

HBufC8* CCmdFileParser::ParseTreeUriL(const TDesC8& aText) const
    {
    LOG_("-> CCmdFileParser::ParseTreeUriL()");
    LOG8_1(" Input: '%S'", &aText);

    HBufC8* ret(NULL);
    TInt uriLen(aText.Length());
    TInt itemCount(0);
    if (iParserStack)
        {
        // First, with precise scientifical approach establish 
        // the amount of wide bytes required for storing the URI
        itemCount = iParserStack->Count();

        LOG_1(" Items in stack: %d", itemCount);

        for (TInt i = 0; i < itemCount; i++) 
            {
            uriLen += iParserStack->At(i)->Length();
            }

        // The number of "slash" ("/") characters required,
        // with utmost precision
        uriLen += itemCount;
        ret = HBufC8::NewL(uriLen);

        // And then store the URI to a new string.
        for (TInt i = 0; i < itemCount; i++) 
            {
            ret->Des().Append(*(iParserStack->At(i)));
            ret->Des().Append(KCmdUriSeparator);
            }
        ret->Des().Append(aText);
        }

    LOG_("<- CCmdFileParser::ParseTreeUriL()");
    return ret;
    }

TBool CCmdFileParser::IsValidText(const TDesC8& aText) const
    {
    LOG_("-> CCmdFileParser::IsValidText()");
    TBool ret(ETrue);

    // We don't support "CR/LF" characters in the
    // beginning of valid value names
    TInt idx = aText.Find(KCmdCr);
    if (idx >= 0 && idx < 2) 
        {
        ret = EFalse;
        }
    else 
        {
        idx = aText.Find(KCmdLf);
        if (idx >= 0 && idx < 2) 
            {
            ret = EFalse;
            }
        }

    LOG_1("<- CCmdFileParser::IsValidText() ret: %d", ret);
    return ret;
    }
    
void CCmdFileParser::ParseXmlL(const TDesC8& aInputData)
    {
    LOG_("-> CCmdFileParser::ParseXmlL()");

    LOG_(" Instantiate parser array");

    CDesC8ArrayFlat* parserValueArray = new (ELeave) CDesC8ArrayFlat(10);
    CleanupStack::PushL(parserValueArray);

    LOG_(" Instantiate XML parser");
    CXmlPullParser* parser = CXmlPullParser::NewLC(*parserValueArray);

    TPtrC8 name;
    TPtrC8 attribute;

    LOG_(" Set input");
    parser->SetInput(aInputData);

    LOG_(" Get length");
    TInt len = parser->Length();
    LOG_1(" XML length: %d bytes", len);

    // Check the first element
    LOG_(" Get the next (first) element");
    parser->NextL();

    if (parser->State() != CXmlPullParser::EStateStartTag) 
        {
        LOG_(" LEAVE: XML data is not in VPN's required format!");
        User::Leave(KErrCorrupt);
        }

    LOG_(" Starting the main parser loop");
    TPtrC8 text;

    // Main loop:
    // - While XML nodes still exist do:
    //   - If "opening" node (<start>), push to the stack
    //   - If "closing" node (</start>), pop from the stack
    //   - If a text node, make sure it's valid and then store
    //     the URI so the value can be fetched later on.
    while (parser->State() != CXmlPullParser::EStateEndDocument)
        {
        parser->Name(name);

        if (parser->State() == CXmlPullParser::EStateStartTag) 
            {
            LOG8_1(" START: '%S'", &name);
            PushNodeL(name);
            }
        else if (parser->State() == CXmlPullParser::EStateEndTag) 
            {
            LOG8_1(" END: '%S'", &name);
            if (IsTopmostNode(name)) 
                {
                PopNode();
                }
            else 
                {
                // Item on top of the stack wasn't what was
                // expected. Indicates corrupted XML.
                LOG_(" ERROR: Node end tag mismatch with expected");
                User::Leave(KErrCorrupt);
                }
            }
        else if (parser->State() == CXmlPullParser::EStateText)
            {
            parser->TextL(text);
            if (IsValidText(text)) 
                {
                LOG8_1(" Text: '%S'", &text);
                
                HBufC8* uri = ParseTreeUriL(text);

                LOG8_1(" URI: '%S'", uri);

                CleanupStack::PushL(uri);
                
                iParsedValuesArray->AppendL(uri);
                
                CleanupStack::Pop(uri);
                }
            }

        parser->NextL();
        }

    LOG_(" Popping");

    CleanupStack::PopAndDestroy(2, parserValueArray);

    LOG_("<- CCmdFileParser::ParseXmlL()");
    }


HBufC* CCmdFileParser::GetParsedValueStrL(const TDesC8& aUri) 
    {
    LOG_("-> CCmdFileParser::GetParsedValueStrL()");

    HBufC* ret(NULL);

    // Get the "leaf" value (i.e. attribute's value)
    // and alloc a new string for it
    TPtrC8 ptr = FindUri(aUri);
    if (ptr.Length() > 0)
        {
        LOG_(" Ptr length > 0");
        LOG8_1(" Ptr: '%S'", &ptr);
        ret = HBufC::NewL(ptr.Length());
        ret->Des().Copy(ptr);
        }
    else 
        {
        LOG_(" Ptr length < 1");
        }

    LOG_("<- CCmdFileParser::GetParsedValueStrL()");

    return ret;
    }

void CCmdFileParser::GetParsedValueIntL(const TDesC8& aUri, TInt& aVal) 
    {
    LOG_("-> CCmdFileParser::GetParsedValueIntL()");

    // Get the attribute's value as string...
    HBufC* str = GetParsedValueStrL(aUri);

    if (str)
        {
        LOG_(" Valid string");
        CleanupStack::PushL(str);

        // ... and convert it to an integer
        LOG_(" Converting string to int");
        TLex lexer(*str);
        TInt status = lexer.Val(aVal);

        if (status != KErrNone) 
            {
            LOG_1("<- CCmdFileParser::GetParsedValueIntL() LEAVE: %d", status);
            User::Leave(status);
            }

        CleanupStack::PopAndDestroy(str);
        }
    else 
        {
        aVal = KErrNotFound;
        }
    LOG_("<- CCmdFileParser::GetParsedValueIntL()");
    }

void CCmdFileParser::GetParsedValueBoolL(const TDesC8& aUri, TBool& aVal)
    {
    LOG_("-> CCmdFileParser::GetParsedValueBoolL()");

    // Get the attribute's value as string...
    HBufC* str = GetParsedValueStrL(aUri);

    if (str) 
        {
        CleanupStack::PushL(str);

        // ... and see whether it matches "true"
        // Note that this comparison is extremely case-sensitive
        if (str->Compare(KTrue) == 0) 
            {
            aVal = ETrue;
            }
        else 
            {
            aVal = EFalse;
            }

        CleanupStack::PopAndDestroy(str);
        }
    else 
        {
        aVal = EFalse;
        }

    LOG_("<- CCmdFileParser::GetParsedValueBoolL()");
    }

/**
 * Extracts the "leaf value" ie. attribute's value instance
 * from an uri.
 * E.g. returns "BEEFFACED" if the full URI was
 * root/node1/node2/attribute1/BEEFFACED
 * (Or in XML representation,
 * <node1>
 *   <node2>
 *     <attribute1>BEEFFACED</attribute1>
 *   </node2>
 * </node1>)
 *
 */
TPtrC8 CCmdFileParser::FindUri(const TDesC8& aUri) const
    {
    LOG_("-> CCmdFileParser::FindUri()");
    LOG8_1(" Searching URI '%S'", &aUri);

    TPtrC8 ret(KNullDesC8);

    if (iParsedValuesArray) 
        {
        TInt count = iParsedValuesArray->Count();
        for (TInt i = 0; i < count; i++) 
            {
            TPtrC8 fulluri = *(iParsedValuesArray->At(i));

            // Check if we find the requested URI from the
            // very beginning of the parsed value's URI
            if (fulluri.Find(aUri) == 0) 
                {
                // Extract the "remaining" string -- the value (assuming correct syntax)
                ret.Set(fulluri.Right(fulluri.Length() - aUri.Length()));
                }
            }
        }

    LOG_("<- CCmdFileParser::FindUri()");

    return ret;
    }