1 /*

     2 * Copyright (c) 2001-2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of the License "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  EAP and WLAN authentication protocols.

    15 *

    16 */

    17 

    18 

    19 

    20 

    21 #if !defined(_AKA_RESULT_H_)

    22 #define _AKA_RESULT_H_

    23 

    24 #include "eap_variable_data.h"

    25 #include "eap_am_export.h"

    26 #include "eap_type_aka_header.h"

    27 

    28 

    29 

    30 class EAP_EXPORT aka_fixed_data_c

    31 {

    32 private:

    33 	//--------------------------------------------------

    34 

    35 	bool m_is_valid;

    36 	aka_payload_AT_header_c m_original_header;

    37 	u16_t m_type;

    38 	u16_t m_data;

    39 

    40 	//--------------------------------------------------

    41 protected:

    42 	//--------------------------------------------------

    43 

    44 	//--------------------------------------------------

    45 public:

    46 	//--------------------------------------------------

    47 

    48 	EAP_FUNC_IMPORT virtual ~aka_fixed_data_c();

    49 

    50 	EAP_FUNC_IMPORT aka_fixed_data_c(

    51 		abs_eap_am_tools_c * const tools);

    52 

    53 	EAP_FUNC_IMPORT bool get_is_valid() const;

    54 

    55 	EAP_FUNC_IMPORT const aka_payload_AT_header_c * get_original_header();

    56 

    57 	EAP_FUNC_IMPORT u16_t get_type(abs_eap_am_tools_c * const m_am_tools) const;

    58 

    59 	EAP_FUNC_IMPORT u16_t get_data(abs_eap_am_tools_c * const m_am_tools) const;

    60 

    61 	EAP_FUNC_IMPORT void set_data(

    62 		const aka_payload_AT_header_c * const original_header,

    63 		const u16_t type, const u16_t data);

    64 

    65 	//--------------------------------------------------

    66 }; // class aka_fixed_data_c

    67 

    68 

    69 class EAP_EXPORT aka_variable_data_c

    70 {

    71 private:

    72 	//--------------------------------------------------

    73 

    74 	abs_eap_am_tools_c * const m_am_tools;

    75 

    76 	eap_variable_data_c m_data;

    77 

    78 	aka_payload_AT_header_c m_original_header;

    79 

    80 	bool m_payload_included;

    81 

    82 	//--------------------------------------------------

    83 protected:

    84 	//--------------------------------------------------

    85 

    86 	//--------------------------------------------------

    87 public:

    88 	//--------------------------------------------------

    89 

    90 	EAP_FUNC_IMPORT virtual ~aka_variable_data_c();

    91 

    92 	EAP_FUNC_IMPORT aka_variable_data_c(abs_eap_am_tools_c * const tools);

    93 

    94 	EAP_FUNC_IMPORT const aka_payload_AT_header_c * get_original_header() const;

    95 

    96 	EAP_FUNC_IMPORT eap_status_e set_buffer(

    97 		const aka_payload_AT_header_c * const original_header,

    98 		u8_t *buffer,

    99 		const u32_t buffer_length,

   100 		const bool free_buffer,

   101 		const bool is_writable);

   102 

   103 	EAP_FUNC_IMPORT bool get_payload_included() const;

   104 

   105 	EAP_FUNC_IMPORT u32_t get_data_length() const;

   106 

   107 	EAP_FUNC_IMPORT u8_t * get_data(const u32_t data_length) const;

   108 

   109 	EAP_FUNC_IMPORT eap_variable_data_c * get_payload_buffer();

   110 

   111 	EAP_FUNC_IMPORT bool get_is_valid() const;

   112 

   113 	EAP_FUNC_IMPORT eap_status_e reset();

   114 

   115 	//--------------------------------------------------

   116 }; // class aka_variable_data_c

   117 

   118 

   119 //--------------------------------------------------

   120 

   121 

   122 // 

   123 class EAP_EXPORT aka_payloads_c

   124 {

   125 private:

   126 	//--------------------------------------------------

   127 

   128 	abs_eap_am_tools_c * const m_am_tools;

   129 

   130 	eap_variable_data_c m_all_payloads;

   131 

   132 	aka_variable_data_c m_nonce_s;

   133 

   134 	aka_variable_data_c m_MAC;

   135 

   136 	aka_variable_data_c m_ENCR_DATA;

   137 

   138 	aka_variable_data_c m_IDENTITY_payload;

   139 

   140 	aka_variable_data_c m_padding_payload;

   141 

   142 	aka_variable_data_c m_RAND;

   143 

   144 	aka_variable_data_c m_AUTN;

   145 

   146 	aka_variable_data_c m_AUTS;

   147 

   148 	aka_variable_data_c m_RES;

   149 

   150 	aka_variable_data_c m_PERMANENT_ID_REQ;

   151 

   152 	aka_variable_data_c m_FULLAUTH_ID_REQ;

   153 

   154 	aka_variable_data_c m_ANY_ID_REQ;

   155 

   156 	aka_variable_data_c m_IV;

   157 

   158 	aka_variable_data_c m_NEXT_PSEUDONYM;

   159 

   160 	aka_variable_data_c m_NEXT_REAUTH_ID;

   161 

   162 	aka_variable_data_c m_NOTIFICATION;

   163 

   164 	aka_variable_data_c m_COUNTER;

   165 

   166 	aka_variable_data_c m_COUNTER_TOO_SMALL;

   167 

   168 	aka_variable_data_c m_CLIENT_ERROR_CODE;

   169 

   170 	aka_variable_data_c m_RESULT_IND;

   171 

   172 	aka_variable_data_c m_CHECKCODE;

   173 

   174 	aka_payload_AT_type_e m_unknown_payload;

   175 

   176 	bool m_includes_other_version_than_1;

   177 

   178 	bool m_is_valid;

   179 

   180 	//--------------------------------------------------

   181 protected:

   182 	//--------------------------------------------------

   183 

   184 	//--------------------------------------------------

   185 public:

   186 	//--------------------------------------------------

   187 

   188 

   189 	enum eap_aka_payload_status_e

   190 	{

   191 		eap_aka_payload_status_optional,

   192 		eap_aka_payload_status_must_be,

   193 		eap_aka_payload_status_must_not_be

   194 	};

   195 

   196 

   197 	EAP_FUNC_IMPORT virtual ~aka_payloads_c();

   198 

   199 	EAP_FUNC_IMPORT aka_payloads_c(

   200 		abs_eap_am_tools_c * const tools);

   201 

   202 	EAP_FUNC_IMPORT bool check_one_payload(

   203 		const eap_aka_payload_status_e status,

   204 		const aka_variable_data_c * const payload);

   205 

   206 	/** This function checks the correct set of payloads are included in the message.

   207 	 *  NOTE do not change the order of parameters.

   208 	 *  Add new payload type to the last of the parameter list.

   209 	 */

   210 	EAP_FUNC_IMPORT bool check_payloads(

   211 		const eap_aka_payload_status_e nonce_s,

   212 		const eap_aka_payload_status_e MAC,

   213 		const eap_aka_payload_status_e ENCR_DATA,

   214 		const eap_aka_payload_status_e IDENTITY,

   215 		const eap_aka_payload_status_e padding,

   216 		const eap_aka_payload_status_e n_RANDs,

   217 		const eap_aka_payload_status_e AUTN,

   218 		const eap_aka_payload_status_e AUTS,

   219 		const eap_aka_payload_status_e RES,

   220 		const eap_aka_payload_status_e PERMANENT_ID_REQ,

   221 		const eap_aka_payload_status_e FULLAUTH_ID_REQ,

   222 		const eap_aka_payload_status_e ANY_ID_REQ,

   223 		const eap_aka_payload_status_e IV,

   224 		const eap_aka_payload_status_e NEXT_PSEUDONYM,

   225 		const eap_aka_payload_status_e NEXT_REAUTH_ID,

   226 		const eap_aka_payload_status_e NOTIFICATION,

   227 		const eap_aka_payload_status_e COUNTER,

   228 		const eap_aka_payload_status_e COUNTER_TOO_SMALL,

   229 		const eap_aka_payload_status_e CLIENT_ERROR_CODE,

   230 		const eap_aka_payload_status_e RESULT_IND,

   231 		const eap_aka_payload_status_e CHECKCODE

   232 		);

   233 

   234 	eap_variable_data_c * const get_all_payloads()

   235 	{

   236 		return static_cast<eap_variable_data_c *>(&m_all_payloads);

   237 	}

   238 

   239 	aka_variable_data_c * const get_NONCE_S()

   240 	{

   241 		return static_cast<aka_variable_data_c *>(&m_nonce_s);

   242 	}

   243 

   244 	aka_variable_data_c * const get_MAC()

   245 	{

   246 		return static_cast<aka_variable_data_c *>(&m_MAC);

   247 	}

   248 

   249 	aka_variable_data_c * const get_ENCR_DATA()

   250 	{

   251 		return static_cast<aka_variable_data_c *>(&m_ENCR_DATA);

   252 	}

   253 

   254 	aka_variable_data_c * const get_IDENTITY_payload()

   255 	{

   256 		return static_cast<aka_variable_data_c *>(&m_IDENTITY_payload);

   257 	}

   258 

   259 	aka_variable_data_c * const get_padding_payload()

   260 	{

   261 		return static_cast<aka_variable_data_c *>(&m_padding_payload);

   262 	}

   263 

   264 	aka_variable_data_c * const get_RAND()

   265 	{

   266 		return static_cast<aka_variable_data_c *>(&m_RAND);

   267 	}

   268 

   269 	aka_variable_data_c * const get_AUTN()

   270 	{

   271 		return static_cast<aka_variable_data_c *>(&m_AUTN);

   272 	}

   273 

   274 	aka_variable_data_c * const get_AUTS()

   275 	{

   276 		return static_cast<aka_variable_data_c *>(&m_AUTS);

   277 	}

   278 

   279 	aka_variable_data_c * const get_RES()

   280 	{

   281 		return static_cast<aka_variable_data_c *>(&m_RES);

   282 	}

   283 

   284 	aka_variable_data_c * const get_PERMANENT_ID_REQ()

   285 	{

   286 		return static_cast<aka_variable_data_c *>(&m_PERMANENT_ID_REQ);

   287 	}

   288 

   289 	aka_variable_data_c * const get_FULLAUTH_ID_REQ()

   290 	{

   291 		return static_cast<aka_variable_data_c *>(&m_FULLAUTH_ID_REQ);

   292 	}

   293 

   294 	aka_variable_data_c * const get_ANY_ID_REQ()

   295 	{

   296 		return static_cast<aka_variable_data_c *>(&m_ANY_ID_REQ);

   297 	}

   298 

   299 	aka_variable_data_c * const get_IV()

   300 	{

   301 		return static_cast<aka_variable_data_c *>(&m_IV);

   302 	}

   303 

   304 	aka_variable_data_c * const get_NEXT_PSEUDONYM()

   305 	{

   306 		return static_cast<aka_variable_data_c *>(&m_NEXT_PSEUDONYM);

   307 	}

   308 

   309 	aka_variable_data_c * const get_NEXT_REAUTH_ID()

   310 	{

   311 		return static_cast<aka_variable_data_c *>(&m_NEXT_REAUTH_ID);

   312 	}

   313 

   314 	aka_variable_data_c * const get_NOTIFICATION()

   315 	{

   316 		return static_cast<aka_variable_data_c *>(&m_NOTIFICATION);

   317 	}

   318 

   319 	aka_variable_data_c * const get_RESULT_IND()

   320 	{

   321 		return static_cast<aka_variable_data_c *>(&m_RESULT_IND);

   322 	}

   323 

   324 	aka_variable_data_c * const get_CHECKCODE()

   325 	{

   326 		return static_cast<aka_variable_data_c *>(&m_CHECKCODE);

   327 	}

   328 

   329 	aka_variable_data_c * const get_CLIENT_ERROR_CODE()

   330 	{

   331 		return static_cast<aka_variable_data_c *>(&m_CLIENT_ERROR_CODE);

   332 	}

   333 

   334 	aka_variable_data_c * const get_COUNTER()

   335 	{

   336 		return static_cast<aka_variable_data_c *>(&m_COUNTER);

   337 	}

   338 

   339 	aka_variable_data_c * const get_COUNTER_TOO_SMALL()

   340 	{

   341 		return static_cast<aka_variable_data_c *>(&m_COUNTER_TOO_SMALL);

   342 	}

   343 

   344 

   345 	void set_includes_unknown_attribute(const aka_payload_AT_type_e unknown_payload);

   346 

   347 	aka_payload_AT_type_e get_includes_unknown_attribute();

   348 

   349 

   350 	void set_includes_other_version_than_1(const bool includes_other_version_than_1);

   351 

   352 	bool get_includes_other_version_than_1();

   353 

   354 

   355 	bool get_is_valid() const;

   356 

   357 	//--------------------------------------------------

   358 }; // class aka_payloads_c

   359 

   360 

   361 #endif //#if !defined(_AKA_RESULT_H_)

   362 

   363 //--------------------------------------------------

   364 

   365 

   366 

   367 // End.