/*
* 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 the License "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 "config.h"
#include "StringHash.h"
#include "FormLoginStore.h"
#include "FileStreamSymbian.h"
#include <pbe.h>
#include <pbedata.h>
_LIT(KLoginDatFile, "c:\\private\\%08x\\login.dat");

namespace WebCore {

//------------------------------------------------------------------------------
// LoginData
//------------------------------------------------------------------------------
LoginData::LoginData(FormLoginStore* s) : m_store(s)
{
}

LoginData::LoginData(FormLoginStore* s, const String& realm, const String& uname, const String& uvalue, const String& pname, const String& pvalue)
            : m_realm(realm), m_usernameField(uname), m_usernameValue(uvalue), m_passwdField(pname), m_passwdValue(pvalue), m_store(s)
{
}

LoginData::~LoginData()
{
}

void LoginData::read(StreamInput& is)
{
    String encryptedUser, encryptedPasswd;
    is>>m_realm>>m_usernameField>>encryptedUser>>m_passwdField>>encryptedPasswd;
    m_usernameValue = m_store->decrypt(encryptedUser);
    m_passwdValue = m_store->decrypt(encryptedPasswd);
}

void LoginData::write(StreamOutput& os) const
{
    os<<m_realm<<m_usernameField<<m_store->encrypt(m_usernameValue)<<m_passwdField<<m_store->encrypt(m_passwdValue);
}

bool LoginData::partialMatch(const String& realm, const String& uname, const String& uvalue, const String& pname) const
{
    return !(realm != m_realm || uname != m_usernameField || uvalue != m_usernameValue || pname != m_passwdField);
}

bool LoginData::match(const LoginData& b) const
{
    return partialMatch(b.m_realm, b.m_usernameField, b.m_usernameValue, b.m_passwdField) && (m_passwdValue == b.m_passwdValue);
}

//------------------------------------------------------------------------------
// FormLoginStore
//------------------------------------------------------------------------------
FormLoginStore::FormLoginStore() : m_needCommit(false), m_pbEncrypt(0), m_pbDecrypt(0)
{
    initialize();
}

FormLoginStore::~FormLoginStore()
{
    commit();
    clearCache();
    delete m_pbEncrypt;
    delete m_pbDecrypt;
}

void FormLoginStore::setSaveNotAllowed(const String& url)
{
    m_blackList.add(url);
}

bool FormLoginStore::saveAllowed(const String& url) const
{
    return !m_blackList.contains(url);
}

void FormLoginStore::add(const String& realm, const String& uname, const String& uvalue, const String& pname, const String& pvalue)
{
    LoginData* login = new LoginData(this, realm, uname, uvalue, pname, pvalue);
    HashSet<LoginData*>::iterator it = m_logins.begin(), end = m_logins.end();
    for (; it!=end; ++it) {
        if ((*it)->match(*login)) {
            delete login;
            return;
        } else if((*it)->partialMatch(realm, uname, uvalue, pname)) {
            // new password for the same login
            m_logins.remove(it);
            m_logins.add(login);
            m_needCommit = true;
            return;
        }
    }

    // new entry
    m_logins.add(login);
    m_needCommit = true;
}

void FormLoginStore::remove(const String& realm, const String& uname, const String& uvalue, const String& pname, const String& pvalue)
{
    LoginData login(this, realm, uname, uvalue, pname, pvalue);
    HashSet<LoginData*>::iterator it = m_logins.begin(), end = m_logins.end();
    for (; it!=end; ++it) {
        if ((*it)->match(login)) {
            break;
        }
    }

    if (it!=end) {
        m_logins.remove(it);
        m_needCommit = true;
    }
}

void FormLoginStore::removePartial(const String& realm, const String& uname, const String& uvalue, const String& pname)
{
    HashSet<LoginData*>::iterator it = m_logins.begin(), end = m_logins.end();
    for(; it!=end; ++it) {
        if ((*it)->partialMatch(realm, uname, uvalue, pname)) {
            m_logins.remove(it);
            m_needCommit = true;
            return;
        }
    }
}

bool FormLoginStore::contains(const String& realm, const String& uname, const String& uvalue, const String& pname, const String& pvalue)
{
    LoginData login(this, realm, uname, uvalue, pname, pvalue);
    HashSet<LoginData*>::iterator it = m_logins.begin(), end = m_logins.end();
    for (; it!=end; ++it) {
        if ((*it)->match(login)) {
            return true;
        }
    }
    return false;
}

void FormLoginStore::removeLoginsForRealm(const String& realm)
{
    HashSet<LoginData*>::iterator it = m_logins.begin(), end = m_logins.end();
    Vector<LoginData*> loginsToDelete;

    for (; it!=end; ++it) {
        if( (*it)->realm() == realm ) {
            loginsToDelete.append( *it );
        }
    }

    for (int i=0; i<loginsToDelete.size(); ++i) {
        m_logins.remove(loginsToDelete[i]);
        m_needCommit = true;
    }
}

bool FormLoginStore::search(const String& realm, const String& uname, const String& uvalue, const String& pname, String& pvalue)
{
    HashSet<LoginData*>::const_iterator it = m_logins.begin(), end = m_logins.end();
    for (; it != end; ++it) {
        if ((*it)->partialMatch(realm, uname, uvalue, pname)) {
            pvalue = (*it)->passwdValue();
            return true;
        }
    }
    return false;
}

// login file format: (Note: this is not the most compact format, 
// however we need to keep it this way in order to be backward compatible.)
// 
// # of blacklist entries
// url #1
// url #2
// ...
// # of logins
// encryption data for logins
//  #1 realm, usernamefield, usernamevalue, passwdfield, passwdvalue
//  #2 realm, usernamefield, usernamevalue, passwdfield, passwdvalue
// ...
void FormLoginStore::commit()
{
    if (!m_needCommit) return;

	RProcess myProcess;	
	TBuf <256>fileName;    
    fileName.Format(KLoginDatFile, myProcess.Identity());
    String s(fileName.Ptr(), fileName.Length());
	FileStreamOutput stream(s);
 
    if (stream.isOpened()) {
        // blacklist
        stream<<(m_blackList.size());
        for (HashSet<String>::const_iterator it=m_blackList.begin(), end = m_blackList.end(); it != end; ++it) {
            stream<<(*it);
        }

        // login count
        stream<<(m_logins.size());
        
        // write the encryption data if we have logins
        if (m_logins.size()>0) {
            if (!m_pbEncrypt)
                m_pbEncrypt = CPBEncryptElement::NewL(_L8(""), ECipher3DES_CBC);
            m_pbEncrypt->EncryptionData().ExternalizeL(stream.platformStream());
        }
        
        // now logins
        for (HashSet<LoginData*>::const_iterator it=m_logins.begin(), end = m_logins.end(); it != end; ++it) {
            stream<<(*(*it));
        }

        delete m_pbEncrypt;
        m_pbEncrypt = 0;
    }

    m_needCommit = false;
}

void FormLoginStore::initialize()
{
 	RProcess myProcess;	
	TBuf <256>fileName;    
    fileName.Format(KLoginDatFile, myProcess.Identity());
    String s(fileName.Ptr(), fileName.Length());
	FileStreamInput stream(s);
   
    if (stream.isOpened()) {
        // black-list
        int bsize = 0;
        stream>>bsize;
        for (int i=0; i<bsize; ++i) {
            String realm;
            stream>>realm;
            m_blackList.add(realm);
        }

        // logins
        int lsize = 0;
        stream>>lsize;

        CPBEncryptionData* encryptionData = 0;
        if (lsize) {
            // prepare for decryption 
            encryptionData = CPBEncryptionData::NewL(stream.platformStream());
            if (!m_pbDecrypt)
                m_pbDecrypt = CPBEncryptElement::NewL(*encryptionData, _L(""));
        }

        for (int i=0; i<lsize; ++i) {
            LoginData* d = new LoginData(this);
            stream>>(*d);
            m_logins.add(d);
        }

        // encryptionData is not needed any more
        delete encryptionData;
        delete m_pbDecrypt;
        m_pbDecrypt = 0;
    }
}

void FormLoginStore::clearCache()
{
    m_blackList.clear();
    HashSet<LoginData*>::const_iterator it = m_logins.begin(), end = m_logins.end();
    for(; it!=end; ++it)
        delete (*it);
    m_logins.clear();
}

void FormLoginStore::deleteAll()
{
    // clear the file data
    clearCache();
    m_needCommit = true;
    commit();
}

String FormLoginStore::encrypt(const String& src)
{
    if (!m_pbEncrypt)
        return src;

    CPBEncryptor* encryptor = m_pbEncrypt->NewEncryptLC();
    int len = encryptor->MaxFinalOutputLength(src.length()<<1);
    UChar* data = new UChar[len>>1];
    TPtrC8 in((const TUint8*)(src.characters()), src.length()<<1);
    TPtr8 out((TUint8*)data, 0, len);
    encryptor->ProcessFinalL(in, out);
    CleanupStack::Pop();  // encryptor
    delete encryptor;

    String result(data, len>>1);
    delete data;

    return result;
}

String FormLoginStore::decrypt(const String& src)
{
    if (!m_pbDecrypt) 
        return src;

	CPBDecryptor* decryptor = m_pbDecrypt->NewDecryptLC();
    int len = decryptor->MaxFinalOutputLength(src.length()<<1);
    len += (len&0x01);
    UChar* data = new UChar[len>>1];
    memset(data, 0x00, len);
    TPtrC8 in((const TUint8*)(src.characters()), src.length()<<1);
    TPtr8 out((TUint8*)data, 0, len);
    decryptor->ProcessFinalL(in, out);
    CleanupStack::Pop(); // decryptor
    delete decryptor;

    // now figure out the padding position
    int sz=0;
    for (int i=0; i<len>>1; ++i) {
        if (data[i] == 0) break;
        sz++;
    }
        
    String result(data, sz);
    delete data;

    return result;
}

}