// Copyright (c) 2003-2009 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:

// Name        : Udvm.cpp

// Part of     : SigComp / UDVM

// UDVM core

// Version     : 1.0

//

// INCLUDE FILES

#include "Udvm.h"

#include "UdvmMemory.h"

#include "sigcompcompartment.h"

#include "StateMgr.h"

#include "Crc.h"

#include "MessageReader.h"

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

void CUdvm::ConstructL(CStateMgr* aStateMgr,

                       TUint aMemSize,

                       TUint aCyclesPerBit)

    {

    iExecuteOpcode[EOpcode_DECOMPRESSION_FAILURE] =

                   &CUdvm::ExecuteOpcodeDecompressionFailureL;

    iExecuteOpcode[EOpcode_AND] = &CUdvm::ExecuteOpcodeAndL;

    iExecuteOpcode[EOpcode_OR] = &CUdvm::ExecuteOpcodeOrL;

    iExecuteOpcode[EOpcode_NOT] = &CUdvm::ExecuteOpcodeNotL;

    iExecuteOpcode[EOpcode_LSHIFT] = &CUdvm::ExecuteOpcodeLShiftL;

    iExecuteOpcode[EOpcode_RSHIFT] = &CUdvm::ExecuteOpcodeRShiftL;

    iExecuteOpcode[EOpcode_ADD] = &CUdvm::ExecuteOpcodeAddL;

    iExecuteOpcode[EOpcode_SUBTRACT] = &CUdvm::ExecuteOpcodeSubtractL;

    iExecuteOpcode[EOpcode_MULTIPLY] = &CUdvm::ExecuteOpcodeMultiplyL;

    iExecuteOpcode[EOpcode_DIVIDE] = &CUdvm::ExecuteOpcodeDivideL;

    iExecuteOpcode[EOpcode_REMAINDER] = &CUdvm::ExecuteOpcodeRemainderL;

    iExecuteOpcode[EOpcode_SORT_ASCENDING] = &CUdvm::ExecuteOpcodeAscendingL;

    iExecuteOpcode[EOpcode_SORT_DESCENDING] = &CUdvm::ExecuteOpcodeDescendingL;

    iExecuteOpcode[EOpcode_SHA_1] = &CUdvm::ExecuteOpcodeSha1L;

    iExecuteOpcode[EOpcode_LOAD] = &CUdvm::ExecuteOpcodeLoadL;

    iExecuteOpcode[EOpcode_MULTILOAD] = &CUdvm::ExecuteOpcodeMultiloadL;

    iExecuteOpcode[EOpcode_PUSH] = &CUdvm::ExecuteOpcodePushL;

    iExecuteOpcode[EOpcode_POP] = &CUdvm::ExecuteOpcodePopL;

    iExecuteOpcode[EOpcode_COPY] = &CUdvm::ExecuteOpcodeCopyL;

    iExecuteOpcode[EOpcode_COPY_LITERAL] = &CUdvm::ExecuteOpcodeCopyLiteralL;

    iExecuteOpcode[EOpcode_COPY_OFFSET] = &CUdvm::ExecuteOpcodeCopyOffsetL;

    iExecuteOpcode[EOpcode_MEMSET] = &CUdvm::ExecuteOpcodeMemsetL;

    iExecuteOpcode[EOpcode_JUMP] = &CUdvm::ExecuteOpcodeJumpL;

    iExecuteOpcode[EOpcode_COMPARE] = &CUdvm::ExecuteOpcodeCompareL;

    iExecuteOpcode[EOpcode_CALL] = &CUdvm::ExecuteOpcodeCallL;

    iExecuteOpcode[EOpcode_RETURN] = &CUdvm::ExecuteOpcodeReturnL;

    iExecuteOpcode[EOpcode_SWITCH] = &CUdvm::ExecuteOpcodeSwitchL;

    iExecuteOpcode[EOpcode_CRC] = &CUdvm::ExecuteOpcodeCrcL;

    iExecuteOpcode[EOpcode_INPUT_BYTES] = &CUdvm::ExecuteOpcodeInputBytesL;

    iExecuteOpcode[EOpcode_INPUT_BITS] = &CUdvm::ExecuteOpcodeInputBitsL;

    iExecuteOpcode[EOpcode_INPUT_HUFFMAN] = &CUdvm::ExecuteOpcodeInputHuffmanL;

    iExecuteOpcode[EOpcode_STATE_ACCESS] = &CUdvm::ExecuteOpcodeStateAccessL;

    iExecuteOpcode[EOpcode_STATE_CREATE] = &CUdvm::ExecuteOpcodeStateCreateL;

    iExecuteOpcode[EOpcode_STATE_FREE] = &CUdvm::ExecuteOpcodeStateFreeL;

    iExecuteOpcode[EOpcode_OUTPUT] = &CUdvm::ExecuteOpcodeOutputL;

    iExecuteOpcode[EOpcode_END_MESSAGE] = &CUdvm::ExecuteOpcodeEndMessageL;

    iStateMgr = aStateMgr;

    iUdvmMemory = CUdvmMemory::NewL(aMemSize);

    iCyclesPerBit = aCyclesPerBit;

    iSHA1 = CSHA1::NewL();

    }

CUdvm::CUdvm() : iReturnedFeedback(NULL, 0),

                 iRequestedFeedback(NULL, 0),

                 iReturnedParameters(NULL, 0)

    {

    }

CUdvm* CUdvm::NewLC(CStateMgr* aStateMgr,

                    TUint aMemSize,

                    TUint aCyclesPerBit)

    {

    CUdvm* self= new (ELeave) CUdvm();

    CleanupStack::PushL(self);

    self->ConstructL(aStateMgr, aMemSize, aCyclesPerBit);

    return self;

    }

CUdvm* CUdvm::NewL(CStateMgr* aStateMgr, TUint aMemSize, TUint aCyclesPerBit)

    {

    CUdvm* self= NewLC(aStateMgr, aMemSize, aCyclesPerBit);

    CleanupStack::Pop();

    return self;

    }

// Destructor

CUdvm::~CUdvm()

    {

    DenyStateOperations();

    delete iUdvmMemory;

    delete iSHA1;

    }

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

/*

     0   1   2   3   4   5   6   7       0   1   2   3   4   5   6   7

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

   | 1   1   1   1   1 | T |  len  |   | 1   1   1   1   1 | T |   0   |

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

   |                               |   |                               |

   :    returned feedback item     :   :    returned feedback item     :

   |                               |   |                               |

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

   |                               |   |           code_len            |

   :   partial state identifier    :   +---+---+---+---+---+---+---+---+

   |                               |   |   code_len    |  destination  |

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

   |                               |   |                               |

   :   remaining SigComp message   :   :    uploaded UDVM bytecode     :

   |                               |   |                               |

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

                                       |                               |

                                       :   remaining SigComp message   :

                                       |                               |

                                       +---+---+---+---+---+---+---+---+

     0   1   2   3   4   5   6   7       0   1   2   3   4   5   6   7

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

   | 0 |  returned_feedback_field  |   | 1 | returned_feedback_length  |

   +---+---+---+---+---+---+---+---+   +---+---+---+---+---+---+---+---+

                                       |                               |

                                       :    returned_feedback_field    :

                                       |                               |

                                       +---+---+---+---+---+---+---+---+

   Encoding:   Length of partial state identifier

   01          6 bytes

   10          9 bytes

   11          12 bytes

   Encoding:   Destination address:

   0000        reserved

   0001        2  *  64  =  128

   0010        3  *  64  =  196

   0011        4  *  64  =  256

     :                :

   1111        16 *  64  =  1024

   Note that the encoding 0000 is reserved for future SigComp versions,

   and causes a decompression failure in Version 0x01.

*/

void CUdvm::SetReturnedFeedbackL(TBool aT, CMessageReader* aMsgReader)

    {

    if (aT)

        {

        // returned feedback item

        TUint rff;

        if (aMsgReader->ReadByte(rff) != KErrNone)

            {

            User::Leave(CSigComp::EIncompleteMessage);

            }

        if (rff & KReturnedFeedbackFieldMask)

            {

            // long form

            // use decompression memory after udvm memory to store returned

            // feedback

            TUint8* udvmMem = iUdvmMemory->MemoryPtr();

            TUint udvmFreeMemSize = iUdvmMemory->FreeMemorySize();

            iReturnedFeedback.Set(&udvmMem[udvmFreeMemSize],

                                  0, rff & KReturnedFeedbackLengthMask);

            if (aMsgReader->ReadBlock(iReturnedFeedback) != KErrNone)

                {

                User::Leave(CSigComp::EIncompleteMessage);

                }

            }

        else

            {

            // short form

            // use decompression memory after udvm memory to store returned

            // feedback

            TUint8* udvmMem = iUdvmMemory->MemoryPtr();

            TUint udvmFreeMemSize = iUdvmMemory->FreeMemorySize();

            iReturnedFeedback.Set(&udvmMem[udvmFreeMemSize], 0, 1);

            iReturnedFeedback.Append(rff);

            }

        }

    else

        {

        iReturnedFeedback.Set(NULL, 0, 0);

        }

    }

void CUdvm::UploadStateInMessageL(TUint aLen, CMessageReader* aMsgReader)

    {

    // RFC3320:

    // The len field encodes the number of transmitted bytes as follows:

    //

    //   Encoding:   Length of partial state identifier

    //   01          6 bytes

    //   10          9 bytes

    //   11          12 bytes

    TUint id_len = (aLen + 1) * 3;

    TBuf8<12> psi;

    if (aMsgReader->ReadBlock(psi, id_len) != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    // upload state item

    UploadStateL(id_len, psi.Ptr());

    }

void CUdvm::UploadBytecodeInMessageL(CMessageReader* aMsgReader)

    {

    TUint tmp;

    // get first byte of 16-bit big-endian value

    if (aMsgReader->ReadByte(tmp) != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    // code length is most significant 12 bits

    TUint code_len = tmp << 4;

    // get second byte of 16-bit big-endian value

    if (aMsgReader->ReadByte(tmp) != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    code_len |= tmp >> 4;

    // destination is less significant 4 bits

    TUint destination = tmp & 0x000f;

    // The destination field is encoded as follows:

    //

    //                     Encoding:   Destination address:

    //                     0000        reserved

    //                     0001        2  *  64  =  128

    //                     0010        3  *  64  =  196

    //                     0011        4  *  64  =  256

    //                       :                :

    //                     1111        16 *  64  =  1024

    //

    //   Note that the encoding 0000 is reserved for future SigComp versions,

    //   and causes a decompression failure in Version 0x01.

    if (destination == 0)

        {

        User::Leave(CSigComp::EDecompressionFailure);

        }

    // destination decoding - see above

    destination = (destination + 1) * 64;

    // upload code_len bytes of bytecode at destination

    UploadCodeL(destination, code_len, aMsgReader);

    }

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

// CUdvm::DecompressL

// dispatch message and run bytecode

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

//

CBufBase* CUdvm::DecompressL(const TDesC8& aMessage, TUint& aBytesConsumed,

                             TBool aStreamBasedProtocol)

    {

    CMessageReader* msgReader = new (ELeave)CMessageReader(aMessage,

                                                         aStreamBasedProtocol);

    CleanupStack::PushL(msgReader);

    if (msgReader->SkipDelimiters() != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    TUint tmp;

    if (msgReader->ReadByte(tmp) != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    //is sigcomp message?

    if ((tmp & KSigCompHeaderMask) != KSigCompHeaderMask)

        {

        User::Leave(CSigComp::EIncompleteMessage);

        }

    // get T bit from header

    TBool t = tmp & KSigCompHeaderTMask;

    // partial state identifier length

    TUint len = tmp & KSigCompHeaderLenMask;

    // initialize udvm memory

    if (aStreamBasedProtocol)

        {

        iUdvmMemory->InitMemoryL(iUdvmMemory->MemorySize()/2, iCyclesPerBit);

        }

    else

        {

        iUdvmMemory->InitMemoryL(aMessage.Length(), iCyclesPerBit);

        }

    // T bit set, returned feedback present

    SetReturnedFeedbackL(t, msgReader);

    if (len)

        {

        // partial state identifier

        UploadStateInMessageL(len, msgReader);

        }

    else

        {

        // bytecode

        UploadBytecodeInMessageL(msgReader);

        }

    // available cycles, as defined in RFC3220 chapter 8.6

    iAvailableCycles = (8 * aMessage.Length() + 1000) * iCyclesPerBit;

    // prepare output buffer

    CBufFlat* outputBuffer = CBufFlat::NewL(128);

    CleanupStack::PushL(outputBuffer);

    outputBuffer->SetReserveL(128);

    iOutputBuffer = outputBuffer; // used for parameter passing to Opcodes

    // execute code

    ExecuteCodeL(msgReader);

    iOutputBuffer = NULL;

    CleanupStack::Pop(outputBuffer);

    // skip end delimiter

    if (aStreamBasedProtocol)

        {

        msgReader->SkipDelimiters(1);

        }

    // get message bytes consumed

    aBytesConsumed = msgReader->Pos();

    outputBuffer->Compress();

    CleanupStack::PopAndDestroy(msgReader);

    return outputBuffer;

    }

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

// CUdvm::ByteCopyingFragmentL

//

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

//

inline TUint CUdvm::ByteCopyingFragmentL(TUint& aAddress,

                                         TUint& aLength,

                                         TUint aBcl,

                                         TUint aBcr) const

    {

    TUint len;

    if (((aAddress + 1) <= aBcr) && ((aAddress + aLength) > aBcr))

        {

        len = aBcr - aAddress;

        }

    else

        {

        len = aLength;

        }

    if ((aAddress + len) > iUdvmMemory->FreeMemorySize())

        {

        User::Leave(CSigComp::EDecompressionFailure);

        }

    aLength -= len;

    aAddress = aBcl;

    return len;

    }

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

// CUdvm::UploadCodeL

// upload bytecode, initialize UDVM memory and registers

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

//

void CUdvm::UploadCodeL(TUint aDest, TUint aLen, CMessageReader* aMsgReader)

    {

    // init memory

    iUdvmMemory->WriteMem16L(EMem_partial_state_ID_length, 0x0000);

    iUdvmMemory->WriteMem16L(EMem_state_length, 0x0000);

    // upload code

    iUdvmMemory->CheckMemAccessL(aDest & KMaxUdvmMemoryMask, aLen);

    TPtr8 codePtr(iUdvmMemory->MemoryPtr() +

                  (aDest & KMaxUdvmMemoryMask), aLen);

    if (aMsgReader->ReadBlock(codePtr) != KErrNone)

        {

        User::Leave(CSigComp::EIncompleteMessage);

                }

    iCodeStart = aDest;

    }

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

// CUdvm::UploadStateL

// upload state item, initialize UDVM memory and registers

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

//

void CUdvm::UploadStateL(TUint aStateLen, const TUint8* aState)

    {

    TStateItem* si = iStateMgr->FindStateItem(TPtrC8(aState, aStateLen));

    if (si == NULL)

        {

        User::Leave(CSigComp::EDecompressionFailure);

        }

    TestStateAccessLenL(si, aStateLen);

    // init memory

    iUdvmMemory->WriteMem16L(EMem_partial_state_ID_length, aStateLen);

    iUdvmMemory->WriteMem16L(EMem_state_length, si->iStateLength);

    // upload state value

    iUdvmMemory->CopyToMemL(si->iStateAddress & KMaxUdvmMemoryMask,

                            si->iStateValue,

                            si->iStateLength);

    iCodeStart = si->iStateInstruction;

    }

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

// CUdvm::TestStateAccessLenL

// test state access lenght

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

//

void CUdvm::TestStateAccessLenL(const TStateItem* aStateItem,

                                TUint aAccessLen) const

    {

    if (aAccessLen < aStateItem->iMinimumAccessLength)

        {

        User::Leave(CSigComp::EDecompressionFailure);

        }

    }

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

// CUdvm::InputMessageBitsL

// input message bits

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

//

TUint CUdvm::InputMessageBitsL(TUint aSize, TUint aP, TUint aF)

    {

    // aP and aF are flags from input_bit_order UDVM register

    // iLastUsedInputBit is number of used bits from readed byte,

    // zero if need to read next byte

    //output value

    TUint val = 0;

    //it may be needed later, depending on aF flag.

    TUint l = aSize;

    //to store the return value of ReadByte function

    TInt ret = 0;

    // get aSize bits, aF aP flags indicates from which side bits are taken

    // (MSB or LSB order)

    // as described in RFC 3220 chapter 8.2.

    while (aSize)

        {

        if (iLastUsedInputBit == 0)

            {

            ret = iInputMessageReader->ReadByte(iLastInputByte);

            if(ret != KErrNone)

            	User::Leave( ret );

            }

        if (aP)

            {

            if (aF)

                {

                // put LSB of input byte as MSB of output 16-bit word

                val >>= 1;

                val |= ((iLastInputByte & 1) << 15);

                }

            else