1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // This file contains all the interfaces classes that can be implemented by

    15 // the Licensee LTSY relating to Security related features.

    16 //

    17 

    18 

    19 

    20 

    21 /**

    22  @file

    23  @internalAll 

    24 */

    25 

    26 

    27 #ifndef MLTSYDISPATCHSECURITYINTERFACE_H_

    28 #define MLTSYDISPATCHSECURITYINTERFACE_H_

    29 

    30 #include <ctsy/ltsy/mltsydispatchinterface.h>

    31 #include <etelmm.h>

    32 #include <ctsy/serviceapi/cmmutility.h>

    33 

    34 namespace DispatcherSecurity

    35 	{

    36 	

    37 	/**

    38 	 * This namespace contains all types relating to the Security dispatcher.

    39 	 */

    40 

    41 	enum TSecurityCodeId

    42 	    {   

    43 	    ESecCodeSecurity = 1,

    44 	    ESecCodePin,

    45 	    ESecCodePuk,

    46 	    ESecCodePin2,

    47 	    ESecCodePuk2,

    48 	    ESecCodeUpin = 7    

    49 	    };

    50 

    51 	}

    52 

    53 class MLtsyDispatchSecurityGetSecurityCodeInfo : public MLtsyDispatchInterface

    54 	{

    55 public:

    56 

    57 	static const TInt KLtsyDispatchSecurityGetSecurityCodeInfoApiId = KDispatchSecurityFuncUnitId + 1;

    58 

    59 	/**

    60 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetSecurityCodeInfo

    61 	 * request from the CTSY.

    62 	 *

    63 	 * It is a request call that is completed by invoking

    64 	 * CCtsyDispatcherCallback::CallbackSecurityGetSecurityCodeInfoComp()

    65 	 *

    66 	 * Implementation of this interface should allow a client to retrieve the current number or remaining entry attempts of a

    67      *  security code.

    68 	 *

    69 	 * @param aSecCode The security code whose information is to be retrieved.

    70 	 *

    71 	 * @return KErrNone on success, otherwise another error code indicating the

    72 	 * failure.

    73 	 */

    74 	virtual TInt HandleGetSecurityCodeInfoReqL(RMobilePhone::TMobilePhoneSecurityCode aSecCode) = 0;

    75 

    76 	}; // class MLtsyDispatchSecurityGetSecurityCodeInfo

    77 

    78 

    79 

    80 class MLtsyDispatchSecurityGetLockInfo : public MLtsyDispatchInterface

    81 	{

    82 public:

    83 

    84 	static const TInt KLtsyDispatchSecurityGetLockInfoApiId = KDispatchSecurityFuncUnitId + 2;

    85 

    86 	/**

    87 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneGetLockInfo

    88 	 * request from the CTSY.

    89 	 *

    90 	 * It is a request call that is completed by invoking

    91 	 * CCtsyDispatcherCallback::CallbackSecurityGetLockInfoComp()

    92 	 *

    93 	 * Implementation of this interface should retrieve the current status and setting of a lock.

    94 	 *

    95 	 * @param aLockType The lock type whose information is to be retrieved.

    96 	 *

    97 	 * @return KErrNone on success, otherwise another error code indicating the

    98 	 * failure.

    99 	 */

   100 	virtual TInt HandleGetLockInfoReqL(RMobilePhone::TMobilePhoneLock aLockType) = 0;

   101 

   102 	}; // class MLtsyDispatchSecurityGetLockInfo

   103 

   104 

   105 

   106 class MLtsyDispatchSecurityAbortSecurityCode : public MLtsyDispatchInterface

   107 	{

   108 public:

   109 

   110 	static const TInt KLtsyDispatchSecurityAbortSecurityCodeApiId = KDispatchSecurityFuncUnitId + 3;

   111 

   112 	/**

   113 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneAbortSecurityCode

   114 	 * request from the CTSY.

   115 	 *

   116 	 * It is a request call that is completed by invoking

   117 	 * CCtsyDispatcherCallback::CallbackSecurityAbortSecurityCodeComp()

   118 	 *

   119 	 * Implementation of this interface should inform the phone that the user has cancelled an outstanding 

   120      *  "get security code" or "verify security code" request.

   121 	 *

   122 	 * @param aSecCode Specifies which code request has been cancelled.

   123 	 *

   124 	 * @return KErrNone on success, otherwise another error code indicating the

   125 	 * failure.

   126 	 */

   127 	virtual TInt HandleAbortSecurityCodeReqL(RMobilePhone::TMobilePhoneSecurityCode aSecCode) = 0;

   128 

   129 	}; // class MLtsyDispatchSecurityAbortSecurityCode

   130 

   131 

   132 

   133 class MLtsyDispatchSecurityGetCurrentActivePin : public MLtsyDispatchInterface

   134 	{

   135 public:

   136 

   137 	static const TInt KLtsyDispatchSecurityGetCurrentActivePinApiId = KDispatchSecurityFuncUnitId + 4;

   138 

   139 	/**

   140 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsySecurityGetSimActivePinStateIPC

   141 	 * request from the CTSY.

   142 	 *

   143 	 * It is a request call that is completed by invoking

   144 	 * CCtsyDispatcherCallback::CallbackSecurityGetCurrentActivePinComp()

   145 	 *

   146 	 * Implementation of this interface should prepare the updating the information of the currently active PIN.

   147 	 *

   148 	 * @return KErrNone on success, otherwise another error code indicating the

   149 	 * failure.

   150 	 */

   151 	virtual TInt HandleGetCurrentActivePinReqL() = 0;

   152 

   153 	}; // class MLtsyDispatchSecurityGetCurrentActivePin

   154 

   155 

   156 

   157 class MLtsyDispatchSecuritySetLockSetting : public MLtsyDispatchInterface

   158 	{

   159 public:

   160 

   161 	static const TInt KLtsyDispatchSecuritySetLockSettingApiId = KDispatchSecurityFuncUnitId + 5;

   162 

   163 	/**

   164 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneSetLockSetting

   165 	 * request from the CTSY.

   166 	 *

   167 	 * It is a request call that is completed by invoking

   168 	 * CCtsyDispatcherCallback::CallbackSecuritySetLockSettingComp()

   169 	 *

   170 	 * Implementation of this interface should allow a client to change the current setting of a lock.

   171 	 *

   172 	 * @param aLock The lock to change.

   173 	 * @param aSetting The new settings for the lock.

   174 	 * @param aPassword The password paramaters.

   175 	 *

   176 	 * @return KErrNone on success, otherwise another error code indicating the

   177 	 * failure.

   178 	 * 

   179 	 * @see RMobilePhone::SetLockSetting()

   180 	 */

   181 	virtual TInt HandleSetLockSettingReqL(RMobilePhone::TMobilePhoneLock aLock, RMobilePhone::TMobilePhoneLockSetting aSetting, const TDesC& aPassword) = 0;

   182 

   183 	}; // class MLtsyDispatchSecuritySetLockSetting

   184 

   185 

   186 

   187 class MLtsyDispatchSecurityVerifySecurityCode : public MLtsyDispatchInterface

   188 	{

   189 public:

   190 

   191 	static const TInt KLtsyDispatchSecurityVerifySecurityCodeApiId = KDispatchSecurityFuncUnitId + 6;

   192 

   193 	/**

   194 	 * The CTSY Dispatcher shall invoke this function on receiving the EMobilePhoneVerifySecurityCode

   195 	 * request from the CTSY.

   196 	 *

   197 	 * It is a request call that is completed by invoking

   198 	 * CCtsyDispatcherCallback::CallbackSecurityVerifySecurityCodeComp()

   199 	 *

   200 	 * Implementation of this interface should send a security code requiring verification to the phone.

   201 	 * 

   202 	 *  If the security code required is one of the unblock codes (either PUK1 or 

   203 	 *  PUK2), then the user must supply a new PIN1 or PIN2 code as well as the associated 

   204 	 *  unblocking code. In this case, aUnblockCode will contain the unblocking code 

   205      *  and aCode will contain the new PIN1 or PIN2 value. If the security code required 

   206 	 *  is NOT one of the unblock codes, then the user only has to supply the one 

   207 	 *  security code. In this case, aUnblockCode will be invalid and aCode will contain 

   208 	 *  the required security code (PIN1, PIN2 or Phone Password).

   209 	 *

   210 	 * @param aSecCode The type of code that is to be verified.

   211 	 * @param aCodes The actual code and if a PUK1 or PUK2 is specified, the PUK code.

   212 	 *

   213 	 * @return KErrNone on success, otherwise another error code indicating the

   214 	 * failure.

   215 	 */

   216 	virtual TInt HandleVerifySecurityCodeReqL(

   217 				RMobilePhone::TMobilePhoneSecurityCode aSecCode,

   218 				const RMobilePhone::TCodeAndUnblockCode& aCodes) = 0;

   219 

   220 	}; // class MLtsyDispatchSecurityVerifySecurityCode

   221 

   222 class MLtsyDispatchSecurityGetPin1DisableSupported : public MLtsyDispatchInterface

   223 	{

   224 public:

   225 	static const TInt KLtsyDispatchSecurityGetPin1DisableSupportedApiId = KDispatchSecurityFuncUnitId + 7;

   226 	/**

   227 	 * The CTSY Dispatcher shall invoke this function on receiving the EMmTsyPhoneGetPin1DisableSupportedIPC

   228 	 * request from the CTSY.

   229 	 *

   230 	 * It is a request call that is completed by invoking

   231 	 * CCtsyDispatcherCallback::CallbackSecurityGetPin1DisableSupportedComp()

   232 	 *

   233 	 * Implementation of this interface should complete whether the SIM supports disabling of PIN1.

   234 	 * This is retrieved from either the EFsst (defined in 3GPP TS 31.102) or

   235 	 * EFust (defined in 3GPP TS 11.11) tables.

   236 	 *

   237 	 * @return KErrNone on success, otherwise another error code indicating the

   238 	 * failure.

   239 	 */

   240 	virtual TInt HandleGetPin1DisableSupportedReqL() = 0;

   241 

   242 	}; // class MLtsyDispatchSimGetPin1DisableSupported

   243 	

   244 class MLtsyDispatchSecurityCheckSecurityCode : public MLtsyDispatchInterface

   245 	{

   246 public:

   247 	static const TInt KLtsyDispatchSecurityCheckSecurityCodeApiId = KDispatchSecurityFuncUnitId + 8;

   248 	/**

   249 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckSecurityCodeIPC

   250 	 * request from the CTSY.

   251 	 * 

   252 	 * It is a request call that is completed by invoking

   253 	 * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeComp()

   254 	 * 

   255 	 * Implementation of this interface should anwser the check security code request.

   256 	 *

   257 	 * @param aCodeID Code ID. 

   258 	 * @param aSecCode Security code (maximum length = KMaxMobilePasswordSize).

   259 	 *

   260 	 * @return KErrNone on success, otherwise another error code indicating the

   261 	 * failure.

   262 	 */

   263 	virtual TInt HandleCheckSecurityCodeReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID, const TDes& aSecCode) = 0;

   264 

   265 	}; // class MLtsyDispatchSecurityCheckSecurityCode

   266 

   267 

   268 class MLtsyDispatchSecurityDisablePhoneLock : public MLtsyDispatchInterface

   269 	{

   270 public:

   271 	static const TInt KLtsyDispatchSecurityDisablePhoneLockApiId = KDispatchSecurityFuncUnitId + 9;

   272 	/**

   273 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomDisablePhoneLockIPC

   274 	 * request from the CTSY.

   275 	 * 

   276 	 * It is a request call that is completed by invoking

   277 	 * CCtsyDispatcherCallback::CallbackSecurityDisablePhoneLockComp()

   278 	 *

   279 	 * Implementation of this interface should disable phone lock.

   280 	 *

   281 	 * @param aSecCode Security code (maximum length = KMaxMobilePasswordSize).

   282 	 *

   283 	 * @return KErrNone on success, otherwise another error code indicating the

   284 	 * failure.

   285 	 */

   286 	virtual TInt HandleDisablePhoneLockReqL(const TDesC& aSecCode) = 0;

   287 

   288 	}; // class MLtsyDispatchSecurityDisablePhoneLock

   289 

   290 class MLtsyDispatchSecurityGetCipheringInfo : public MLtsyDispatchInterface

   291 	{

   292 public:

   293 	static const TInt KLtsyDispatchSecurityGetCipheringInfoApiId = KDispatchSecurityFuncUnitId + 10;

   294 	/**

   295 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomGetCipheringInfoIPC

   296 	 * request from the CTSY.

   297 	 * 

   298 	 * It is a request call that is completed by invoking

   299 	 * CCtsyDispatcherCallback::CallbackSecurityGetCipheringInfoComp()

   300 	 * 

   301 	 * Implementation of this interface should allow retrieving ciphering info: indicator and ciphering status.

   302 	 *

   303 	 * @return KErrNone on success, otherwise another error code indicating the

   304 	 * failure.

   305 	 */

   306 	virtual TInt HandleGetCipheringInfoReqL() = 0;

   307 

   308 	}; // class MLtsyDispatchSecurityGetCipheringInfo

   309 

   310 

   311 class MLtsyDispatchSecurityIsSecurityCodeBlocked : public MLtsyDispatchInterface

   312 	{

   313 public:

   314 	static const TInt KLtsyDispatchSecurityIsSecurityCodeBlockedApiId = KDispatchSecurityFuncUnitId + 11;

   315 	/**

   316 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomIsBlockedIPC

   317 	 * request from the CTSY.

   318 	 * 

   319 	 * It is a request call that is completed by invoking

   320 	 * CCtsyDispatcherCallback::CallbackSecurityIsSecurityCodeBlockedComp()

   321 	 *

   322 	 * Implementation of this interface should support retrieving synchronously the information

   323 	 * if the security code is blocked or not. 

   324      *

   325 	 * @param aCodeID Code ID.

   326 	 *

   327 	 * @return KErrNone on success, otherwise another error code indicating the

   328 	 * failure.

   329 	 */

   330 	virtual TInt HandleIsSecurityCodeBlockedReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID) = 0;

   331 

   332 	}; // class MLtsyDispatchSecurityIsSecurityCodeBlocked

   333 

   334 class MLtsyDispatchSecurityCheckSecurityCodeCancel : public MLtsyDispatchInterface

   335 	{

   336 public:

   337 	static const TInt KLtsyDispatchSecurityCheckSecurityCodeCancelApiId = KDispatchSecurityFuncUnitId + 12;	

   338 	/**

   339 	 * The CTSY Dispatcher shall invoke this function on receiving the ECustomCheckSecurityCodeCancelIPC

   340 	 * request from the CTSY.

   341 	 * 

   342 	 * It is a request call that is completed by invoking

   343 	 * CCtsyDispatcherCallback::CallbackSecurityCheckSecurityCodeCancelComp()

   344 	 * 

   345 	 * Implementation of this interface should cancel check security code request.

   346 	 *

   347 	 * @param aCodeID Code ID.

   348 	 *

   349 	 * @return KErrNone on success, otherwise another error code indicating the

   350 	 * failure.

   351 	 */

   352 	virtual TInt HandleCheckSecurityCodeCancelReqL(DispatcherSecurity::TSecurityCodeId aSecCodeID) = 0;

   353 

   354 	}; // class MLtsyDispatchSecurityCheckSecurityCodeCancel

   355 

   356 	

   357 

   358 #endif /*MLTSYDISPATCHSECURITYINTERFACE_H_*/