/*

* Copyright (c) 2004-2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* 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:

*

*

*/

#define TRACE_PREFIX "WSOCK: "

#include "wsock.h"

#include <utf.h>

#include <etelpckt.h>

#include <ApEngineConsts.h>

#include <CNetworkControllerBase.h>

#include "WinsockAgentFactory.h"

#include "WinsockProtocolFamily.h"

#include "WinsockInterfaceFactory.h"

#include "WinsockUtils.h"

_LIT(KProxyTableName,"Proxies");

static const TInt KDefaultProxyPort = 8080;

enum TProxyUpdateFlags

{

    TProxyUpdateUseProxy                = 0x00000001,

    TProxyUpdateServerName              = 0x00000002,

    TProxyUpdateProtocol                = 0x00000004,

    TProxyUpdatePort                    = 0x00000008,

    TProxyUpdateName                    = 0x00000010

};

enum TBearerUpdateFlags

{

    TBearerUpdateAgent                  = 0x00000001,

    TBearerUpdateSocketActivityTimeout  = 0x00000002,

    TBearerUpdateSessionClosedTimeout   = 0x00000004,

    TBearerUpdateSocketClosedTimeout    = 0x00000008

};

enum TServiceUpdateFlags

{

    TServiceUpdateNetworks              = 0x00000001,

    TServiceUpdateAuthPrompt            = 0x00000002,

    TServiceUpdateAPN                   = 0x00000004,

    TServiceUpdateAPType                = 0x00000008

};

enum TIAPUpdateFlags

{

    TIAPUpdateService                   = 0x00000001,

    TIAPUpdateServiceType               = 0x00000002,

    TIAPUpdateBearer                    = 0x00000004,

    TIAPUpdateBearerType                = 0x00000008,

    TIAPUpdateNetwork                   = 0x00000010

};

enum TWapIpBearerUpdateFlags

{

    TWapIpBearerUpdateIAP               = 0x00000001,

    TWapIpBearerUpdateWspOption         = 0x00000002,

    TWapIpBearerUpdateProxyPort         = 0x00000004,

    TWapIpBearerUpdateSecurity          = 0x00000008,

    TWapIpBearerUpdateGatewayAddress    = 0x00000010,

    TWapIpBearerUpdateProxyLoginName    = 0x00000020,

    TWapIpBearerUpdateProxyLoginPass    = 0x00000040

};

#ifdef _REALLY_DEBUG

extern "C" int __stdcall IsDebuggerPresent(void);

void WsockAssert(const TText* s, const TText* file, TInt line)

{

    TRACE1("Assertion failed: %s",s);

    TRACE1("File: %s",file);

    TRACE1("Line: %d",line);

    #ifdef WSOCK_ASSERT_BREAKPOINT

    if (IsDebuggerPresent())

    {

        __BREAKPOINT();

    }

    #endif

}

TInt WsockAssertSuccess(TInt err, const TText* s, const TText* file, TInt line)

{

    if (err != KErrNone)

    {

        TRACE1("Unexpected error: %d",err);

        TRACE1("Expression: %s",s);

        TRACE1("File: %s",file);

        TRACE1("Line: %d",line);

        #ifdef WSOCK_ASSERT_BREAKPOINT

        if (IsDebuggerPresent())

        {

            __BREAKPOINT();

        }

        #endif

    }

    return err;

}

void WsockLeave(TInt err, const TText* s, const TText* file, TInt line)

{

    TRACE2("Leaving with error %d (%s)",err,s);

    TRACE1("File: %s",file);

    TRACE1("Line: %d",line);

    #ifdef WSOCK_ASSERT_BREAKPOINT

    if (IsDebuggerPresent())

    {

        __BREAKPOINT();

    }

    #endif

    User::Leave(err);

}

void WsockLeaveIfError(TInt err, const TText* s, const TText* file, TInt line)

{

    if (err != KErrNone)

    {

        TRACE1("Unexpected error: %d",err);

        TRACE1("Expression: %s",s);

        TRACE1("File: %s",file);

        TRACE1("Line: %d",line);

        #ifdef WSOCK_ASSERT_BREAKPOINT

        if (IsDebuggerPresent())

        {

            __BREAKPOINT();

        }

        #endif

        User::Leave(err);

    }

}

#endif // _REALLY_DEBUG

// WSOCK lock

class WsockLock

{

private:

    TBool iLocked;

    RMutex iMutex;

public:

    WsockLock() : iLocked(EFalse) {}

    ~WsockLock() {

        ASSERT(!iLocked);

        if (iLocked) Unlock();

    }

    // Locks the mutex, returning KErrNone on success

    TInt Lock()

    {

        _LIT(KMutexName, "WsockLock");

        ASSERT(!iLocked);

        TInt err = iMutex.CreateGlobal(KMutexName, EOwnerThread);

        while (err == KErrAlreadyExists) {

            err = iMutex.OpenGlobal(KMutexName, EOwnerThread);

            if (err == KErrNone) {

                TRACE("opened existing CommDb mutex");

            } else {

                TRACE("couldn't either create or open CommDb mutex, retry");

                err = iMutex.CreateGlobal(KMutexName, EOwnerThread);

            }

        }

        ASSERT_SUCCESS(err);

        if (err == KErrNone) {

            iMutex.Wait();

            iLocked = ETrue;

        }

        return err;

    }

    // Locks the mutex, leaves on failure

    void LockL()

    {

        LEAVE_IF_ERROR(Lock());

    }

    // Locks the mutex, leaves on failure, sets up cleanup callback

    void LockLC()

    {

        LEAVE_IF_ERROR(Lock());

        CleanupStack::PushL(TCleanupItem(UnlockOnLeave,this));

    }

    // Releases the mutex

    void Unlock()

    {

        ASSERT(iLocked);

        if (iLocked) {

            iLocked = EFalse;

            iMutex.Signal();

            iMutex.Close();

        }

    }

    // Cleanup callback. Unlocks WsockLock

    static void UnlockOnLeave(TAny* aPtr)

    {

        WsockLock* lock = (WsockLock*)aPtr;

        lock->Unlock();

    }

};

// Cleanup callback. Rolls back the transaction

static void WsockRollbackOnLeave(TAny* aDb)

{

    CCommsDatabase* db = (CCommsDatabase*)aDb;

    db->RollbackTransaction();

}

// Begins CommDb transaction

static void WsockBeginCommDbTransactionLC(CCommsDatabase* aDb)

{

    TInt err = aDb->BeginTransaction();

    TInt retriesLeft = KRetryCount;

    while ((err == KErrLocked || err == KErrAccessDenied) && --retriesLeft)

    {

        User::After(KRetryWait);

        err = aDb->BeginTransaction();

    }

    LEAVE_IF_ERROR(err); // Leaves if error

    CleanupStack::PushL(TCleanupItem(WsockRollbackOnLeave,aDb));

}

// Checks proxy settings in CommDb. Returns ETrue if transaction needs

// to be commited. If aProxyHost is NULL, does not check the proxy values,

// only makes sure that there is on and only one proxy record in CommDb.

// If we allow more than one record, Symbian HTTP framework gets confused

// what to use and more often than not uses the wrong one. Particularly,

// it appears to prefer proxy records associated with OutgoingGPRS service,

// ignoring LANService.

static TBool WsockCheckProxyL(CCommsDatabase* aDb,

                              TUint32 aServiceId,

                              TBool aUseProxy,

                              const TDesC* aProxyHost,

                              TUint aProxyPort)

{

    _LIT(KProxyProtocol,"http");

    _LIT(KProxyName, "Winsock Proxy Settings");

    const TDesC& TableName = KProxyTableName();

    const TDesC& ServiceType = KWinsockServiceType();

    TRACE1("examining %S table...",&TableName);

    CCommsDbTableView* view = aDb->OpenTableLC(TableName);

    // Column names

    TPtrC IdColumn(COMMDB_ID);

    TPtrC NameColumn(COMMDB_NAME);

    TPtrC ISPColumn(PROXY_ISP);

    TPtrC UseProxyColumn(PROXY_USE_PROXY_SERVER);

    TPtrC ServiceTypeColumn(PROXY_SERVICE_TYPE);

    TPtrC ServerNameColumn(PROXY_SERVER_NAME);

    TPtrC ProtocolColumn(PROXY_PROTOCOL_NAME);

    TPtrC ProxyPortColumn(PROXY_PORT_NUMBER);

    // Delete everything except our record

    TInt err;

    TUint32 id = 0;

    TBool recordFound = EFalse;

    TBool databaseUpdated  = EFalse;

    if (view->GotoFirstRecord() == KErrNone)

    {

        TUint32 number = 0;

        TBuf<KCommsDbSvrMaxFieldLength> text;

        do

        {

            // This one must exist

            TRAP(err, view->ReadUintL(IdColumn, id));

            if (err == KErrNone)

            {

                // We detect our record based on the values of "ISP"

                // and "ProxyServiceType" columns

                number = 0;

                TRAP(err, view->ReadUintL(ISPColumn,number));

                TRAP(err, view->ReadTextL(ServiceTypeColumn,text));

                TRACE4("  %S #%d -> %d,%S",&TableName,id,number,&text);

                if (err == KErrNone &&

                    text == ServiceType &&

                    number == aServiceId &&

                    !recordFound)

                {

                    TUint updateFlags = 0;

                    if (aProxyHost)

                    {

                        TBool useProxy = EFalse;

                        TRAP(err, view->ReadBoolL(UseProxyColumn,useProxy));

                        if (err != KErrNone || useProxy != aUseProxy)

                        {

                            updateFlags |= TProxyUpdateUseProxy;

                        }

                        HBufC* val = NULL;

                        TRAP(err, val = view->ReadLongTextLC(ServerNameColumn);

                        CleanupStack::Pop(val));

                        if (err != KErrNone || *val != *aProxyHost)

                        {

                            updateFlags |= TProxyUpdateServerName;

                        }

                        delete val;

                        TRAP(err, view->ReadUintL(ProxyPortColumn,number));

                        if (err != KErrNone || number != aProxyPort)

                        {

                            updateFlags |= TProxyUpdatePort;

                        }

                    }

                    TRAP(err, view->ReadTextL(NameColumn,text));

                    if (err != KErrNone || text != KProxyName())

                    {

                        updateFlags |= TProxyUpdateName;

                    }

                    TRAP(err, view->ReadTextL(ProtocolColumn,text));

                    if (err != KErrNone || text != KProxyProtocol())

                    {

                        updateFlags |= TProxyUpdateProtocol;

                    }

                    if (updateFlags)

                    {

                        TRACE3("updating %S #%d (flags: %08X)",&TableName,id,updateFlags);

                        LEAVE_IF_ERROR(view->UpdateRecord());

                        if (updateFlags & TProxyUpdateUseProxy)

                        {

                            TRAP(err,view->WriteBoolL(UseProxyColumn,aUseProxy));

                            ASSERT_SUCCESS(err);

                        }

                        if (updateFlags & TProxyUpdateServerName)

                        {

                            TRAP(err,view->WriteLongTextL(ServerNameColumn,*aProxyHost));

                            ASSERT_SUCCESS(err);

                        }

                        if (updateFlags & TProxyUpdateName)

                        {

                            TRAP(err,view->WriteTextL(NameColumn,KProxyName()));

                            ASSERT_SUCCESS(err);

                        }

                        if (updateFlags & TProxyUpdateProtocol)

                        {

                            TRAP(err,view->WriteTextL(ProtocolColumn,KProxyProtocol()));

                            ASSERT_SUCCESS(err);

                        }

                        if (updateFlags & TProxyUpdatePort)

                        {

                            TRAP(err,view->WriteUintL(ProxyPortColumn,aProxyPort));

                            ASSERT_SUCCESS(err);

                        }

                        LEAVE_IF_ERROR(view->PutRecordChanges());

                        databaseUpdated = ETrue;

                    }

                    recordFound = ETrue;

                    continue;

                }

            }

            TRACE4("  deleting proxy record: %S #%d -> %d,%S",&TableName,id,number,&text);

            VERIFY_SUCCESS(view->DeleteRecord());

            databaseUpdated = ETrue;

        }

        while (view->GotoNextRecord() == KErrNone);

    }

    // Create a new entry if it doesn't exist

    if (!recordFound)

    {

        LEAVE_IF_ERROR(view->InsertRecord(id));

        const TDesC& host = aProxyHost ? (*aProxyHost) : KNullDesC();

        TRACE2("created %S #%d",&TableName,id);

        TRAP(err,view->WriteUintL(ISPColumn,aServiceId));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteTextL(ServiceTypeColumn,ServiceType));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteBoolL(UseProxyColumn, aUseProxy));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteTextL(NameColumn, KProxyName));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteTextL(ProtocolColumn, KProxyProtocol));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteUintL(ProxyPortColumn, aProxyPort));

        ASSERT_SUCCESS(err);

        TRAP(err,view->WriteLongTextL(ServerNameColumn, host));

        ASSERT_SUCCESS(err);

        LEAVE_IF_ERROR(view->PutRecordChanges());

        databaseUpdated = ETrue;

    }

    CleanupStack::PopAndDestroy(view);

    return databaseUpdated;

}

// Shortcut for making sure that there's no garbage in the proxy settings table

static TBool WsockCheckProxyL(CCommsDatabase* aDb, TUint32 aServiceId)

{

    return WsockCheckProxyL(aDb, aServiceId, EFalse, NULL, KDefaultProxyPort);

}

// Makes sure our IAP is in the Network table

static TBool WsockCheckNetworkL(CCommsDatabase* aDb, TUint32& aNetworkId)

{

    _LIT(KNetworkTable,"Network");

    const TDesC& TableName = KNetworkTable();

    TRACE1("examining %S table...",&TableName);

    CCommsDbTableView* view = aDb->OpenTableLC(TableName);

    // Column names

    TPtrC IdColumn(COMMDB_ID);

    TPtrC NameColumn(COMMDB_NAME);

    // Walk the table

    TInt err;

    TUint32 id = 0;

    TBool found = EFalse;

    TBool needCommit = EFalse;

    if (view->GotoFirstRecord() == KErrNone)

    {

        TBuf<KCommsDbSvrMaxFieldLength> text;

        do

        {

            // This one must exist

            TRAPD(err, view->ReadUintL(IdColumn, id));

            if (err == KErrNone)

            {

                TRAP(err, view->ReadTextL(NameColumn,text));

                TRACE3("  %S #%d -> %S",&TableName,id,&text);

                if (err == KErrNone && text == KWinsockAPName)

                {

                    if (!found)

                    {

                        found = ETrue;

                    }

                    else

                    {

                        TRACE1("  deleting record #%d",id);

                        LEAVE_IF_ERROR(view->DeleteRecord());

                        needCommit = ETrue;

                    }

                }

            }

        }

        while (view->GotoNextRecord() == KErrNone);

    }

    // Create a new entry if it doesn't exist

    if (!found)

    {

        LEAVE_IF_ERROR(view->InsertRecord(id));

        TRACE2("created %S #%d",&TableName,id);

        TRAP(err,view->WriteTextL(NameColumn, KWinsockAPName));

        ASSERT_SUCCESS(err);

        LEAVE_IF_ERROR(view->PutRecordChanges());

        needCommit = ETrue;

    }

    aNetworkId = id;

    CleanupStack::PopAndDestroy(view);

    return needCommit;

}

// Finds our records in CommDb, creating one if necessary. Returns ETrue

// if transaction needs to be commited.

static TBool WsockCheckBearerTypeL(CCommsDatabase* aDb, TUint32& aBearerId)

{

    const TDesC& TableName = KWinsockBearerType();

    TRACE1("examining %S table...",&TableName);

    CCommsDbTableView* view = aDb->OpenTableLC(TableName);

    TBuf<KCommsDbSvrMaxFieldLength> agent;

    agent.Copy(KWinsockAgent);

    agent.Append(_L(".agt"));

    // Column names

    TPtrC IdColumn(COMMDB_ID);

    TPtrC NameColumn(COMMDB_NAME);

    TPtrC IfNameColumn(IF_NAME);

    TPtrC AgentColumn(AGENT_NAME);

    TPtrC SocketActivityTimeoutColumn(LAST_SOCKET_ACTIVITY_TIMEOUT);

    TPtrC SessionClosedTimeoutColumn(LAST_SESSION_CLOSED_TIMEOUT);

    TPtrC SocketClosedTimeoutColumn(LAST_SOCKET_CLOSED_TIMEOUT);

    // Walk the table

    TInt err;

    TBool needCommit = EFalse;

    if (view->GotoFirstRecord() == KErrNone)

    {

        TUint32 number = 0;

        TBuf<KCommsDbSvrMaxFieldLength> text;

        do

        {

            // This one must exist

            TUint32 id = 0;

            TRAPD(err, view->ReadUintL(IdColumn, id));

            if (err == KErrNone)

            {

                // We detect our record based on the value of the "IfName"

                // column, it must point to our interface.

                TRAP(err, view->ReadTextL(IfNameColumn,text));

                TRACE3("  %S #%d -> %S",&TableName,id,&text);

                if (err == KErrNone && text == KWinsockInterface)

                {

                    aBearerId = id;

                    TUint updateFlags = 0;

                    TRAP(err, view->ReadTextL(AgentColumn,text));

                    if (err != KErrNone || text != agent)

                    {

                       updateFlags |= TBearerUpdateAgent;

                    }

                    TRAP(err, view->ReadUintL(SocketActivityTimeoutColumn,number));

                    if (err != KErrNone || number != KWinsockSocketActivityTimeout)

                    {

                       updateFlags |= TBearerUpdateSocketActivityTimeout;

                    }

                    TRAP(err, view->ReadUintL(SessionClosedTimeoutColumn,number));

                    if (err != KErrNone || number != KWinsockSessionClosedTimeout)

                    {

                       updateFlags |= TBearerUpdateSessionClosedTimeout;

                    }