/*
* Copyright (c) 2008 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:
 *
*/


// INCLUDE FILES
#include "cstsuri.h"
#include "stsapduconstants.h"
#include "logger.h"

namespace java
{
namespace satsa
{

// CONSTANTS
const TInt KSTSAIDMaxLength = 16;
const TInt KSTSAIDMinLength = 5;

const TInt KSTSMinURILength = 15;//(SAT uri without slot number)
const TInt KSTSMaxURILength = 61;//(AID uri with slot and maximum AID)

const TUint8 KSTSErrNotAHexNumber = 255;

const TInt KSTSApduUriPrefixLength = 5; // "apdu:" takes 5 characters

const TUint8 KSTSApduUriSlotTargetSeparator = ';';
const TUint8 KSTSApduUriAIDSeparator = '.';
const TUint8 KSTSSmallA = 'a';
const TUint8 KSTSBigA = 'A';
const TInt KSTSValueOfHexA = 0x0A;
const TInt KSTSMaxHexValue = 0x0F;
const TInt KSTSLengthOfSingleHexDigitInBits = 4;

_LIT(KSTSUriTargetPrefix, "target=");
_LIT(KSTSUriTargetSAT, "SAT");

// ============================ MEMBER FUNCTIONS ===============================


CSTSURI::CSTSURI()
{
}

void CSTSURI::ConstructL(const TDesC& aURIString)
{
    LOG(ESATSA, EInfo, "CSTSURI::ConstructL++");
    // does URI conform to the BNF syntax
    if (!CheckURIL(aURIString))
    {
        ELOG(ESATSA, "CSTSURI::ConstructL: URI does not conform to BNF sntax");
        // IllegalArgumentException
        User::Leave(KSTSErrIllegalArgument + KSTSErrIAInvalidParam);
    }
}

CSTSURI* CSTSURI::NewLC(const TDesC& aURIString)
{
    LOG(ESATSA, EInfo, "CSTSURI::NewLC++");
    CSTSURI* self = new(ELeave) CSTSURI();
    CleanupStack::PushL(self);
    self->ConstructL(aURIString);
    LOG(ESATSA, EInfo, "CSTSURI::NewLC---");
    return self;
}

CSTSURI::~CSTSURI()
{
    delete iAID;
}

// -----------------------------------------------------------------------------
// CSTSURI::AID
// Getter for AID value
// -----------------------------------------------------------------------------
const TDesC8& CSTSURI::AID() const
{
    return *iAID;
}

// -----------------------------------------------------------------------------
// CSTSURI::Slot
// Getter for Slot
// -----------------------------------------------------------------------------
TUint8 CSTSURI::Slot() const
{
    return iSlot;
}

// -----------------------------------------------------------------------------
// CSTSURI::Type
// Getter for URI type
// -----------------------------------------------------------------------------
CSTSURI::TURIType CSTSURI::Type() const
{
    return iURIType;
}

// -----------------------------------------------------------------------------
// CSTSURI::CheckURIL
// Checks uri and saves needed information to member variables
//
/*
 URI can be for example: "apdu:0;target=A0.0.0.67.4.7.1F.3.2C.3"
 or                     "apdu:0;target=SAT"

 <APDU_connection_string>::= "apdu:"<targetAddress>
 <targetAddress>            ::= [slot];target
 <slot>                 ::= smart card slot number. (optional. Hexadecimal
 number identifying the smart card slot. Default
 slot assumed if left empty)
 <target>               ::= "target="<AID>|"SAT"
 <AID>                  ::= < 5 - 16 bytes >
 An AID (Application Identifier) uniquely
 identifies a smart card application. It is
 represented by 5 to 16 hexadecimal bytes where
 each byte value is seperated by a ".".
 */
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CSTSURI::CheckURIL(const TDesC& aURI)
{
    LOG(ESATSA, EInfo, "CSTSURI::CheckURIL");
    const TInt uriLength = aURI.Length();
    LOG1(ESATSA, EInfo, "CSTSURI::CheckURIL:The lenghth of URI is %d", uriLength);
    // check length
    if ((uriLength > KSTSMaxURILength) || (uriLength < KSTSMinURILength))
    {
        ELOG(ESATSA, "CSTSURI::CheckURIL:wrong length of the URI");
        return EFalse;
    }
    // uri is now between 15 and 61 characters
    // Connector has already parsed the scheme part of the uri,
    // so we don't need to

    // "apdu:" takes 5 first characters
    TInt pos = KSTSApduUriPrefixLength;

    // parse slot number
    TChar slotChar = aURI[pos++];
    TUint8 slotInt = 0;
    //if slot number is gived
    if (slotChar != KSTSApduUriSlotTargetSeparator)
    {
        //create ptr which starts from slot number position
        TPtrC16 slotAndRest(aURI.Ptr() + KSTSApduUriPrefixLength, uriLength
                            - KSTSApduUriPrefixLength);
        TLex slotLex(slotAndRest);
        TInt slotNumber;
        //parse slot number
        TInt err = slotLex.Val(slotNumber);
        if (err != KErrNone)
        {
            return EFalse;
        }

        slotInt = static_cast<TUint8>(slotNumber);

        //calculate amount of slot number digits
        HBufC8* slotBuf = HBufC8::NewL(KSTSMaxURILength);
        slotBuf->Des().AppendNum(slotNumber);
        TInt slotNumberLength = slotBuf->Des().Length();
        delete slotBuf;

        //if digits of slotnumber are more that one
        slotChar = aURI[pos + (slotNumberLength - 1)];
        pos += slotNumberLength;
    }

    if (slotChar != KSTSApduUriSlotTargetSeparator)
    {
        return EFalse;
    }

    // next should be "target="
    if (aURI.Find(KSTSUriTargetPrefix()) != pos)
    {
        return EFalse;
    }
    pos += KSTSUriTargetPrefix().Length();

    TURIType uriType = EAID;
    TBufC8<KSTSAIDMaxLength> aid;

    if (aURI.Find(KSTSUriTargetSAT()) == pos)
    {
        if (uriLength != (pos + KSTSUriTargetSAT().Length()))
        {
            return EFalse;
        }
        uriType = ESAT;
    }
    else
    {
        TPtr8 aidDes = aid.Des();
        if (!ParseAID(aURI, pos, aidDes))
        {
            return EFalse;
        }
    }

    iSlot = slotInt;
    iURIType = uriType;

    //copies data to the member buffer
    iAID = aid.AllocL();
    LOG(ESATSA, EInfo, "CSTSURI::CheckURIL---");
    return ETrue;
}

// -----------------------------------------------------------------------------
// CSTSURI::GetHexValue
// returns an integer value of given hex character
// -----------------------------------------------------------------------------
//
TUint8 CSTSURI::GetHexValue(const TChar& aDigit)
{
    // if aDigit is 0-9, we can use TChar::GetNumericValue directly
    if (aDigit.IsDigit())
    {
        return static_cast<TUint8>(aDigit.GetNumericValue());
    }

    // if aDigit is not a hexadecimal digit, it is an error
    if (!(aDigit.IsHexDigit()))
    {
        return KSTSErrNotAHexNumber;
    }

    // otherwise, aDigit is a-f or A-F
    TChar charA = KSTSSmallA;
    if (aDigit.IsUpper())
    {
        charA = KSTSBigA;
    }

    // we can get the value by calculating the difference of the character
    // and character 'a', and adding the value of hex digit 'a'.
    TUint8 retVal = static_cast<TUint8>((aDigit - charA) + KSTSValueOfHexA);
    return retVal;
}

// -----------------------------------------------------------------------------
// CSTSURI::ParseAID
// parses AID from URI
// -----------------------------------------------------------------------------
//
TBool CSTSURI::ParseAID(const TDesC& aURI, TInt aPos, TDes8& aAID)
{
    TInt aidLength = aAID.Length();
    TInt aidMaxLength = aAID.MaxLength();
    TInt uriLength = aURI.Length();
    TInt pos = aPos;
    TAidParserState aidState = EFirstDigit;
    TUint8 aidDigit = 0;
    while (pos < uriLength)
    {
        TChar digit = aURI[pos++];
        ParseAIDCharacter(digit, aidState, aidDigit);
        switch (aidState)
        {
        case EFirstDigit:
        {
            if (++aidLength > aidMaxLength)
            {
                return EFalse;
            }
            aAID.Append(aidDigit);
            break;
        }
        case EERROR:
        {
            return EFalse;
        }
        default:
        {
            // other states don't require action
        }
        }
    }
    if (aidState == ESecondDigit)
    {
        // the uri ended after first digit, which is not yet added
        if (++aidLength > aidMaxLength)
        {
            return EFalse;
        }
        aAID.Append(aidDigit);
    }
    if (aidState == EFirstDigit)
    {
        // AID ended with a dot
        return EFalse;
    }

    if (aidState == EDot)
    {
        // Append also last digit
        aAID.Append(aidDigit);
    }

    if (aidLength < KSTSAIDMinLength)
    {
        return EFalse;
    }
    return ETrue;
}

// -----------------------------------------------------------------------------
// CSTSURI::ParseAIDCharacter
// Implements AID parsing state machine
// -----------------------------------------------------------------------------
void CSTSURI::ParseAIDCharacter(const TChar& aDigit, TAidParserState& aState,
                                TUint8& aAIDDigit)
{
    switch (aState)
    {
    case EFirstDigit:
    {
        aAIDDigit = GetHexValue(aDigit);
        if (aAIDDigit > KSTSMaxHexValue)
        {
            aState = EERROR;
        }
        else
        {
            aState = ESecondDigit;
        }
        break;
    }
    case ESecondDigit:
    {
        if (aDigit != KSTSApduUriAIDSeparator)
        {
            TUint8 secondDigit = GetHexValue(aDigit);
            if (secondDigit > KSTSMaxHexValue)
            {
                aState = EERROR;
            }
            else
            {
                aAIDDigit <<= KSTSLengthOfSingleHexDigitInBits;
                aAIDDigit |= secondDigit;
                aState = EDot;
            }
        }
        else
        {
            aState = EFirstDigit;
        }
        break;
    }
    case EDot:
    {
        if (aDigit != KSTSApduUriAIDSeparator)
        {
            aState = EERROR;
        }
        else
        {
            aState = EFirstDigit;
        }
        break;
    }
    default:
    {

    }
    }
}

} // namespace satsa
} // namespace java
//  End of File