/*

* Copyright (c) 2007-2010 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 FILES

#include "cmmstaticutility.h"

#include "nokiatsy_internal_variation.h"

#include "tsylogger.h"

#include <etelmm.h>

#include <etelmmerr.h>

#include <etelsat.h>

#include <exterror.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/rmmcustomapi.h>

#include <call_modemisi.h>

#include <csdisi.h>

#include <ss_wmisi.h>

#include <net_modemisi.h>

#include <smsisi.h>

#include <pipeisi.h>

#include <gpdsisi.h>

#include <pipe_sharedisi.h>

#include <in_sock.h>

#include <f32file.h>

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmstaticutilityTraces.h"

#endif

#include "cmmuiccmesshandler.h"

// EXTERNAL DATA STRUCTURES

    // None

// EXTERNAL FUNCTION PROTOTYPES

    // None

// CONSTANTS

const TUint8 KNotAllowed = 0x01;

const TUint8 KAllowedWithModifications = 0x02;

// MACROS

    // None

// LOCAL CONSTANTS AND MACROS

    // None

// MODULE DATA STRUCTURES

#ifdef __WINSCW__

    TBool apacInfoToBeReturned;

#endif // __WINSCW__

// LOCAL FUNCTION PROTOTYPES

    // None

// ======================= LOCAL FUNCTIONS =====================================

    // None

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

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

// CMmStaticUtility::CSCauseToEpocError

// Converts CS cause to EPOC error value

// (other items were commented in a header).

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

//

TInt CMmStaticUtility::CSCauseToEpocError

        (

        TInt aResource, // CALL, SS, NET etc

        TUint8 aIsiCauseType, // Cause type

        TUint8 aIsiCauseValue // Cause value

        )

    {

TFLOGSTRING4("TSY: CMmStaticUtility::CSCauseToEpocError - resource: %d, cause type: %d, cause value: %d", aResource, aIsiCauseType, aIsiCauseValue);

    TInt epocError = ( KErrGeneral & 0x0000FFFF ) | ( KErrNotFound << 16 );

    if ( 0 == aIsiCauseValue && 0 == aIsiCauseType )

        {

        return KErrNone;

        }

    switch ( aResource )

        {

        case PN_MODEM_CALL:

            {

            // Common error

            if ( CALL_MODEM_CAUSE_TYPE_CLIENT == ( aIsiCauseType & 0x0F ) ||

                CALL_MODEM_CAUSE_TYPE_SERVER == ( aIsiCauseType & 0x0F ) )

                {

                // NOTE

                //

                // Following Error Mapping is HIGHLY GSM ISA 3.0 CALL SERVER

                // dependent. Following information was received 9.9.2002 from

                // the person that is in responsible of GSM ISA 3.0 Call server.

                //

                switch ( aIsiCauseValue )

                    {

                    // This is used only with CALL_DTMF_STATUS_IND when audio

                    // connection is suddenly disconnected by lower layers (and

                    // with CALL_STATUS_RESP when there are no other calls,

                    // CALL_STATUS_REQ/RESP is not used by MMTSY).

                    case CALL_MODEM_CAUSE_NO_CALL:

                    case CALL_MODEM_CAUSE_NO_CALL_ACTIVE:

                        {

                        epocError = EpocErrorCode( KErrEtelCallNotActive,

                            KErrMMEtelCallTerminated );

                        break;

                        }

                    // This is used when the local user disconnects the call.

                    // MMTSY maps this always to KErrNone. If remote user

                    // disconnects the call, network error code is used instead.

                    case CALL_MODEM_CAUSE_RELEASE_BY_USER:

                        {

                        epocError = EpocErrorCode( KErrGsmReleaseByUser,

                            KErrNotFound );

                        break;

                        }

                    // This occurs for example if Hold is requested when Call is

                    // not active, DTMF sending is requested if call is not

                    // active etc.

                    case CALL_MODEM_CAUSE_ERROR_REQUEST:

                        {

                        epocError = EpocErrorCode( KErrNotReady,

                            KErrNotFound );

                        break;

                        }

                    // This is used with Autohold if network rejects it

                    case CALL_MODEM_CAUSE_CALL_ACTIVE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrNotFound );

                        break;

                        }

                    // This is used if Emergency call fails.

                    case CALL_MODEM_CAUSE_EMERGENCY_FAILURE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCResourceNotAvailable );

                        break;

                        }

                    // This is used with Autohold if network rejects it

                    // This is used if call mode changing fails

                    case CALL_MODEM_CAUSE_INVALID_CALL_MODE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCBearerCapabilityNotAuthorised );

                        break;

                        }

                    // If there are other calls active when emergency call is

                    // activated, normal calls will be terminated with this

                    // error value

                    case CALL_MODEM_CAUSE_EMERGENCY:

                        {

                        epocError = EpocErrorCode( KErrAbort,

                            KErrGsmRRPreEmptiveRelease );

                        break;

                        }

                    // PIN number has not been given by user -> only emergency

                    // calls allowed

                    case CALL_MODEM_CAUSE_CODE_REQUIRED:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsm0707SimPin1Required );

                        break;

                        }

                    // This is a basic error value returned when something is

                    // not allowed. Used in various situations inside the Call

                    // Server

                    case CALL_MODEM_CAUSE_NOT_ALLOWED:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrMMEtelCallForbidden );

                        break;

                        }

                    // Used in rarely occuring DTMF buffer handling errors. Not

                    // really used.

                    case CALL_MODEM_CAUSE_DTMF_ERROR:

                        {

                        epocError = EpocErrorCode( KErrArgument,

                            KErrMMEtelFormatNotSupported );

                        break;

                        }

                    // This is used only if re-establihment procedure fails

                    // which means that channel to the NW is lost and it can not

                    // be set-up again. This feature is supported very rarely by

                    // networks.

                    case CALL_MODEM_CAUSE_CHANNEL_LOSS:

                        {

                        epocError = EpocErrorCode( KErrEtelNoCarrier,

                            KErrMMEtelNetworkNotResponding );

                        break;

                        }

                    // This is used with CALL_CREATE_RESP when dialled number

                    // has not been in the FDN list -> dialling to the requested

                    // number has not been allowed.

                    case CALL_MODEM_CAUSE_FDN_NOT_OK:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsmInvalidFdn );

                        break;

                        }

                    // Dialled number is in blacklist -> calling to this number

                    // is not allowed

                    case CALL_MODEM_CAUSE_BLACKLIST_BLOCKED:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrMMEtelCallForbidden );

                        break;

                        }

                    // Dialled number is in blacklist -> calling to this number

                    // has been delayed and dialling is not allowed until

                    // specified time (see 3GPP specs) has elapsed.

                    case CALL_MODEM_CAUSE_BLACKLIST_DELAYED:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrMMEtelCallForbidden );

                        break;

                        }

                    // Indicates that SIM card has not been inserted

                    case CALL_MODEM_CAUSE_NO_SIM:

                        {

                        epocError = EpocErrorCode( KErrNotReady,

                            KErrGsm0707SimNotInserted );

                        break;

                        }

                    // Error comes when dial is made when there is no network

                    case CALL_MODEM_CAUSE_NO_SERVICE:

                        {

                        epocError = EpocErrorCode( KErrCouldNotConnect,

                            KErrGsmNoService );

                        break;

                        }

                    // Not used by GSM ISA Call server: checking of

                    // parameters has been left to the client's responsibility

                    case CALL_MODEM_CAUSE_TOO_LONG_ADDRESS:

                        {

                        epocError = EpocErrorCode( KErrArgument,

                            KErrNotFound );

                        break;

                        }

                    case CALL_MODEM_CAUSE_BUSY_USER_REQUEST:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCallRejected );

                        break;

                        }

                    case CALL_MODEM_CAUSE_INCOMPATIBLE_DEST:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCBearerCapabilityNotAuthorised );

                        break;

                        }

                    // Not used by GSM ISA Call server: checking of

                    // parameters has been left to the client's responsibility

                    case CALL_MODEM_CAUSE_INVALID_ADDRESS:

                    default:

                        {

TFLOGSTRING2("TSY: CMmStaticUtility::CSCauseToEpocError - PN_MODEM_CALL - common error, default, ISI cause value: %d", aIsiCauseValue);

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrNotFound );

                        break;

                        }

                    }

                }

            else if ( CALL_MODEM_CAUSE_TYPE_NETWORK == ( aIsiCauseType & 0x0F ) )

                {

                switch ( aIsiCauseValue )

                    {

                    case CALL_MODEM_NW_CAUSE_UNASSIGNED_NUMBER:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCUnassignedNumber );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NO_ROUTE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCNoRouteToDestination );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_CH_UNACCEPTABLE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCChannelUnacceptable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_OPER_BARRING:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsmCCOperatorDeterminedBarring );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NORMAL:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCNormalUnspecified );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_USER_BUSY:

                        {

                        epocError = EpocErrorCode( KErrEtelBusyDetected,

                            KErrGsmCCUserBusy );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NO_USER_RESPONSE:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCUserNotResponding );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_ALERT_NO_ANSWER:

                        {

                        epocError = EpocErrorCode( KErrEtelNoAnswer,

                            KErrGsmCCUserAlertingNoAnswer );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_CALL_REJECTED:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCCallRejected );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NUMBER_CHANGED:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCNumberChanged );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NON_SELECT_CLEAR:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCNonSelectedUserClearing );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_DEST_OUT_OF_ORDER:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCDestinationOutOfOrder );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_INVALID_NUMBER:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCInvalidNumberFormat );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_FACILITY_REJECTED:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCFacilityRejected );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_RESP_TO_STATUS:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCResponseToStatusEnquiry );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NORMAL_UNSPECIFIED:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCNormalUnspecified );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NO_CHANNEL:

                        {

                        epocError = EpocErrorCode( KErrEtelNoCarrier,

                            KErrGsmCCNoChannelAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NETW_OUT_OF_ORDER:

                        {

                        epocError = EpocErrorCode( KErrEtelNoCarrier,

                            KErrGsmCCNetworkOutOfOrder );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_TEMPORARY_FAILURE:

                        {

                        epocError = EpocErrorCode( KErrEtelNoCarrier,

                            KErrGsmCCTemporaryFailure );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_CONGESTION:

                        {

                        epocError = EpocErrorCode( KErrEtelNoCarrier,

                            KErrGsmCCSwitchingEquipmentCongestion );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_ACCESS_INFO_DISC:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCAccessInformationDiscarded );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_CHANNEL_NA:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCRequestedChannelNotAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_RESOURCES_NA:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCResourceNotAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_QOS_NA:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCQualityOfServiceNotAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_FACILITY_UNSUBS:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCRequestedFacilityNotSubscribed );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_COMING_BARRED_CUG:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsmCCIncomingCallsBarredInCug );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_BC_UNAUTHORIZED:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCBearerCapabilityNotAuthorised );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_BC_NA:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCBearerCapabilityNotCurrentlyAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_SERVICE_NA:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCServiceNotAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_BEARER_NOT_IMPL:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCServiceNotImplemented );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_ACM_MAX:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsmCCAcmGreaterThanAcmMax );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_FACILITY_NOT_IMPL:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCRequestedFacilityNotImplemented );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_ONLY_RDI_BC:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCOnlyRestrictedDigitalInformationBCAvailable );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_SERVICE_NOT_IMPL:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCServiceNotImplemented );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_INVALID_TI:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCInvalidCallReferenceValue );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_NOT_IN_CUG:

                        {

                        epocError = EpocErrorCode( KErrAccessDenied,

                            KErrGsmCCUserNotInCug );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_INCOMPATIBLE_DEST:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCIncompatibleDestination );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_INV_TRANS_NET_SEL:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCInvalidTransitNetworkSelection );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_SEMANTICAL_ERR:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCSemanticallyIncorrectMessage );

                        break;

                        }

                    case CALL_MODEM_NW_CAUSE_INVALID_MANDATORY:

                        {

                        epocError = EpocErrorCode( KErrGeneral,

                            KErrGsmCCInvalidMandatoryInformation );

                        break;