accesssec_plat/eap_type_api/inc/EapType.h
branchRCL_3
changeset 18 bad0cc58d154
parent 2 1c7bc153c08e
child 19 c74b3d9f6b9e
equal deleted inserted replaced
17:30e048a7b597 18:bad0cc58d154
    14 * Description:  EAP and WLAN authentication protocols.
    14 * Description:  EAP and WLAN authentication protocols.
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 /*
    18 /*
    19 * %version: 18.1.3 %
    19 * %version: 33 %
    20 */
    20 */
    21 
    21 
    22 #ifndef _EAPTYPE_H_
    22 #ifndef _EAPTYPE_H_
    23 #define _EAPTYPE_H_
    23 #define _EAPTYPE_H_
    24 
    24 
    25 // INCLUDES
    25 // INCLUDES
    26 #include <e32base.h>
    26 #include <e32base.h>
    27 #include <ecom/ecom.h> 
    27 #include <ecom/ecom.h> 
    28 
    28 
    29 #include <EapSettings.h>
    29 #include <EapSettings.h>
       
    30 #include <EapTypeDefinitions.h>
    30 
    31 
    31 // FORWARD DECLARATIONS
    32 // FORWARD DECLARATIONS
    32 class abs_eap_am_tools_c;
    33 class abs_eap_am_tools_c;
    33 class eap_base_type_c;
    34 class eap_base_type_c;
    34 class abs_eap_base_type_c;
    35 class abs_eap_base_type_c;
    37 
    38 
    38 #ifndef RD_WLAN_3_1_BACKPORTING
    39 #ifndef RD_WLAN_3_1_BACKPORTING
    39 class abs_eap_configuration_if_c;
    40 class abs_eap_configuration_if_c;
    40 #endif
    41 #endif
    41 
    42 
    42 // LOCAL DATA
       
    43 // The UID for EAP plugin interface. ECom uses this.
       
    44 const TUid KEapTypeInterfaceUid = {0x101f8e4a};
       
    45 
       
    46 /// Possible services.
       
    47 enum TIndexType
       
    48 {
       
    49 	EDialoutISP,
       
    50 	EDialinISP,
       
    51 	EOutgoingGPRS,
       
    52 	ELan,
       
    53 	EVpn
       
    54 };
       
    55 
       
    56 struct SIapInfo {
       
    57 	TIndexType indexType;
       
    58 	TInt index;
       
    59 }; 
       
    60 
       
    61 // CLASS DECLARATION
    43 // CLASS DECLARATION
    62 
    44 
    63 /**
    45 /**
    64 * The base interface class for EAP plug-in access.
    46 * The base interface class for EAP plug-in access.
    65 * Includes methods to create either the configuration interface or the EAP protocol interface.
    47 * Includes methods to create either the configuration interface or the EAP protocol interface.
    66 */
    48 */
    67 class CEapType : public CBase  
    49 class CEapType
       
    50 : public CBase
    68 {
    51 {
    69 public:
    52 public:
    70 
    53 
    71 	/**
    54     /**
    72 	* Factory function that loads the EAP type implementation DLL (plug-in).
    55     * Factory function that loads the Generic EAP type implementation DLL (plug-in).
    73 	* Uses ECom architecture to load the correct EAP type DLL. Calls the initialization
    56     * @param aIndexType Indicates the bearer used for this connection.
    74 	* function of the EAP type
    57     * @param aIndex Index for the connection. aIndexType and aIndex uniquely specify the connection.
    75 	* @param aCue EAP type id that specifies which plugin is loaded.
    58     * @return Pointer to the implementation.
    76 	* @param aIndexType Indicates the bearer used for this connection.
    59     */
    77 	* @param aIndex Index for the connection. aIndexType and aIndex uniquely specify the connection.
    60 	inline static CEapType* NewL(const TIndexType aIndexType, const TInt aIndex, const TEapExpandedType aEapType);
    78 	* @return Pointer to the implementation.
    61 
    79 	*/
       
    80 	inline static CEapType* NewL(const TDesC8& aCue, TIndexType aIndexType, TInt aIndex);	
       
    81 	
       
    82 	/**
    62 	/**
    83 	* Unloads the implementation DLL.
    63 	* Unloads the implementation DLL.
    84 	*/
    64 	*/
    85 	inline virtual ~CEapType();
    65 	inline virtual ~CEapType();
    86 
    66 
    87 #ifndef RD_WLAN_3_1_BACKPORTING
       
    88 
    67 
    89 	/**
       
    90 	* Creates EAP protocol interface implementation. Instances an object that
       
    91 	* has been derived from eap_base_type_c that handles the communication 
       
    92 	* with EAP stack. 
       
    93 	* @param aTools Pointer to tools class.
       
    94 	* @param aPartner Used for callbacks to the stack.
       
    95 	* @param is_client_when_true Specifies whether the EAP type acts as a client or server.
       
    96 	* @param receive_network_id Network addresses
       
    97 	* @param eap_config_if Pointer used for call back to creater of stack (eapol_am_wlan_authentication_symbian_c class).
       
    98 	* @return Pointer to the implementation.
       
    99 	*/		
       
   100 	virtual eap_base_type_c* GetStackInterfaceL(abs_eap_am_tools_c* const aTools, 
       
   101 											   abs_eap_base_type_c* const aPartner,
       
   102 											   const bool is_client_when_true,
       
   103 											   const eap_am_network_id_c * const receive_network_id,
       
   104 											   abs_eap_configuration_if_c * const configuration_if) = 0;
       
   105 
    68 
   106 #else
       
   107 
       
   108 	/**
       
   109 	* Creates EAP protocol interface implementation. Instances an object that
       
   110 	* has been derived from eap_base_type_c that handles the communication 
       
   111 	* with EAP stack. 
       
   112 	* @param aTools Pointer to tools class.
       
   113 	* @param aPartner Used for callbacks to the stack.
       
   114 	* @param is_client_when_true Specifies whether the EAP type acts as a client or server.
       
   115 	* @param receive_network_id Network addresses
       
   116 	* @return Pointer to the implementation.
       
   117 	*/		
       
   118 
       
   119 	virtual eap_base_type_c* GetStackInterfaceL(abs_eap_am_tools_c* const aTools, 
       
   120 											   abs_eap_base_type_c* const aPartner,
       
   121 											   const bool is_client_when_true,
       
   122 											   const eap_am_network_id_c * const receive_network_id) = 0;
       
   123 	
       
   124 #endif // #ifndef RD_WLAN_3_1_BACKPORTING
       
   125 
       
   126 	/**
       
   127 	* Invokes the configuration UI. Displays a dialog for configuring the EAP type settings.
       
   128 	*/
       
   129 	virtual TInt InvokeUiL() = 0;
       
   130 	
       
   131 	/**
    69 	/**
   132 	* Gets information about EAP type. 
    70 	* Gets information about EAP type. 
   133 	* @return Pointer to a class that contains the EAP type information. Also pushed to cleanup stack.
    71 	* @return Pointer to a class that contains the EAP type information. Also pushed to cleanup stack.
   134 	*/
    72 	*/
   135 	virtual CEapTypeInfo* GetInfoLC() = 0;
    73 	virtual CEapTypeInfo* GetInfoL() = 0;
   136 	
    74 
   137 	/**
    75 	/**
   138 	* Deletes EAP type configuration
    76 	* Deletes EAP type configuration
   139 	*/	
    77 	*/	
   140 	virtual void DeleteConfigurationL() = 0;
    78 	virtual void DeleteConfigurationL() = 0;
   141 
    79 
   148 	* @return Integer indicating the version.
    86 	* @return Integer indicating the version.
   149 	*/
    87 	*/
   150 	virtual TUint GetInterfaceVersion() = 0;
    88 	virtual TUint GetInterfaceVersion() = 0;
   151 
    89 
   152 	/**
    90 	/**
   153 	* Parses the opaque_data field in CImplementationInformation and returns true if
       
   154 	* string NOT_OUTSIDE_PEAP is found.
       
   155 	* @param aImplInfo Implementation info returned by ListImplementations call
       
   156 	* @return Boolean
       
   157 	*/
       
   158 	inline static TBool IsDisallowedOutsidePEAP(const CImplementationInformation& aImplInfo);
       
   159 
       
   160 	/**
       
   161 	* Parses the opaque_data field in CImplementationInformation and returns true if
       
   162 	* string NOT_INSIDE_PEAP is found.
       
   163 	* @param aImplInfo Implementation info returned by ListImplementations call
       
   164 	* @return Boolean
       
   165 	*/	
       
   166 	inline static TBool IsDisallowedInsidePEAP(const CImplementationInformation& aImplInfo);
       
   167 
       
   168 	/**
       
   169 	* Parses the opaque_data field in CImplementationInformation and returns true if
       
   170 	* string NOT_INSIDE_TTLS is found.
       
   171 	* @param aImplInfo Implementation info returned by ListImplementations call
       
   172 	* @return Boolean
       
   173 	*/	
       
   174 	inline static TBool IsDisallowedInsideTTLS(const CImplementationInformation& aImplInfo);
       
   175 
       
   176 	/**
       
   177 	* Sets the tunneling type. This is used to indicate that this type is run inside another 
    91 	* Sets the tunneling type. This is used to indicate that this type is run inside another 
   178 	* EAP type. 
    92 	* EAP type. 
   179 	* @param aTunnelingType Type number for the tunneling type
    93 	* @param aTunnelingType Type number for the tunneling type
   180 	*/	
    94 	*/	
   181 	virtual void SetTunnelingType(const TInt aTunnelingType) = 0;
    95 	virtual void SetTunnelingType(const TEapExpandedType aTunnelingType) = 0;
   182 	
    96 	
   183 	/**
    97 	/**
   184 	* Changes the index of the saved parameters.
    98 	* Changes the index of the saved parameters.
   185 	* @param aIndexType Indicates the bearer used for this connection.
    99 	* @param aIndexType Indicates the bearer used for this connection.
   186 	* @param aIndex Index for the connection. aIndexType and aIndex uniquely specify the connection.
   100 	* @param aIndex Index for the connection. aIndexType and aIndex uniquely specify the connection.