/*

* Copyright (c) 2005 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 <e32math.h>

#include <siperr.h>

#include <sdpcodecerr.h>

#include <sdpdocument.h>

#include <siptoheader.h>

#include <sipdialog.h>

#include <sipcallidheader.h>

#include <sipcseqheader.h>

#include <sipretryafterheader.h>

#include <sipcontactheader.h>

#include <sipsupportedheader.h>

#include <siprequireheader.h>

#include <sipallowheader.h>

#include <sipprofile.h>

#include <siprseqheader.h>

#include <siprackheader.h>

#include "mcesip.h"

#include "mcedefs.h"

const CSIPTransactionBase::TState KMceTrxStateUndefined = 

    static_cast<CSIPTransactionBase::TState>(-1);

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

// MceSip::ResponseCode

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

//

TUint MceSip::ResponseCode( CSIPClientTransaction& aResponse )

    {

    return aResponse.ResponseElements()->StatusCode();

    }

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

// MceSip::ResponseType

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

//

TMceSipResponseType MceSip::ResponseType( CSIPClientTransaction& aResponse )

    {

    TUint responseCode = ResponseCode( aResponse );

    return ResponseType( responseCode );

    }

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

// MceSip::ResponseType

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

//

TMceSipResponseType MceSip::ResponseType( TUint aCode )

    {

    if ( aCode < KMceSipOK )//200

        {

        return E1XX;

        }

    else if ( aCode < KMceSipMultipleChoices )//300

        {

        return E2XX;

        }

    else if ( aCode < KMceSipBadRequest )//400

        {

        return E3XX;

        }

    else if ( aCode < KMceSipServerInternalError )//500

        {

        return E4XX;

        }

    else if ( aCode < KMceSipBusyEverywhere )//600

        {

        return E5XX;

        }

    else 

        {

        return E6XX;

        }   

    }

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

// MceSip::ReasonPhraseL

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

//

RStringF MceSip::ReasonPhraseL( TUint aStatusCode )

    {

    RStringF phrase;

    switch( aStatusCode )

        {

        case KMceSipOK:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseOk );

            break;

            }

        case KMceSipBadRequest:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseBadRequest );

            break;

            }

        case KMceSipUnauthorized:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseUnauthorized );

            break;

            }

        case KMceSipForbidden:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseForbidden );

            break;

            }

        case KMceSipNotFound:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseNotFound );

            break;

            }

        case KMceSipMethodNotAllowed:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseMethodNotAllowed );

            break;

            }

        case KMceSip4XXNotAcceptable:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseNotAcceptableHere );

            break;

            }

        case KMceSipProxyAuthenticationRequired:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseProxyAuthenticationRequired );

            break;

            }

        case KMceSipRequestTimeout:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseRequestTimeout );

            break;

            }

        case KMceSipUnsupportedMediaType:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseUnsupportedMediaType );

            break;

            }

        case KMceSipUnsupportedURIScheme:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseUnsupportedURIScheme );

            break;

            }

        case KMceSipBadExtension:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseBadExtension );

            break;

            }

        case KMceSipExtensionRequired:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseExtensionRequired );

            break;

            }

        case KMceSipSessionIntervalTooSmall:

        case KMceSipIntervalTooBrief:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseIntervalTooBrief );

            break;

            }

        case KMceSipTemporarilyUnavailable:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseTemporarilyNotAvailable );

            break;

            }

        case KMceSipCallOrTransactionDoesNotExist:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseCallTransactionDoesNotExist );

            break;

            }

        case KMceSipLoopDetected:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseLoopDetected );

            break;

            }

        case KMceSipTooManyHops:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseTooManyHops );

            break;

            }

        case KMceSipBusyHere:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseBusyHere );

            break;

            }

        case KMceSipRequestTerminated:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseRequestTerminated );

            break;

            }

        case KMceSipNotAcceptableHere:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseNotAcceptableHere );

            break;

            }

        case KMceSipBadEvent:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseBadEvent );

            break;

            }

        case KMceSipRequestPending:

            {

            phrase = SIPStrings::Pool().OpenFStringL( KMceSipPhraseRequestPending() );

            break;

            }

        case KMceSipServerInternalError:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseServerInternalError );

            break;

            }

        case KMceSipNotImplemented:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseNotImplemented );

            break;

            }        

        case KMceSipServiceUnavailable:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseServiceUnavailable );

            break;

            }

        case KMceSipVersionNotSupported:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseVersionNotSupported );

            break;

            }

        case KMceSipDecline:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseDecline );

            break;

            }

        case  KMceSipServerTimeOut:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EPhraseRequestTimeout );

            break;

            }

        default:

            {

            phrase = SIPStrings::StringF( SipStrConsts::EEmpty );

            break;

            }

        }

    return phrase;

    }

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

// MceSip::IsResponseTo

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

//

TBool MceSip::IsResponseTo( CSIPClientTransaction& aResponse, RStringF aMethod )

    {

    return &aResponse != NULL && aResponse.Type() == aMethod;

    }

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

// MceSip::TrxCompleted

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

//

TBool MceSip::TrxCompleted( CSIPTransactionBase& aTransaction )

    {

    // Invite transaction which is in confirmed state can be removed as well,

    // as it means that error response has been already sent and SIP is 

    // just waiting for acks for certain time (T4).

    CSIPTransactionBase::TState trxState = TrxState( aTransaction );

    return trxState == KMceTrxStateUndefined ||

           trxState == CSIPTransactionBase::ECompleted || 

           trxState == CSIPTransactionBase::ETerminated ||

           TrxType( aTransaction ) == SipStrConsts::EAck ||

           ( TrxType( aTransaction ) == SipStrConsts::EInvite &&

             trxState == CSIPTransactionBase::EConfirmed );

    }

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

// MceSip::TrxState

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

//

CSIPTransactionBase::TState MceSip::TrxState( 

                                    CSIPTransactionBase& aTransaction )

    {

    CSIPTransactionBase::TState trxState = KMceTrxStateUndefined;

    TRAP_IGNORE( ( trxState = aTransaction.StateL() ) );

    return trxState;

    }

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

// MceSip::TrxType

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

//

TInt MceSip::TrxType( CSIPTransactionBase& aTransaction )

    {

    return aTransaction.Type().Index( SIPStrings::Table() );

    }

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

// MceSip::WarningPhraseL

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

//

RStringF MceSip::WarningPhraseL( TUint aWarnCode )

    {

    RStringF warningPhrase;

    switch( aWarnCode )

        {

        case KMceSipWarnIncompatibleNetworkProtocol:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase300() );

            break;

            }

        case KMceSipWarnIncompatibleNetworkAddressFormat:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase301() );

            break;

            }

        case KMceSipWarnIncompatibleTransportProtocol:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase302() );

            break;

            }

        case KMceSipWarnIncompatibleBandwidthUnits:

            {

            warningPhrase =

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase303() );

            break;

            }

        case KMceSipWarnMediaTypeNotAvailable:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase304() );

            break;

            }

        case KMceSipWarnIncompatibleMediaFormat:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase305() );

            break;

            }

        case KMceSipWarnAttributeNotUnderstood:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase306() );

            break;

            }

        case KMceSipWarnSessionDescriptionParameterNotUnderstood:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase307() );

            break;

            }

        case KMceSipWarnMulticastNotAvailable:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase330() );

            break;

            }

        case KMceSipWarnUnicastNotAvailable:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase331() );

            break;

            }

        case KMceSipWarnInsufficientBandwidth:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase370() );

            break;

            }

        case KMceSipWarnMiscellaneous:

            {

            warningPhrase = 

                SIPStrings::Pool().OpenFStringL( KMceSipWarnPhrase399() );

            break;

            }

        default:

            {

            warningPhrase = SIPStrings::StringF( SipStrConsts::EEmpty );

            break;

            }

        }

    return warningPhrase;

    }

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

// MceSip::IsSIPStackError

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

//

TBool MceSip::IsSIPStackError( TInt aError )

    {

    return IsSDPError( aError ) ||

        ( aError >= KErrSIPInvalidURIType 

        && aError <= KErrSIPMalformedMessage );

    }

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

// MceSip::IsSDPError

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

//

TBool MceSip::IsSDPError( TInt aError )

    {

    return aError >= KErrSdpCodecDecode && aError <= KErrSdpCodecVersionField;

    }

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

// MceSip::ErrorResponse

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

//

void MceSip::ErrorResponse( TInt aError, 

                            TUint& aSIPResponseCode, 

                            TInt& aReasonPhrase )

    {

    if ( IsSDPError( aError ) )

        {

        aSIPResponseCode = KMceSipBadRequest;

        aReasonPhrase = SipStrConsts::EPhraseBadRequest;

        }

    else 

        {

        aSIPResponseCode = KMceSipServerInternalError;

        aReasonPhrase = SipStrConsts::EPhraseServerInternalError;

        }

    }

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

// MceSip::DiscardRequest

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

//

TInt MceSip::DiscardRequest( CSIPServerTransaction& aRequest, TInt aError,

                             TBool aRetryIndication  )

    {

    TInt status = KErrNone;

    TRAP( status, DoDiscardRequestL( aRequest, aError, aRetryIndication ) );

    return status;

    }

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

// MceSip::DiscardRequest

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

//

TInt MceSip::DiscardRequest( CSIPServerTransaction* aRequest, TInt aError,

                             TBool aRetryIndication  )

    {

    TInt status = DiscardRequest( *aRequest, aError, aRetryIndication );

    delete aRequest;

    return status;

    }

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

// MceSip::Method

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

//

RStringF MceSip::Method( CSIPServerTransaction& aRequest )

    {

    const CSIPRequestElements* request = aRequest.RequestElements();

    if ( request )

        {

        return request->Method();

        }

    else

        {

        return SIPStrings::StringF( SipStrConsts::EEmpty );

        }

    }

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

// MceSip::AddressToTextL

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

//

HBufC8* MceSip::AddressToTextL( const CSIPAddress& aToAddr )

    {

    HBufC8* address = aToAddr.ToTextLC();

    CleanupStack::Pop( address );

    return address;

    }

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

// MceSip::ToFromHeaderL

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

//

CSIPFromHeader* MceSip::ToFromHeaderL( const TDesC8& aAddress )

    {

	CSIPAddress* sipAddressFrom = CSIPAddress::DecodeL( aAddress );    

	CleanupStack::PushL( sipAddressFrom );

	CSIPFromHeader* fromHeader = CSIPFromHeader::NewL( sipAddressFrom );

    CleanupStack::Pop( sipAddressFrom );

    return fromHeader;