|
1 /* |
|
2 * Copyright (c) 2005-2010 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: Class for WLAN EAPOL Plugin interface. |
|
15 * |
|
16 */ |
|
17 |
|
18 /* |
|
19 * %version: 13 % |
|
20 */ |
|
21 |
|
22 #include "core_wlan_eapol_if_message.h" |
|
23 #include "core_types.h" |
|
24 #include "core_tools.h" |
|
25 |
|
26 |
|
27 /** |
|
28 * Constructor |
|
29 */ |
|
30 core_wlan_eapol_if_parameter_c::core_wlan_eapol_if_parameter_c() |
|
31 : data_m( NULL ) |
|
32 , buffer_length_m( 0 ) |
|
33 , delete_buffer_m( false_t) |
|
34 { |
|
35 } |
|
36 |
|
37 /** |
|
38 * Constructor |
|
39 * |
|
40 * @param data Pointer to the TLV encoded data. |
|
41 * @param data_length Length of the TLV encoded data. |
|
42 */ |
|
43 core_wlan_eapol_if_parameter_c::core_wlan_eapol_if_parameter_c( |
|
44 u8_t *data, u32_t data_length ) |
|
45 : data_m( data ) |
|
46 , buffer_length_m( data_length ) |
|
47 , delete_buffer_m( false_t ) |
|
48 { |
|
49 } |
|
50 |
|
51 |
|
52 /** |
|
53 * Destructor. |
|
54 */ |
|
55 core_wlan_eapol_if_parameter_c::~core_wlan_eapol_if_parameter_c() |
|
56 { |
|
57 if ( delete_buffer_m ) |
|
58 { |
|
59 core_tools_c::fillz( data_m, buffer_length_m ); |
|
60 delete[] data_m; |
|
61 data_m = NULL; |
|
62 } |
|
63 } |
|
64 |
|
65 |
|
66 |
|
67 /** |
|
68 * Update content of parameter |
|
69 */ |
|
70 void core_wlan_eapol_if_parameter_c::update( |
|
71 u8_t *data, u32_t data_length ) |
|
72 { |
|
73 data_m = data; |
|
74 buffer_length_m = data_length; |
|
75 delete_buffer_m = false_t; |
|
76 } |
|
77 |
|
78 // ============================================================================ |
|
79 // General methods to handle parameters |
|
80 |
|
81 u32_t core_wlan_eapol_if_parameter_c::size() const |
|
82 { |
|
83 return WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + get_parameter_length(); |
|
84 } |
|
85 |
|
86 wlan_eapol_if_message_type_e core_wlan_eapol_if_parameter_c::get_parameter_type() const |
|
87 { |
|
88 return static_cast<wlan_eapol_if_message_type_e>( core_tools_c::get_u32_big_endian( |
|
89 &data_m[0], |
|
90 WLAN_EAPOL_MESSAGE_IF_TYPE_OFFSET )); |
|
91 } |
|
92 |
|
93 u32_t core_wlan_eapol_if_parameter_c::get_parameter_length() const |
|
94 { |
|
95 return core_tools_c::get_u32_big_endian( |
|
96 &data_m[0], |
|
97 WLAN_EAPOL_MESSAGE_IF_LENGTH_OFFSET ); |
|
98 } |
|
99 |
|
100 u8_t* core_wlan_eapol_if_parameter_c::get_data() const |
|
101 { |
|
102 return &data_m[0]; |
|
103 } |
|
104 |
|
105 |
|
106 |
|
107 |
|
108 |
|
109 // ============================================================================ |
|
110 // Parameter specific methods |
|
111 |
|
112 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data( |
|
113 wlan_eapol_if_message_type_e type, |
|
114 u32_t value ) |
|
115 { |
|
116 DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, u32_t value=%i)", type, value ); |
|
117 |
|
118 if ( type == wlan_eapol_if_message_type_u8_t ) |
|
119 { |
|
120 return set_parameter_data_u8_t( type, value ); |
|
121 } |
|
122 else if ( type == wlan_eapol_if_message_type_u16_t ) |
|
123 { |
|
124 return set_parameter_data_u16_t( type, value ); |
|
125 } |
|
126 else if ( type == wlan_eapol_if_message_type_boolean ) |
|
127 { |
|
128 return set_parameter_data_boolean( type, value ); |
|
129 } |
|
130 |
|
131 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) ); |
|
132 if ( error != core_error_ok ) |
|
133 { |
|
134 return error; |
|
135 } |
|
136 |
|
137 add_header( type, sizeof( value ) ); |
|
138 add_parameter_u32_t( value ); |
|
139 return core_error_ok; |
|
140 } |
|
141 |
|
142 |
|
143 |
|
144 |
|
145 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data( |
|
146 wlan_eapol_if_message_type_e type, |
|
147 const u8_t* data, |
|
148 u32_t length ) |
|
149 { |
|
150 DEBUG3( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, data=%08X, length=%i)", type, data, length ); |
|
151 |
|
152 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + length ); |
|
153 if ( error != core_error_ok ) |
|
154 { |
|
155 return error; |
|
156 } |
|
157 |
|
158 add_header( type, length ); |
|
159 |
|
160 if ( data == NULL || length == 0 ) |
|
161 { |
|
162 // Variable data and Array could be empty. In that case data is NULL. |
|
163 if ( type != wlan_eapol_if_message_type_array && |
|
164 type != wlan_eapol_if_message_type_variable_data ) |
|
165 { |
|
166 DEBUG( "core_wlan_eapol_if_parameter_c::set_parameter_data() - Illegal arguments" ); |
|
167 ASSERT( false_t ); |
|
168 return core_error_illegal_argument; |
|
169 } |
|
170 return core_error_ok; |
|
171 } |
|
172 else |
|
173 { |
|
174 core_tools_c::copy( |
|
175 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], |
|
176 data, |
|
177 length ); |
|
178 } |
|
179 return core_error_ok; |
|
180 } |
|
181 |
|
182 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data( |
|
183 wlan_eapol_if_message_type_e type, |
|
184 u32_t vendor_id, |
|
185 u32_t vendor_type ) |
|
186 { |
|
187 DEBUG3( "core_wlan_eapol_if_parameter_c::set_parameter_data(type=%i, vendor_id=%06X, vendor_type=%08X)", type, vendor_id, vendor_type ); |
|
188 if ( type != wlan_eapol_if_message_type_eap_type ) |
|
189 { |
|
190 return core_error_illegal_argument; |
|
191 } |
|
192 |
|
193 u32_t length( 8 ); // Size of EAP type. |
|
194 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + length ); |
|
195 if ( error != core_error_ok ) |
|
196 { |
|
197 return error; |
|
198 } |
|
199 |
|
200 add_header( type, length ); |
|
201 |
|
202 const u32_t eap_type = 254; // This is constant in Extended EAP type. |
|
203 vendor_id = (vendor_id & 0x00FFFFFF) ^ (eap_type<<24); |
|
204 vendor_id = core_tools_c::convert_host_to_big_endian( vendor_id ); |
|
205 core_tools_c::copy( |
|
206 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], |
|
207 &vendor_id, |
|
208 sizeof( vendor_id ) ); |
|
209 |
|
210 vendor_type = core_tools_c::convert_host_to_big_endian( vendor_type ); |
|
211 core_tools_c::copy( |
|
212 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( vendor_id )], |
|
213 &vendor_type, |
|
214 sizeof( vendor_type ) ); |
|
215 |
|
216 return core_error_ok; |
|
217 } |
|
218 |
|
219 |
|
220 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_boolean( |
|
221 wlan_eapol_if_message_type_e type, |
|
222 bool_t boolean ) |
|
223 { |
|
224 DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_boolean(type=%i, bool_t value=%i)", type, boolean ); |
|
225 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( boolean ) ); |
|
226 if ( error != core_error_ok ) |
|
227 { |
|
228 return error; |
|
229 } |
|
230 |
|
231 add_header( type, sizeof( boolean ) ); |
|
232 add_parameter_u32_t( boolean ); |
|
233 return core_error_ok; |
|
234 } |
|
235 |
|
236 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u16_t( |
|
237 wlan_eapol_if_message_type_e type, |
|
238 u16_t value ) |
|
239 { |
|
240 DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_u16_t(type=%i, u16_t value=%i)", type, value ); |
|
241 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) ); |
|
242 if ( error != core_error_ok ) |
|
243 { |
|
244 return error; |
|
245 } |
|
246 |
|
247 add_header( type, sizeof( value ) ); |
|
248 add_parameter_u16_t( value ); |
|
249 return core_error_ok; |
|
250 } |
|
251 |
|
252 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u8_t( |
|
253 wlan_eapol_if_message_type_e type, |
|
254 u8_t value ) |
|
255 { |
|
256 DEBUG2( "core_wlan_eapol_if_parameter_c::set_parameter_data_u8_t(type=%i, u8_t value=%i)", type, value ); |
|
257 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( value ) ); |
|
258 if ( error != core_error_ok ) |
|
259 { |
|
260 return error; |
|
261 } |
|
262 |
|
263 add_header( type, sizeof( value ) ); |
|
264 add_parameter_u8_t( value ); |
|
265 return core_error_ok; |
|
266 } |
|
267 |
|
268 |
|
269 core_error_e core_wlan_eapol_if_parameter_c::set_parameter_data_u64_t( |
|
270 u64_t data ) |
|
271 { |
|
272 DEBUG( "core_wlan_eapol_if_parameter_c::set_parameter_data_u64_t()" ); |
|
273 |
|
274 core_error_e error = reserve_buffer( WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( data ) ); |
|
275 if ( error != core_error_ok ) |
|
276 { |
|
277 return error; |
|
278 } |
|
279 |
|
280 add_header( wlan_eapol_if_message_type_u64_t, sizeof( data ) ); |
|
281 |
|
282 u64_t parameter_data = |
|
283 static_cast<u64_t>( ((data & 0xFF) << 56) |
|
284 | ((data & 0xFF00) << 40) |
|
285 | ((data & 0xFF0000) << 24) |
|
286 | ((data & 0xFF000000) << 8) |
|
287 | (((data >> 32) & 0xFF) << 24) |
|
288 | (((data >> 32) & 0xFF00) << 8) |
|
289 | (((data >> 32) & 0xFF0000) >> 8) |
|
290 | (((data >> 32) & 0xFF000000) >> 24) ); |
|
291 |
|
292 core_tools_c::copy( |
|
293 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], |
|
294 ¶meter_data, |
|
295 sizeof( parameter_data ) ); |
|
296 COMPILE_ASSERT( sizeof( parameter_data ) == 8 ); // Specification says this. |
|
297 return core_error_ok; |
|
298 } |
|
299 |
|
300 |
|
301 // ============================================================================ |
|
302 |
|
303 // All 32 bit values |
|
304 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
305 u32_t * value ) const |
|
306 { |
|
307 ASSERT( value ); |
|
308 wlan_eapol_if_message_type_e type = get_parameter_type(); |
|
309 if ( type == wlan_eapol_if_message_type_u32_t |
|
310 || type == wlan_eapol_if_message_type_function |
|
311 || type == wlan_eapol_if_message_type_eap_protocol_layer |
|
312 || type == wlan_eapol_if_message_type_eap_status |
|
313 || type == wlan_eapol_if_message_type_eapol_key_802_11_authentication_mode |
|
314 || type == wlan_eapol_if_message_type_eapol_key_authentication_type |
|
315 || type == wlan_eapol_if_message_type_eapol_key_type |
|
316 || type == wlan_eapol_if_message_type_eapol_tkip_mic_failure_type |
|
317 || type == wlan_eapol_if_message_type_eapol_wlan_authentication_state |
|
318 || type == wlan_eapol_if_message_type_error |
|
319 || type == wlan_eapol_if_message_type_RSNA_cipher ) |
|
320 { |
|
321 *value = get_parameter_u32_t(); |
|
322 return core_error_ok; |
|
323 } |
|
324 *value = 0; |
|
325 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u32_t ) - Error: parameter not found" ); |
|
326 return core_error_not_found; |
|
327 } |
|
328 |
|
329 // |
|
330 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
331 u64_t * value ) const |
|
332 { |
|
333 ASSERT( value ); |
|
334 if ( get_parameter_type() == wlan_eapol_if_message_type_u64_t ) |
|
335 { |
|
336 *value = get_parameter_u64_t(); |
|
337 return core_error_ok; |
|
338 } |
|
339 *value = 0; |
|
340 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u64_t ) - Error: parameter not found" ); |
|
341 return core_error_not_found; |
|
342 } |
|
343 |
|
344 // |
|
345 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
346 bool_t * value ) const |
|
347 { |
|
348 ASSERT( value ); |
|
349 if ( get_parameter_type() == wlan_eapol_if_message_type_boolean ) |
|
350 { |
|
351 *value = get_parameter_u32_t(); |
|
352 return core_error_ok; |
|
353 } |
|
354 *value = 0; |
|
355 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( bool_t ) - Error: parameter not found" ); |
|
356 return core_error_not_found; |
|
357 } |
|
358 |
|
359 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
360 u16_t * value ) const |
|
361 { |
|
362 ASSERT( value ); |
|
363 if ( get_parameter_type() == wlan_eapol_if_message_type_u16_t ) |
|
364 { |
|
365 *value = get_parameter_u16_t(); |
|
366 return core_error_ok; |
|
367 } |
|
368 *value = 0; |
|
369 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u16_t ) - Error: parameter not found" ); |
|
370 return core_error_not_found; |
|
371 } |
|
372 |
|
373 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
374 u8_t * value ) const |
|
375 { |
|
376 ASSERT( value ); |
|
377 if ( get_parameter_type() == wlan_eapol_if_message_type_u8_t ) |
|
378 { |
|
379 *value = get_parameter_u8_t(); |
|
380 return core_error_ok; |
|
381 } |
|
382 *value = 0; |
|
383 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( u8_t ) - Error: parameter not found" ); |
|
384 return core_error_not_found; |
|
385 } |
|
386 |
|
387 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
388 u8_t ** const data, |
|
389 u32_t * data_length ) const |
|
390 { |
|
391 ASSERT( data ); |
|
392 ASSERT( data_length ); |
|
393 // All structured parameters must be mentioned here. |
|
394 if ( get_parameter_type() == wlan_eapol_if_message_type_variable_data |
|
395 || get_parameter_type() == wlan_eapol_if_message_type_network_id |
|
396 || get_parameter_type() == wlan_eapol_if_message_type_session_key |
|
397 || get_parameter_type() == wlan_eapol_if_message_type_network_key |
|
398 || get_parameter_type() == wlan_eapol_if_message_type_protected_setup_credential |
|
399 || get_parameter_type() == wlan_eapol_if_message_type_eap_state_notification |
|
400 || get_parameter_type() == wlan_eapol_if_message_type_array ) |
|
401 { |
|
402 *data = &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET]; |
|
403 *data_length = get_parameter_length(); |
|
404 // If data length is zero, it is good to set also data pointer to NULL. |
|
405 if ( *data_length == 0 ) |
|
406 { |
|
407 *data = NULL; |
|
408 } |
|
409 return core_error_ok; |
|
410 } |
|
411 *data = NULL; |
|
412 *data_length = 0; |
|
413 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( non-basic types ) - Error: parameter not found" ); |
|
414 return core_error_not_found; |
|
415 } |
|
416 |
|
417 |
|
418 core_error_e core_wlan_eapol_if_parameter_c::get_parameter_data( |
|
419 u32_t * vendor_id, |
|
420 u32_t * vendor_type ) const |
|
421 { |
|
422 ASSERT( vendor_id ); |
|
423 ASSERT( vendor_type ); |
|
424 wlan_eapol_if_message_type_e type = get_parameter_type(); |
|
425 if ( type == wlan_eapol_if_message_type_eap_type ) |
|
426 { |
|
427 *vendor_id = core_tools_c::get_u32_big_endian( |
|
428 &data_m[0], |
|
429 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET ); |
|
430 |
|
431 if( ( *vendor_id >> 24 ) == 254 ) |
|
432 { |
|
433 *vendor_id &= 0x00FFFFFF; // Mask EAP-type constant (254) out |
|
434 |
|
435 *vendor_type = core_tools_c::get_u32_big_endian( |
|
436 &data_m[0], |
|
437 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET + sizeof( vendor_id ) ); |
|
438 } |
|
439 else // Not expanded EAP type, in this case EAP type is first byte of vendor_id |
|
440 { |
|
441 *vendor_type = ( *vendor_id >> 24 ); |
|
442 *vendor_id = 0; |
|
443 } |
|
444 |
|
445 return core_error_ok; |
|
446 } |
|
447 *vendor_id = 0; |
|
448 *vendor_type = 0; |
|
449 DEBUG( "core_wlan_eapol_if_parameter_c::get_parameter_data( vendor_id, vendor_type ) - Error: parameter not found" ); |
|
450 return core_error_not_found; |
|
451 } |
|
452 |
|
453 |
|
454 |
|
455 // ============================================================================ |
|
456 |
|
457 |
|
458 core_error_e core_wlan_eapol_if_parameter_c::reserve_buffer( |
|
459 u32_t needed_buffer_length ) |
|
460 { |
|
461 if ( needed_buffer_length <= buffer_length_m ) |
|
462 { |
|
463 return core_error_ok; |
|
464 } |
|
465 |
|
466 DEBUG2( "core_wlan_eapol_if_parameter_c::reserve_buffer - increase buffer %i->%i bytes", buffer_length_m, needed_buffer_length ); |
|
467 u8_t* p = new u8_t[needed_buffer_length]; |
|
468 if ( !p ) |
|
469 { |
|
470 DEBUG( "core_wlan_eapol_if_parameter_c::reserve_buffer - Error: No enough memory!" ); |
|
471 return core_error_no_memory; |
|
472 } |
|
473 core_tools_c::fillz( p, needed_buffer_length ); |
|
474 core_tools_c::copy( |
|
475 p, |
|
476 &data_m[0], |
|
477 buffer_length_m ); |
|
478 core_tools_c::fillz( &data_m[0], buffer_length_m ); |
|
479 |
|
480 if ( delete_buffer_m ) |
|
481 { |
|
482 delete[] data_m; |
|
483 } |
|
484 delete_buffer_m = true_t; |
|
485 data_m = p; |
|
486 buffer_length_m = needed_buffer_length; |
|
487 |
|
488 return core_error_ok; |
|
489 } |
|
490 |
|
491 |
|
492 void core_wlan_eapol_if_parameter_c::add_header( |
|
493 wlan_eapol_if_message_type_e type, |
|
494 u32_t length ) |
|
495 { |
|
496 // Type |
|
497 u32_t type_value( type ); |
|
498 type_value = core_tools_c::convert_host_to_big_endian( type_value ); |
|
499 core_tools_c::copy( |
|
500 &data_m[0], |
|
501 &type_value, |
|
502 sizeof( type_value ) ); |
|
503 COMPILE_ASSERT( sizeof( type_value ) == 4); // Specification says this. |
|
504 |
|
505 // Length |
|
506 u32_t parameter_length( length ); |
|
507 parameter_length = core_tools_c::convert_host_to_big_endian( parameter_length ); |
|
508 core_tools_c::copy( |
|
509 &data_m[WLAN_EAPOL_MESSAGE_IF_LENGTH_OFFSET], |
|
510 ¶meter_length, |
|
511 sizeof( parameter_length ) ); |
|
512 COMPILE_ASSERT( sizeof( parameter_length ) == 4); // Specification says this. |
|
513 } |
|
514 |
|
515 |
|
516 u64_t core_wlan_eapol_if_parameter_c::get_parameter_u64_t() const |
|
517 { |
|
518 u64_t value = core_tools_c::get_u32_big_endian( |
|
519 &data_m[0], |
|
520 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET ); |
|
521 value <<= 32; |
|
522 value += core_tools_c::get_u32_big_endian( |
|
523 &data_m[0], |
|
524 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET+4 ); |
|
525 |
|
526 return value; |
|
527 } |
|
528 |
|
529 |
|
530 |
|
531 void core_wlan_eapol_if_parameter_c::add_parameter_u32_t( |
|
532 u32_t data ) |
|
533 { |
|
534 u32_t parameter_data( data ); |
|
535 parameter_data = core_tools_c::convert_host_to_big_endian( parameter_data ); |
|
536 core_tools_c::copy( |
|
537 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], |
|
538 ¶meter_data, |
|
539 sizeof( parameter_data ) ); |
|
540 COMPILE_ASSERT( sizeof( parameter_data ) == 4); // Specification says this. |
|
541 } |
|
542 |
|
543 u32_t core_wlan_eapol_if_parameter_c::get_parameter_u32_t() const |
|
544 { |
|
545 return core_tools_c::get_u32_big_endian( |
|
546 &data_m[0], |
|
547 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET ); |
|
548 } |
|
549 |
|
550 void core_wlan_eapol_if_parameter_c::add_parameter_u16_t( |
|
551 u16_t data ) |
|
552 { |
|
553 u16_t parameter_data( data ); |
|
554 parameter_data = core_tools_c::convert_host_to_big_endian( parameter_data ); |
|
555 core_tools_c::copy( |
|
556 &data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET], |
|
557 ¶meter_data, |
|
558 sizeof( parameter_data ) ); |
|
559 COMPILE_ASSERT( sizeof( data ) == 2); // Specification says this. |
|
560 } |
|
561 |
|
562 u16_t core_wlan_eapol_if_parameter_c::get_parameter_u16_t() const |
|
563 { |
|
564 return core_tools_c::get_u16_big_endian( |
|
565 &data_m[0], |
|
566 WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET ); |
|
567 } |
|
568 |
|
569 void core_wlan_eapol_if_parameter_c::add_parameter_u8_t( |
|
570 u8_t data ) |
|
571 { |
|
572 data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET] = data; |
|
573 COMPILE_ASSERT( sizeof( data ) == 1 ); // Specification says this. |
|
574 } |
|
575 |
|
576 u8_t core_wlan_eapol_if_parameter_c::get_parameter_u8_t() const |
|
577 { |
|
578 return data_m[WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET]; |
|
579 } |
|
580 |
|
581 |
|
582 |
|
583 |
|
584 |
|
585 |
|
586 |
|
587 |
|
588 |
|
589 |
|
590 |
|
591 |
|
592 |
|
593 |
|
594 |
|
595 /** |
|
596 * Constructor |
|
597 */ |
|
598 core_wlan_eapol_if_function_c::core_wlan_eapol_if_function_c() |
|
599 : data_m( NULL ) |
|
600 , data_length_m( 0 ) |
|
601 , buffer_length_m( 0 ) |
|
602 , delete_buffer_m( false_t) |
|
603 , iter_m( 0 ) |
|
604 , current_parameter_m( ) |
|
605 { |
|
606 DEBUG( "core_wlan_eapol_if_function_c::core_wlan_eapol_if_function_c()" ); |
|
607 } |
|
608 |
|
609 /** |
|
610 * Constructor |
|
611 * |
|
612 * @param data Pointer to the IE data. |
|
613 * @param data_length Length of the IE data. |
|
614 */ |
|
615 core_wlan_eapol_if_function_c::core_wlan_eapol_if_function_c( |
|
616 u8_t * data, |
|
617 const u32_t length ) |
|
618 : data_m( data ) |
|
619 , data_length_m( length ) |
|
620 , buffer_length_m( 0 ) |
|
621 , delete_buffer_m( false_t) |
|
622 , iter_m( 0 ) |
|
623 , current_parameter_m( ) |
|
624 { |
|
625 // Update current_parameter_m |
|
626 first(); |
|
627 } |
|
628 |
|
629 /** |
|
630 * Destructor. |
|
631 */ |
|
632 core_wlan_eapol_if_function_c::~core_wlan_eapol_if_function_c() |
|
633 { |
|
634 if ( delete_buffer_m ) |
|
635 { |
|
636 core_tools_c::fillz( data_m, buffer_length_m ); |
|
637 delete[] data_m; |
|
638 data_m = NULL; |
|
639 } |
|
640 } |
|
641 |
|
642 wlan_eapol_if_message_type_e core_wlan_eapol_if_function_c::get_type() |
|
643 { |
|
644 first(); |
|
645 return static_cast<wlan_eapol_if_message_type_e>( current()->get_parameter_type() ); |
|
646 } |
|
647 |
|
648 wlan_eapol_if_message_type_function_e core_wlan_eapol_if_function_c::get_function() |
|
649 { |
|
650 first(); |
|
651 |
|
652 u32_t function; |
|
653 core_error_e error = current()->get_parameter_data( &function ); |
|
654 if ( error != core_error_ok ) |
|
655 { |
|
656 return wlan_eapol_if_message_type_function_none; |
|
657 } |
|
658 return static_cast<wlan_eapol_if_message_type_function_e>( function ); |
|
659 } |
|
660 |
|
661 core_error_e core_wlan_eapol_if_function_c::append( |
|
662 const core_wlan_eapol_if_parameter_c * const param ) |
|
663 { |
|
664 ASSERT( param != NULL ); |
|
665 core_error_e error = reserve_buffer( data_length_m + param->size() ); |
|
666 if ( error != core_error_ok ) |
|
667 { |
|
668 return error; |
|
669 } |
|
670 |
|
671 core_tools_c::copy( |
|
672 &data_m[data_length_m], |
|
673 param->get_data(), |
|
674 param->size() ); |
|
675 |
|
676 data_length_m += param->size(); |
|
677 return core_error_ok; |
|
678 } |
|
679 |
|
680 u32_t core_wlan_eapol_if_function_c::size() const |
|
681 { |
|
682 return data_length_m; |
|
683 } |
|
684 |
|
685 |
|
686 u8_t* core_wlan_eapol_if_function_c::get_data() |
|
687 { |
|
688 return &data_m[0]; |
|
689 } |
|
690 |
|
691 void core_wlan_eapol_if_function_c::clear() |
|
692 { |
|
693 core_tools_c::fillz( data_m, buffer_length_m ); |
|
694 data_length_m = 0; |
|
695 first(); |
|
696 } |
|
697 |
|
698 // ============================================================================ |
|
699 |
|
700 // Iterators |
|
701 void core_wlan_eapol_if_function_c::first() |
|
702 { |
|
703 // Update current_parameter_m |
|
704 iter_m = 0; |
|
705 current_parameter_m.update( &data_m[iter_m], data_length_m - iter_m ); |
|
706 } |
|
707 |
|
708 void core_wlan_eapol_if_function_c::next() |
|
709 { |
|
710 // Update current_parameter_m |
|
711 iter_m += current_parameter_m.size(); |
|
712 current_parameter_m.update( &data_m[iter_m], data_length_m - iter_m ); |
|
713 |
|
714 return; // ok |
|
715 } |
|
716 |
|
717 const core_wlan_eapol_if_parameter_c* core_wlan_eapol_if_function_c::current() |
|
718 { |
|
719 return ¤t_parameter_m; |
|
720 } |
|
721 |
|
722 bool_t core_wlan_eapol_if_function_c::is_done() const |
|
723 { |
|
724 return ( iter_m >= data_length_m ); |
|
725 } |
|
726 |
|
727 // ============================================================================ |
|
728 |
|
729 core_error_e core_wlan_eapol_if_function_c::reserve_buffer( |
|
730 u32_t needed_buffer_length ) |
|
731 { |
|
732 if ( needed_buffer_length <= buffer_length_m ) |
|
733 { |
|
734 return core_error_ok; |
|
735 } |
|
736 |
|
737 DEBUG2( "core_wlan_eapol_if_function_c::reserve_buffer - increase buffer %i->%i bytes", buffer_length_m, needed_buffer_length ); |
|
738 u8_t* p = new u8_t[needed_buffer_length]; |
|
739 if ( !p ) |
|
740 { |
|
741 DEBUG( "core_wlan_eapol_if_function_c::reserve_buffer - Error: No enough memory!" ); |
|
742 return core_error_no_memory; |
|
743 } |
|
744 core_tools_c::fillz( p, needed_buffer_length ); |
|
745 core_tools_c::copy( |
|
746 p, |
|
747 &data_m[0], |
|
748 data_length_m ); |
|
749 core_tools_c::fillz( &data_m[0], buffer_length_m ); |
|
750 |
|
751 if ( delete_buffer_m ) |
|
752 { |
|
753 delete[] data_m; |
|
754 } |
|
755 delete_buffer_m = true_t; |
|
756 data_m = p; |
|
757 buffer_length_m = needed_buffer_length; |
|
758 |
|
759 return core_error_ok; |
|
760 } |
|
761 |
|
762 |
|
763 |
|
764 // Higher level methods to handle structured parameters and functions |
|
765 |
|
766 core_error_e core_wlan_eapol_if_function_c::generate_network_id( |
|
767 const network_id_c * network_id ) |
|
768 { |
|
769 DEBUG( "core_wlan_eapol_if_function_c::generate_network_id()" ); |
|
770 ASSERT( network_id != NULL); |
|
771 |
|
772 core_wlan_eapol_if_parameter_c source_parameter; |
|
773 core_wlan_eapol_if_parameter_c destination_parameter; |
|
774 core_wlan_eapol_if_parameter_c packet_type_parameter; |
|
775 core_wlan_eapol_if_parameter_c network_identity; |
|
776 |
|
777 |
|
778 core_error_e error = source_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, network_id->source_ptr, network_id->source_length ); |
|
779 if ( error != core_error_ok ) |
|
780 { |
|
781 return error; |
|
782 } |
|
783 error = destination_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, network_id->destination_ptr, network_id->destination_length ); |
|
784 if ( error != core_error_ok ) |
|
785 { |
|
786 return error; |
|
787 } |
|
788 error = packet_type_parameter.set_parameter_data( wlan_eapol_if_message_type_u16_t, network_id->packet_type ); |
|
789 if ( error != core_error_ok ) |
|
790 { |
|
791 return error; |
|
792 } |
|
793 |
|
794 core_wlan_eapol_if_function_c message; |
|
795 |
|
796 error = message.append( &source_parameter ); |
|
797 if ( error != core_error_ok ) |
|
798 { |
|
799 return error; |
|
800 } |
|
801 error = message.append( &destination_parameter ); |
|
802 if ( error != core_error_ok ) |
|
803 { |
|
804 return error; |
|
805 } |
|
806 error = message.append( &packet_type_parameter ); |
|
807 if ( error != core_error_ok ) |
|
808 { |
|
809 return error; |
|
810 } |
|
811 |
|
812 error = network_identity.set_parameter_data( wlan_eapol_if_message_type_network_id, message.get_data(), message.size() ); |
|
813 if ( error != core_error_ok ) |
|
814 { |
|
815 return error; |
|
816 } |
|
817 |
|
818 return append( &network_identity ); |
|
819 } |
|
820 |
|
821 |
|
822 |
|
823 |
|
824 core_error_e core_wlan_eapol_if_function_c::parse_network_id( |
|
825 network_id_c * network_id ) |
|
826 { |
|
827 DEBUG( "core_wlan_eapol_if_function_c::parse_network_id()" ); |
|
828 ASSERT( network_id ); |
|
829 |
|
830 if ( is_done() || current()->get_parameter_type() != wlan_eapol_if_message_type_network_id ) |
|
831 { |
|
832 return core_error_not_found; |
|
833 } |
|
834 |
|
835 u8_t* network_id_data( NULL ); |
|
836 u32_t network_id_data_length( 0 ); |
|
837 |
|
838 core_error_e error = current()->get_parameter_data( &network_id_data, &network_id_data_length ); |
|
839 if ( error != core_error_ok ) |
|
840 { |
|
841 return error; |
|
842 } |
|
843 |
|
844 core_wlan_eapol_if_function_c parsed_nwid_struct( network_id_data, network_id_data_length ); |
|
845 |
|
846 |
|
847 // Source |
|
848 parsed_nwid_struct.first(); |
|
849 if ( parsed_nwid_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
850 { |
|
851 return core_error_not_found; |
|
852 } |
|
853 error = parsed_nwid_struct.current()->get_parameter_data( &network_id->source_ptr, &network_id->source_length ); |
|
854 if ( error != core_error_ok ) |
|
855 { |
|
856 return error; |
|
857 } |
|
858 |
|
859 |
|
860 // Destination |
|
861 parsed_nwid_struct.next(); |
|
862 if ( parsed_nwid_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
863 { |
|
864 return core_error_not_found; |
|
865 } |
|
866 error = parsed_nwid_struct.current()->get_parameter_data( &network_id->destination_ptr, &network_id->destination_length ); |
|
867 if ( error != core_error_ok ) |
|
868 { |
|
869 return error; |
|
870 } |
|
871 |
|
872 |
|
873 // Packet type |
|
874 parsed_nwid_struct.next(); |
|
875 if ( parsed_nwid_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u16_t ) |
|
876 { |
|
877 return core_error_not_found; |
|
878 } |
|
879 error = parsed_nwid_struct.current()->get_parameter_data( &network_id->packet_type ); |
|
880 if ( error != core_error_ok ) |
|
881 { |
|
882 return error; |
|
883 } |
|
884 |
|
885 return error; |
|
886 } |
|
887 |
|
888 |
|
889 |
|
890 |
|
891 core_error_e core_wlan_eapol_if_function_c::generate_network_key( |
|
892 network_key_c * network_key ) |
|
893 { |
|
894 DEBUG( "core_wlan_eapol_if_function_c::generate_network_key()" ); |
|
895 ASSERT( network_key ); |
|
896 ASSERT( network_key->network_key ); |
|
897 |
|
898 core_wlan_eapol_if_parameter_c network_key_index_parameter; |
|
899 core_wlan_eapol_if_parameter_c network_key_parameter; |
|
900 core_wlan_eapol_if_parameter_c temp_network_key; |
|
901 |
|
902 |
|
903 core_error_e error = network_key_index_parameter.set_parameter_data( wlan_eapol_if_message_type_u8_t, network_key->network_key_index ); |
|
904 if ( error != core_error_ok ) |
|
905 { |
|
906 return error; |
|
907 } |
|
908 error = network_key_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, network_key->network_key, network_key->network_key_length ); |
|
909 if ( error != core_error_ok ) |
|
910 { |
|
911 return error; |
|
912 } |
|
913 |
|
914 core_wlan_eapol_if_function_c message; |
|
915 |
|
916 error = message.append( &network_key_index_parameter ); |
|
917 if ( error != core_error_ok ) |
|
918 { |
|
919 return error; |
|
920 } |
|
921 error = message.append( &network_key_parameter ); |
|
922 if ( error != core_error_ok ) |
|
923 { |
|
924 return error; |
|
925 } |
|
926 |
|
927 error = temp_network_key.set_parameter_data( wlan_eapol_if_message_type_network_key, message.get_data(), message.size() ); |
|
928 if ( error != core_error_ok ) |
|
929 { |
|
930 return error; |
|
931 } |
|
932 |
|
933 return append( &temp_network_key ); |
|
934 } |
|
935 |
|
936 |
|
937 |
|
938 |
|
939 core_error_e core_wlan_eapol_if_function_c::parse_network_key( |
|
940 network_key_c * network_key ) |
|
941 { |
|
942 DEBUG( "core_wlan_eapol_if_function_c::parse_network_key()" ); |
|
943 ASSERT( network_key ); |
|
944 |
|
945 if ( is_done() || current()->get_parameter_type() != wlan_eapol_if_message_type_network_key ) |
|
946 { |
|
947 return core_error_not_found; |
|
948 } |
|
949 |
|
950 u8_t* network_key_data( NULL ); |
|
951 u32_t network_key_data_length( 0 ); |
|
952 |
|
953 core_error_e error = current()->get_parameter_data( &network_key_data, &network_key_data_length ); |
|
954 if ( error != core_error_ok ) |
|
955 { |
|
956 return error; |
|
957 } |
|
958 |
|
959 core_wlan_eapol_if_function_c parsed_network_key_struct( network_key_data, network_key_data_length ); |
|
960 |
|
961 |
|
962 parsed_network_key_struct.first(); |
|
963 if ( parsed_network_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u8_t ) |
|
964 { |
|
965 return core_error_not_found; |
|
966 } |
|
967 error = parsed_network_key_struct.current()->get_parameter_data( &network_key->network_key_index ); |
|
968 if ( error != core_error_ok ) |
|
969 { |
|
970 return error; |
|
971 } |
|
972 |
|
973 |
|
974 parsed_network_key_struct.next(); |
|
975 if ( parsed_network_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
976 { |
|
977 return core_error_not_found; |
|
978 } |
|
979 error = parsed_network_key_struct.current()->get_parameter_data( &network_key->network_key, &network_key->network_key_length ); |
|
980 if ( error != core_error_ok ) |
|
981 { |
|
982 return error; |
|
983 } |
|
984 |
|
985 return error; |
|
986 } |
|
987 |
|
988 |
|
989 |
|
990 |
|
991 |
|
992 |
|
993 |
|
994 core_error_e core_wlan_eapol_if_function_c::generate_protected_setup_credential( |
|
995 protected_setup_credential_c * credential ) |
|
996 { |
|
997 DEBUG( "core_wlan_eapol_if_function_c::generate_protected_setup_credential()" ); |
|
998 ASSERT( credential ); |
|
999 |
|
1000 core_wlan_eapol_if_parameter_c network_index_parameter; |
|
1001 core_wlan_eapol_if_parameter_c ssid_parameter; |
|
1002 core_wlan_eapol_if_parameter_c authentication_type_parameter; |
|
1003 core_wlan_eapol_if_parameter_c encryption_type_parameter; |
|
1004 core_wlan_eapol_if_parameter_c network_key_list_parameter; |
|
1005 core_wlan_eapol_if_parameter_c mac_address_parameter; |
|
1006 |
|
1007 core_wlan_eapol_if_parameter_c protected_setup_credential; |
|
1008 |
|
1009 |
|
1010 core_error_e error = network_index_parameter.set_parameter_data( wlan_eapol_if_message_type_u8_t, credential->network_index ); |
|
1011 if ( error != core_error_ok ) |
|
1012 { |
|
1013 return error; |
|
1014 } |
|
1015 error = ssid_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, credential->ssid, credential->ssid_length ); |
|
1016 if ( error != core_error_ok ) |
|
1017 { |
|
1018 return error; |
|
1019 } |
|
1020 error = authentication_type_parameter.set_parameter_data( wlan_eapol_if_message_type_u16_t, credential->authentication_type ); |
|
1021 if ( error != core_error_ok ) |
|
1022 { |
|
1023 return error; |
|
1024 } |
|
1025 error = encryption_type_parameter.set_parameter_data( wlan_eapol_if_message_type_u16_t, credential->encryption_type ); |
|
1026 if ( error != core_error_ok ) |
|
1027 { |
|
1028 return error; |
|
1029 } |
|
1030 |
|
1031 // Handle array here. |
|
1032 core_wlan_eapol_if_function_c array; |
|
1033 |
|
1034 credential->network_key_list.first(); |
|
1035 while ( credential->network_key_list.current() ) |
|
1036 { |
|
1037 core_wlan_eapol_if_function_c network_key; |
|
1038 error = network_key.generate_network_key( |
|
1039 credential->network_key_list.current() ); |
|
1040 if ( error != core_error_ok ) |
|
1041 { |
|
1042 return error; |
|
1043 } |
|
1044 core_wlan_eapol_if_parameter_c network_key_parameter( network_key.get_data(), network_key.size() ); |
|
1045 |
|
1046 error = array.append( &network_key_parameter ); |
|
1047 if ( error != core_error_ok ) |
|
1048 { |
|
1049 return error; |
|
1050 } |
|
1051 credential->network_key_list.next(); |
|
1052 } |
|
1053 network_key_list_parameter.set_parameter_data( wlan_eapol_if_message_type_array, array.get_data(), array.size() ); |
|
1054 |
|
1055 |
|
1056 error = mac_address_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, credential->mac_address, credential->mac_address_length ); |
|
1057 if ( error != core_error_ok ) |
|
1058 { |
|
1059 return error; |
|
1060 } |
|
1061 |
|
1062 core_wlan_eapol_if_function_c message; |
|
1063 |
|
1064 error = message.append( &network_index_parameter ); |
|
1065 if ( error != core_error_ok ) |
|
1066 { |
|
1067 return error; |
|
1068 } |
|
1069 error = message.append( &ssid_parameter ); |
|
1070 if ( error != core_error_ok ) |
|
1071 { |
|
1072 return error; |
|
1073 } |
|
1074 error = message.append( &authentication_type_parameter ); |
|
1075 if ( error != core_error_ok ) |
|
1076 { |
|
1077 return error; |
|
1078 } |
|
1079 error = message.append( &encryption_type_parameter ); |
|
1080 if ( error != core_error_ok ) |
|
1081 { |
|
1082 return error; |
|
1083 } |
|
1084 error = message.append( &network_key_list_parameter ); |
|
1085 if ( error != core_error_ok ) |
|
1086 { |
|
1087 return error; |
|
1088 } |
|
1089 error = message.append( &mac_address_parameter ); |
|
1090 if ( error != core_error_ok ) |
|
1091 { |
|
1092 return error; |
|
1093 } |
|
1094 |
|
1095 error = protected_setup_credential.set_parameter_data( wlan_eapol_if_message_type_protected_setup_credential, message.get_data(), message.size() ); |
|
1096 if ( error != core_error_ok ) |
|
1097 { |
|
1098 return error; |
|
1099 } |
|
1100 |
|
1101 return append( &protected_setup_credential ); |
|
1102 } |
|
1103 |
|
1104 |
|
1105 |
|
1106 |
|
1107 core_error_e core_wlan_eapol_if_function_c::parse_protected_setup_credential( |
|
1108 protected_setup_credential_c * credential ) |
|
1109 { |
|
1110 DEBUG( "core_wlan_eapol_if_function_c::parse_protected_setup_credential()" ); |
|
1111 ASSERT( credential ); |
|
1112 |
|
1113 if ( is_done() || current()->get_parameter_type() != wlan_eapol_if_message_type_protected_setup_credential ) |
|
1114 { |
|
1115 return core_error_not_found; |
|
1116 } |
|
1117 |
|
1118 u8_t* credential_data( NULL ); |
|
1119 u32_t credential_data_length( 0 ); |
|
1120 |
|
1121 core_error_e error = current()->get_parameter_data( &credential_data, &credential_data_length ); |
|
1122 if ( error != core_error_ok ) |
|
1123 { |
|
1124 return error; |
|
1125 } |
|
1126 |
|
1127 core_wlan_eapol_if_function_c parsed_credential_struct( credential_data, credential_data_length ); |
|
1128 |
|
1129 |
|
1130 parsed_credential_struct.first(); |
|
1131 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u8_t ) |
|
1132 { |
|
1133 return core_error_not_found; |
|
1134 } |
|
1135 error = parsed_credential_struct.current()->get_parameter_data( &credential->network_index ); |
|
1136 if ( error != core_error_ok ) |
|
1137 { |
|
1138 return error; |
|
1139 } |
|
1140 |
|
1141 |
|
1142 parsed_credential_struct.next(); |
|
1143 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
1144 { |
|
1145 return core_error_not_found; |
|
1146 } |
|
1147 error = parsed_credential_struct.current()->get_parameter_data( &credential->ssid, &credential->ssid_length ); |
|
1148 if ( error != core_error_ok ) |
|
1149 { |
|
1150 return error; |
|
1151 } |
|
1152 |
|
1153 |
|
1154 parsed_credential_struct.next(); |
|
1155 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u16_t ) |
|
1156 { |
|
1157 return core_error_not_found; |
|
1158 } |
|
1159 error = parsed_credential_struct.current()->get_parameter_data( &credential->authentication_type ); |
|
1160 if ( error != core_error_ok ) |
|
1161 { |
|
1162 return error; |
|
1163 } |
|
1164 |
|
1165 |
|
1166 parsed_credential_struct.next(); |
|
1167 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u16_t ) |
|
1168 { |
|
1169 return core_error_not_found; |
|
1170 } |
|
1171 error = parsed_credential_struct.current()->get_parameter_data( &credential->encryption_type ); |
|
1172 if ( error != core_error_ok ) |
|
1173 { |
|
1174 return error; |
|
1175 } |
|
1176 |
|
1177 |
|
1178 parsed_credential_struct.next(); |
|
1179 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_array ) |
|
1180 { |
|
1181 return core_error_not_found; |
|
1182 } |
|
1183 |
|
1184 u32_t data_length; |
|
1185 u8_t * data; |
|
1186 error = parsed_credential_struct.current()->get_parameter_data( &data, &data_length ); |
|
1187 if ( error != core_error_ok ) |
|
1188 { |
|
1189 return error; |
|
1190 } |
|
1191 |
|
1192 core_wlan_eapol_if_function_c array( data, data_length ); |
|
1193 |
|
1194 // Loop through array, put every parsed network_key to network_key_list. |
|
1195 array.first(); |
|
1196 while ( !array.is_done() ) |
|
1197 { |
|
1198 if ( array.current()->get_parameter_type() != wlan_eapol_if_message_type_network_key ) |
|
1199 { |
|
1200 return core_error_not_found; |
|
1201 } |
|
1202 network_key_c * network_key = new network_key_c( 0, NULL, 0 ); |
|
1203 if ( !network_key ) |
|
1204 { |
|
1205 DEBUG( "core_wlan_eapol_if_function_c::parse_protected_setup_credential() - Error: No enough memory!" ); |
|
1206 return core_error_no_memory; |
|
1207 } |
|
1208 error = array.parse_network_key( network_key ); |
|
1209 if ( error != core_error_ok ) |
|
1210 { |
|
1211 delete network_key; |
|
1212 network_key = NULL; |
|
1213 return error; |
|
1214 } |
|
1215 |
|
1216 error = credential->network_key_list.append( network_key ); |
|
1217 if ( error != core_error_ok ) |
|
1218 { |
|
1219 delete network_key; |
|
1220 network_key = NULL; |
|
1221 return error; |
|
1222 } |
|
1223 |
|
1224 array.next(); |
|
1225 } |
|
1226 |
|
1227 |
|
1228 parsed_credential_struct.next(); |
|
1229 if ( parsed_credential_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
1230 { |
|
1231 return core_error_not_found; |
|
1232 } |
|
1233 error = parsed_credential_struct.current()->get_parameter_data( &credential->mac_address, &credential->mac_address_length ); |
|
1234 if ( error != core_error_ok ) |
|
1235 { |
|
1236 return error; |
|
1237 } |
|
1238 |
|
1239 |
|
1240 return error; |
|
1241 } |
|
1242 |
|
1243 |
|
1244 |
|
1245 |
|
1246 |
|
1247 core_error_e core_wlan_eapol_if_function_c::generate_session_key( |
|
1248 session_key_c * session_key ) |
|
1249 { |
|
1250 DEBUG( "core_wlan_eapol_if_function_c::generate_session_key()" ); |
|
1251 ASSERT( session_key ); |
|
1252 ASSERT( session_key->key ); |
|
1253 ASSERT( session_key->sequence_number ); |
|
1254 |
|
1255 core_wlan_eapol_if_parameter_c key_parameter; |
|
1256 core_wlan_eapol_if_parameter_c sequence_number_parameter; |
|
1257 core_wlan_eapol_if_parameter_c eapol_key_type_parameter; |
|
1258 core_wlan_eapol_if_parameter_c key_index_parameter; |
|
1259 core_wlan_eapol_if_parameter_c key_tx_bit_parameter; |
|
1260 |
|
1261 core_wlan_eapol_if_parameter_c session_key_parameter; |
|
1262 |
|
1263 |
|
1264 // Generate parameters |
|
1265 core_error_e error = key_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, session_key->key, session_key->key_length); |
|
1266 if ( error != core_error_ok ) |
|
1267 { |
|
1268 return error; |
|
1269 } |
|
1270 error = sequence_number_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, session_key->sequence_number, session_key->sequence_number_length); |
|
1271 if ( error != core_error_ok ) |
|
1272 { |
|
1273 return error; |
|
1274 } |
|
1275 error = eapol_key_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_type, session_key->eapol_key_type ); |
|
1276 if ( error != core_error_ok ) |
|
1277 { |
|
1278 return error; |
|
1279 } |
|
1280 error = key_index_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, session_key->key_index ); |
|
1281 if ( error != core_error_ok ) |
|
1282 { |
|
1283 return error; |
|
1284 } |
|
1285 error = key_tx_bit_parameter.set_parameter_data( wlan_eapol_if_message_type_boolean, session_key->key_tx_bit ); |
|
1286 if ( error != core_error_ok ) |
|
1287 { |
|
1288 return error; |
|
1289 } |
|
1290 |
|
1291 |
|
1292 // Append parameters to parameter list |
|
1293 core_wlan_eapol_if_function_c message; |
|
1294 |
|
1295 error = message.append( &key_parameter ); |
|
1296 if ( error != core_error_ok ) |
|
1297 { |
|
1298 return error; |
|
1299 } |
|
1300 error = message.append( &sequence_number_parameter ); |
|
1301 if ( error != core_error_ok ) |
|
1302 { |
|
1303 return error; |
|
1304 } |
|
1305 error = message.append( &eapol_key_type_parameter ); |
|
1306 if ( error != core_error_ok ) |
|
1307 { |
|
1308 return error; |
|
1309 } |
|
1310 error = message.append( &key_index_parameter ); |
|
1311 if ( error != core_error_ok ) |
|
1312 { |
|
1313 return error; |
|
1314 } |
|
1315 error = message.append( &key_tx_bit_parameter ); |
|
1316 if ( error != core_error_ok ) |
|
1317 { |
|
1318 return error; |
|
1319 } |
|
1320 |
|
1321 |
|
1322 // Group parameter list to session key type |
|
1323 error = session_key_parameter.set_parameter_data( wlan_eapol_if_message_type_session_key, message.get_data(), message.size() ); |
|
1324 if ( error != core_error_ok ) |
|
1325 { |
|
1326 return error; |
|
1327 } |
|
1328 |
|
1329 return append( &session_key_parameter ); |
|
1330 } |
|
1331 |
|
1332 |
|
1333 core_error_e core_wlan_eapol_if_function_c::parse_session_key( |
|
1334 session_key_c * session_key ) |
|
1335 { |
|
1336 DEBUG( "core_wlan_eapol_if_function_c::parse_session_key()" ); |
|
1337 ASSERT( session_key ); |
|
1338 |
|
1339 if ( is_done() || current()->get_parameter_type() != wlan_eapol_if_message_type_session_key ) |
|
1340 { |
|
1341 return core_error_not_found; |
|
1342 } |
|
1343 |
|
1344 u8_t* session_key_data( NULL ); |
|
1345 u32_t session_key_data_length( 0 ); |
|
1346 |
|
1347 core_error_e error = current()->get_parameter_data( &session_key_data, &session_key_data_length ); |
|
1348 if ( error != core_error_ok ) |
|
1349 { |
|
1350 return error; |
|
1351 } |
|
1352 |
|
1353 core_wlan_eapol_if_function_c parsed_session_key_struct( session_key_data, session_key_data_length ); |
|
1354 |
|
1355 |
|
1356 // Source |
|
1357 parsed_session_key_struct.first(); |
|
1358 if ( parsed_session_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
1359 { |
|
1360 return core_error_not_found; |
|
1361 } |
|
1362 error = parsed_session_key_struct.current()->get_parameter_data( &session_key->key, &session_key->key_length ); |
|
1363 if ( error != core_error_ok ) |
|
1364 { |
|
1365 return error; |
|
1366 } |
|
1367 |
|
1368 |
|
1369 // Sequence number |
|
1370 parsed_session_key_struct.next(); |
|
1371 if ( parsed_session_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
1372 { |
|
1373 return core_error_not_found; |
|
1374 } |
|
1375 error = parsed_session_key_struct.current()->get_parameter_data( &session_key->sequence_number, &session_key->sequence_number_length ); |
|
1376 if ( error != core_error_ok ) |
|
1377 { |
|
1378 return error; |
|
1379 } |
|
1380 |
|
1381 |
|
1382 // EAPOL key type |
|
1383 parsed_session_key_struct.next(); |
|
1384 if ( parsed_session_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_eapol_key_type ) |
|
1385 { |
|
1386 return core_error_not_found; |
|
1387 } |
|
1388 u32_t eapol_key_type( 0 ); |
|
1389 error = parsed_session_key_struct.current()->get_parameter_data( &eapol_key_type ); |
|
1390 if ( error != core_error_ok ) |
|
1391 { |
|
1392 return error; |
|
1393 } |
|
1394 session_key->eapol_key_type = static_cast<wlan_eapol_if_eapol_key_type_e>( eapol_key_type ); |
|
1395 |
|
1396 // Key index |
|
1397 parsed_session_key_struct.next(); |
|
1398 if ( parsed_session_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u32_t ) |
|
1399 { |
|
1400 return core_error_not_found; |
|
1401 } |
|
1402 error = parsed_session_key_struct.current()->get_parameter_data( &session_key->key_index ); |
|
1403 if ( error != core_error_ok ) |
|
1404 { |
|
1405 return error; |
|
1406 } |
|
1407 |
|
1408 // Key TX bit |
|
1409 parsed_session_key_struct.next(); |
|
1410 if ( parsed_session_key_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_boolean ) |
|
1411 { |
|
1412 return core_error_not_found; |
|
1413 } |
|
1414 error = parsed_session_key_struct.current()->get_parameter_data( &session_key->key_tx_bit ); |
|
1415 if ( error != core_error_ok ) |
|
1416 { |
|
1417 return error; |
|
1418 } |
|
1419 |
|
1420 return error; |
|
1421 } |
|
1422 |
|
1423 |
|
1424 |
|
1425 |
|
1426 |
|
1427 core_error_e core_wlan_eapol_if_function_c::generate_eap_state_notification( |
|
1428 state_notification_c * state_notification ) |
|
1429 { |
|
1430 DEBUG( "core_wlan_eapol_if_function_c::generate_eap_state_notification()" ); |
|
1431 ASSERT( state_notification ); |
|
1432 |
|
1433 core_wlan_eapol_if_parameter_c eap_state_notification; |
|
1434 |
|
1435 core_wlan_eapol_if_parameter_c protocol_layer_parameter; |
|
1436 core_wlan_eapol_if_parameter_c protocol_parameter; |
|
1437 core_wlan_eapol_if_parameter_c eap_type_parameter; |
|
1438 core_wlan_eapol_if_parameter_c current_state_parameter; |
|
1439 core_wlan_eapol_if_parameter_c is_client_parameter; |
|
1440 core_wlan_eapol_if_parameter_c authentication_error_parameter; |
|
1441 |
|
1442 |
|
1443 // Generate parameters |
|
1444 core_wlan_eapol_if_function_c network_id; |
|
1445 core_error_e error = network_id.generate_network_id( |
|
1446 &state_notification->network_id ); |
|
1447 if ( error != core_error_ok ) |
|
1448 { |
|
1449 return error; |
|
1450 } |
|
1451 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
1452 |
|
1453 |
|
1454 |
|
1455 error = protocol_layer_parameter.set_parameter_data( wlan_eapol_if_message_type_eap_protocol_layer, state_notification->protocol_layer ); |
|
1456 if ( error != core_error_ok ) |
|
1457 { |
|
1458 return error; |
|
1459 } |
|
1460 error = protocol_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, state_notification->protocol); |
|
1461 if ( error != core_error_ok ) |
|
1462 { |
|
1463 return error; |
|
1464 } |
|
1465 error = eap_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eap_type, state_notification->eap_type_vendor_id, state_notification->eap_type_vendor_type ); |
|
1466 if ( error != core_error_ok ) |
|
1467 { |
|
1468 return error; |
|
1469 } |
|
1470 error = current_state_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, state_notification->current_state ); |
|
1471 if ( error != core_error_ok ) |
|
1472 { |
|
1473 return error; |
|
1474 } |
|
1475 error = is_client_parameter.set_parameter_data( wlan_eapol_if_message_type_boolean, state_notification->is_client ); |
|
1476 if ( error != core_error_ok ) |
|
1477 { |
|
1478 return error; |
|
1479 } |
|
1480 error = authentication_error_parameter.set_parameter_data( wlan_eapol_if_message_type_eap_status, state_notification->authentication_error ); |
|
1481 if ( error != core_error_ok ) |
|
1482 { |
|
1483 return error; |
|
1484 } |
|
1485 |
|
1486 // Append parameters to parameter list |
|
1487 core_wlan_eapol_if_function_c message; |
|
1488 |
|
1489 error = message.append( &network_id_parameter ); |
|
1490 if ( error != core_error_ok ) |
|
1491 { |
|
1492 return error; |
|
1493 } |
|
1494 error = message.append( &protocol_layer_parameter ); |
|
1495 if ( error != core_error_ok ) |
|
1496 { |
|
1497 return error; |
|
1498 } |
|
1499 error = message.append( &protocol_parameter ); |
|
1500 if ( error != core_error_ok ) |
|
1501 { |
|
1502 return error; |
|
1503 } |
|
1504 error = message.append( &eap_type_parameter ); |
|
1505 if ( error != core_error_ok ) |
|
1506 { |
|
1507 return error; |
|
1508 } |
|
1509 error = message.append( ¤t_state_parameter ); |
|
1510 if ( error != core_error_ok ) |
|
1511 { |
|
1512 return error; |
|
1513 } |
|
1514 error = message.append( &is_client_parameter ); |
|
1515 if ( error != core_error_ok ) |
|
1516 { |
|
1517 return error; |
|
1518 } |
|
1519 error = message.append( &authentication_error_parameter ); |
|
1520 if ( error != core_error_ok ) |
|
1521 { |
|
1522 return error; |
|
1523 } |
|
1524 |
|
1525 |
|
1526 // Group parameter list to EAP state notification type |
|
1527 error = eap_state_notification.set_parameter_data( wlan_eapol_if_message_type_eap_state_notification, message.get_data(), message.size() ); |
|
1528 if ( error != core_error_ok ) |
|
1529 { |
|
1530 return error; |
|
1531 } |
|
1532 |
|
1533 return append( &eap_state_notification ); |
|
1534 } |
|
1535 |
|
1536 |
|
1537 core_error_e core_wlan_eapol_if_function_c::parse_eap_state_notification( |
|
1538 state_notification_c * state_notification ) |
|
1539 { |
|
1540 DEBUG( "core_wlan_eapol_if_function_c::parse_eap_state_notification()" ); |
|
1541 ASSERT( state_notification ); |
|
1542 |
|
1543 if ( is_done() || current()->get_parameter_type() != wlan_eapol_if_message_type_eap_state_notification ) |
|
1544 { |
|
1545 return core_error_not_found; |
|
1546 } |
|
1547 |
|
1548 u8_t* eap_state_notification_data( NULL ); |
|
1549 u32_t eap_state_notification_data_length( 0 ); |
|
1550 |
|
1551 core_error_e error = current()->get_parameter_data( &eap_state_notification_data, &eap_state_notification_data_length ); |
|
1552 if ( error != core_error_ok ) |
|
1553 { |
|
1554 return error; |
|
1555 } |
|
1556 |
|
1557 core_wlan_eapol_if_function_c parsed_state_notification_struct( eap_state_notification_data, eap_state_notification_data_length ); |
|
1558 |
|
1559 |
|
1560 // Network id |
|
1561 parsed_state_notification_struct.first(); |
|
1562 error = parsed_state_notification_struct.parse_network_id( |
|
1563 &state_notification->network_id ); |
|
1564 if ( error != core_error_ok ) |
|
1565 { |
|
1566 return error; |
|
1567 } |
|
1568 |
|
1569 |
|
1570 // Protocol layer |
|
1571 parsed_state_notification_struct.next(); |
|
1572 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_eap_protocol_layer ) |
|
1573 { |
|
1574 return core_error_not_found; |
|
1575 } |
|
1576 u32_t temp_protocol_layer( 0 ); |
|
1577 error = parsed_state_notification_struct.current()->get_parameter_data( &temp_protocol_layer ); |
|
1578 if ( error != core_error_ok ) |
|
1579 { |
|
1580 return error; |
|
1581 } |
|
1582 state_notification->protocol_layer = static_cast<wlan_eapol_if_eap_protocol_layer_e>( temp_protocol_layer ); |
|
1583 |
|
1584 |
|
1585 // Protocol |
|
1586 parsed_state_notification_struct.next(); |
|
1587 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u32_t ) |
|
1588 { |
|
1589 return core_error_not_found; |
|
1590 } |
|
1591 error = parsed_state_notification_struct.current()->get_parameter_data( &state_notification->protocol ); |
|
1592 if ( error != core_error_ok ) |
|
1593 { |
|
1594 return error; |
|
1595 } |
|
1596 |
|
1597 // EAP-Type |
|
1598 parsed_state_notification_struct.next(); |
|
1599 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_eap_type ) |
|
1600 { |
|
1601 return core_error_not_found; |
|
1602 } |
|
1603 error = parsed_state_notification_struct.current()->get_parameter_data( &state_notification->eap_type_vendor_id, &state_notification->eap_type_vendor_type ); |
|
1604 if ( error != core_error_ok ) |
|
1605 { |
|
1606 return error; |
|
1607 } |
|
1608 |
|
1609 // Current state |
|
1610 parsed_state_notification_struct.next(); |
|
1611 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_u32_t ) |
|
1612 { |
|
1613 return core_error_not_found; |
|
1614 } |
|
1615 error = parsed_state_notification_struct.current()->get_parameter_data( &state_notification->current_state ); |
|
1616 if ( error != core_error_ok ) |
|
1617 { |
|
1618 return error; |
|
1619 } |
|
1620 |
|
1621 // Is client |
|
1622 parsed_state_notification_struct.next(); |
|
1623 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_boolean ) |
|
1624 { |
|
1625 return core_error_not_found; |
|
1626 } |
|
1627 error = parsed_state_notification_struct.current()->get_parameter_data( &state_notification->is_client ); |
|
1628 if ( error != core_error_ok ) |
|
1629 { |
|
1630 return error; |
|
1631 } |
|
1632 |
|
1633 // Authentication error |
|
1634 parsed_state_notification_struct.next(); |
|
1635 if ( parsed_state_notification_struct.current()->get_parameter_type() != wlan_eapol_if_message_type_eap_status ) |
|
1636 { |
|
1637 return core_error_not_found; |
|
1638 } |
|
1639 u32_t temp_authentication_error( 0 ); |
|
1640 error = parsed_state_notification_struct.current()->get_parameter_data( &temp_authentication_error ); |
|
1641 if ( error != core_error_ok ) |
|
1642 { |
|
1643 return error; |
|
1644 } |
|
1645 state_notification->authentication_error = static_cast<wlan_eapol_if_eap_status_e>( temp_authentication_error ); |
|
1646 return error; |
|
1647 } |
|
1648 |
|
1649 |
|
1650 void core_wlan_eapol_if_function_c::debug_print() |
|
1651 { |
|
1652 #ifdef _DEBUG |
|
1653 DEBUG( " -> debug_print()" ); |
|
1654 |
|
1655 static const bool wlan_eapol_if_message_type_is_basic_type[] = |
|
1656 { |
|
1657 true, //"none", |
|
1658 false, //"array", |
|
1659 true, //"boolean", |
|
1660 true, //"eap_protocol_layer", |
|
1661 false, //"eap_state_notification", |
|
1662 true, //"eap_status", |
|
1663 true, //"eap_type", |
|
1664 true, //"eapol_key_802_11_authentication_mode", |
|
1665 true, //"eapol_key_authentication_type", |
|
1666 true, //"eapol_key_type", |
|
1667 true, //"eapol_tkip_mic_failure_type", |
|
1668 true, //"eapol_wlan_authentication_state", |
|
1669 true, //"error", |
|
1670 true, //"function", |
|
1671 false, //"network_id", |
|
1672 false, //"network_key", |
|
1673 false, //"protected_setup_credential", |
|
1674 true, //"RSNA_cipher", |
|
1675 false, //"session_key", |
|
1676 true, //"u8_t", |
|
1677 true, //"u16_t", |
|
1678 true, //"u32_t", |
|
1679 true, //"u64_t", |
|
1680 true, //"variable_data", |
|
1681 }; |
|
1682 |
|
1683 first(); |
|
1684 while ( !is_done() ) |
|
1685 { |
|
1686 wlan_eapol_if_message_type_e type = current()->get_parameter_type(); |
|
1687 debug_print_type_string( type, current()->get_parameter_length() ); |
|
1688 |
|
1689 // Basic types are printed now. Structured types are parsed recursively. |
|
1690 if ( wlan_eapol_if_message_type_is_basic_type[ type ]) |
|
1691 { |
|
1692 // Special handling for functions |
|
1693 if ( current()->get_parameter_type() == wlan_eapol_if_message_type_function ) |
|
1694 { |
|
1695 u32_t func(0); |
|
1696 core_error_e error = current()->get_parameter_data( &func ); |
|
1697 if ( error != core_error_ok ) |
|
1698 { |
|
1699 return; |
|
1700 } |
|
1701 debug_print_function_string( static_cast<wlan_eapol_if_message_type_function_e>( func ) ); |
|
1702 } |
|
1703 else |
|
1704 { |
|
1705 DEBUG( "Data:" ); |
|
1706 DEBUG_BUFFER( current()->size()-WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET, |
|
1707 current()->get_data()+WLAN_EAPOL_MESSAGE_IF_DATA_OFFSET ); |
|
1708 } |
|
1709 } |
|
1710 else |
|
1711 { |
|
1712 u8_t* data( NULL ); |
|
1713 u32_t data_length( 0 ); |
|
1714 core_error_e error = current()->get_parameter_data( &data, &data_length ); |
|
1715 if ( error != core_error_ok ) |
|
1716 { |
|
1717 return; |
|
1718 } |
|
1719 |
|
1720 core_wlan_eapol_if_function_c sub_message( data, data_length ); |
|
1721 sub_message.debug_print(); |
|
1722 } |
|
1723 next(); |
|
1724 } |
|
1725 DEBUG( " <- debug_print()" ); |
|
1726 #endif // _DEBUG |
|
1727 } |
|
1728 |
|
1729 |
|
1730 #ifdef _DEBUG |
|
1731 |
|
1732 void core_wlan_eapol_if_function_c::debug_print_type_string( |
|
1733 wlan_eapol_if_message_type_e type, |
|
1734 u32_t length ) |
|
1735 { |
|
1736 switch ( type ) |
|
1737 { |
|
1738 case wlan_eapol_if_message_type_none : DEBUG2( "Type %i: none, length %i", type, length ); break; |
|
1739 case wlan_eapol_if_message_type_array : DEBUG2( "Type %i: array, length %i", type, length ); break; |
|
1740 case wlan_eapol_if_message_type_boolean : DEBUG2( "Type %i: boolean, length %i", type, length ); break; |
|
1741 case wlan_eapol_if_message_type_eap_protocol_layer : DEBUG2( "Type %i: eap_protocol_layer, length %i", type, length ); break; |
|
1742 case wlan_eapol_if_message_type_eap_state_notification : DEBUG2( "Type %i: eap_state_notification, length %i", type, length ); break; |
|
1743 case wlan_eapol_if_message_type_eap_status : DEBUG2( "Type %i: eap_status, length %i", type, length ); break; |
|
1744 case wlan_eapol_if_message_type_eap_type : DEBUG2( "Type %i: eap_type, length %i", type, length ); break; |
|
1745 case wlan_eapol_if_message_type_eapol_key_802_11_authentication_mode: DEBUG2( "Type %i: eapol_key_802_11_authentication_mode, length %i", type, length ); break; |
|
1746 case wlan_eapol_if_message_type_eapol_key_authentication_type : DEBUG2( "Type %i: eapol_key_authentication_type, length %i", type, length ); break; |
|
1747 case wlan_eapol_if_message_type_eapol_key_type : DEBUG2( "Type %i: eapol_key_type, length %i", type, length ); break; |
|
1748 case wlan_eapol_if_message_type_eapol_tkip_mic_failure_type : DEBUG2( "Type %i: eapol_tkip_mic_failure_type, length %i", type, length ); break; |
|
1749 case wlan_eapol_if_message_type_eapol_wlan_authentication_state : DEBUG2( "Type %i: eapol_wlan_authentication_state, length %i", type, length ); break; |
|
1750 case wlan_eapol_if_message_type_error : DEBUG2( "Type %i: error, length %i", type, length ); break; |
|
1751 case wlan_eapol_if_message_type_function : DEBUG2( "Type %i: function, length %i", type, length ); break; |
|
1752 case wlan_eapol_if_message_type_network_id : DEBUG2( "Type %i: network_id, length %i", type, length ); break; |
|
1753 case wlan_eapol_if_message_type_network_key : DEBUG2( "Type %i: network_key, length %i", type, length ); break; |
|
1754 case wlan_eapol_if_message_type_protected_setup_credential : DEBUG2( "Type %i: protected_setup_credential, length %i", type, length ); break; |
|
1755 case wlan_eapol_if_message_type_RSNA_cipher : DEBUG2( "Type %i: RSNA_cipher, length %i", type, length ); break; |
|
1756 case wlan_eapol_if_message_type_session_key : DEBUG2( "Type %i: session_key, length %i", type, length ); break; |
|
1757 case wlan_eapol_if_message_type_u8_t : DEBUG2( "Type %i: u8_t, length %i", type, length ); break; |
|
1758 case wlan_eapol_if_message_type_u16_t : DEBUG2( "Type %i: u16_t, length %i", type, length ); break; |
|
1759 case wlan_eapol_if_message_type_u32_t : DEBUG2( "Type %i: u32_t, length %i", type, length ); break; |
|
1760 case wlan_eapol_if_message_type_u64_t : DEBUG2( "Type %i: u64_t, length %i", type, length ); break; |
|
1761 case wlan_eapol_if_message_type_variable_data : DEBUG2( "Type %i: variable_data, length %i", type, length ); break; |
|
1762 default: DEBUG1( "Illegal type number (%i)", type ); |
|
1763 } |
|
1764 } |
|
1765 |
|
1766 void core_wlan_eapol_if_function_c::debug_print_function_string( |
|
1767 wlan_eapol_if_message_type_function_e function ) |
|
1768 { |
|
1769 switch ( function ) |
|
1770 { |
|
1771 case wlan_eapol_if_message_type_function_none : DEBUG1( "Function %i: none", function ); break; |
|
1772 case wlan_eapol_if_message_type_function_check_pmksa_cache : DEBUG1( "Function %i: check_pmksa_cache", function ); break; |
|
1773 case wlan_eapol_if_message_type_function_start_authentication : DEBUG1( "Function %i: start_authentication", function ); break; |
|
1774 case wlan_eapol_if_message_type_function_complete_association : DEBUG1( "Function %i: complete_association", function ); break; |
|
1775 case wlan_eapol_if_message_type_function_disassociation : DEBUG1( "Function %i: disassociation", function ); break; |
|
1776 case wlan_eapol_if_message_type_function_start_preauthentication : DEBUG1( "Function %i: start_preauthentication", function ); break; |
|
1777 case wlan_eapol_if_message_type_function_start_reassociation : DEBUG1( "Function %i: start_reassociation", function ); break; |
|
1778 case wlan_eapol_if_message_type_function_complete_reassociation : DEBUG1( "Function %i: complete_reassociation", function ); break; |
|
1779 case wlan_eapol_if_message_type_function_start_wpx_fast_roam_reassociation : DEBUG1( "Function %i: start_wpx_fast_roam_reassociation", function ); break; |
|
1780 case wlan_eapol_if_message_type_function_complete_wpx_fast_roam_reassociation : DEBUG1( "Function %i: complete_wpx_fast_roam_reassociation", function ); break; |
|
1781 case wlan_eapol_if_message_type_function_packet_process : DEBUG1( "Function %i: packet_process", function ); break; |
|
1782 case wlan_eapol_if_message_type_function_tkip_mic_failure : DEBUG1( "Function %i: tkip_mic_failure", function ); break; |
|
1783 case wlan_eapol_if_message_type_function_eap_acknowledge : DEBUG1( "Function %i: eap_acknowledge", function ); break; |
|
1784 case wlan_eapol_if_message_type_function_update_header_offset : DEBUG1( "Function %i: update_header_offset", function ); break; |
|
1785 case wlan_eapol_if_message_type_function_complete_check_pmksa_cache : DEBUG1( "Function %i: complete_check_pmksa_cache", function ); break; |
|
1786 case wlan_eapol_if_message_type_function_packet_send : DEBUG1( "Function %i: packet_send", function ); break; |
|
1787 case wlan_eapol_if_message_type_function_associate : DEBUG1( "Function %i: associate", function ); break; |
|
1788 case wlan_eapol_if_message_type_function_disassociate : DEBUG1( "Function %i: disassociate", function ); break; |
|
1789 case wlan_eapol_if_message_type_function_packet_data_session_key : DEBUG1( "Function %i: packet_data_session_key", function ); break; |
|
1790 case wlan_eapol_if_message_type_function_state_notification : DEBUG1( "Function %i: state_notification", function ); break; |
|
1791 case wlan_eapol_if_message_type_function_reassociate : DEBUG1( "Function %i: reassociate", function ); break; |
|
1792 case wlan_eapol_if_message_type_function_update_wlan_database_reference_values: DEBUG1( "Function %i: update_wlan_database_reference_values", function ); break; |
|
1793 case wlan_eapol_if_message_type_function_complete_start_wpx_fast_roam_reassociation : DEBUG1( "Function %i: complete_start_wpx_fast_roam_reassociation", function ); break; |
|
1794 case wlan_eapol_if_message_type_function_new_protected_setup_credentials : DEBUG1( "Function %i: new_protected_setup_credentials", function ); break; |
|
1795 default: DEBUG1( "Illegal function number (%i)", function ); |
|
1796 } |
|
1797 } |
|
1798 |
|
1799 #else |
|
1800 |
|
1801 void core_wlan_eapol_if_function_c::debug_print_type_string( |
|
1802 wlan_eapol_if_message_type_e /* type */, |
|
1803 u32_t /* length */ ) |
|
1804 { |
|
1805 } |
|
1806 |
|
1807 void core_wlan_eapol_if_function_c::debug_print_function_string( |
|
1808 wlan_eapol_if_message_type_function_e /* function */ ) |
|
1809 { |
|
1810 } |
|
1811 |
|
1812 #endif // _DEBUG |
|
1813 |
|
1814 |
|
1815 // ============================================================================ |
|
1816 |
|
1817 core_error_e core_wlan_eapol_if_function_c::check_pmksa_cache( |
|
1818 core_type_list_c<network_id_c> & network_id_list, |
|
1819 const wlan_eapol_if_eapol_key_authentication_type_e selected_eapol_key_authentication_type, |
|
1820 const wlan_eapol_if_rsna_cipher_e pairwise_key_cipher_suite, |
|
1821 const wlan_eapol_if_rsna_cipher_e group_key_cipher_suite ) |
|
1822 { |
|
1823 DEBUG( "core_wlan_eapol_if_function_c::check_pmksa_cache()" ); |
|
1824 clear(); |
|
1825 |
|
1826 core_error_e error; |
|
1827 core_wlan_eapol_if_parameter_c function; |
|
1828 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_check_pmksa_cache ); |
|
1829 if ( error != core_error_ok ) |
|
1830 { |
|
1831 return error; |
|
1832 } |
|
1833 |
|
1834 core_wlan_eapol_if_parameter_c key_authentication_type_parameter; |
|
1835 core_wlan_eapol_if_parameter_c pairwise_key_cipher_suite_parameter; |
|
1836 core_wlan_eapol_if_parameter_c group_key_cipher_suite_parameter; |
|
1837 |
|
1838 // Generate parameters |
|
1839 |
|
1840 // Generate array |
|
1841 core_wlan_eapol_if_function_c network_id_array; |
|
1842 core_wlan_eapol_if_parameter_c network_id_array_parameter; |
|
1843 |
|
1844 network_id_list.first(); |
|
1845 while ( network_id_list.current() ) |
|
1846 { |
|
1847 core_wlan_eapol_if_function_c network_id; |
|
1848 error = network_id.generate_network_id( |
|
1849 network_id_list.current() ); |
|
1850 if ( error != core_error_ok ) |
|
1851 { |
|
1852 return error; |
|
1853 } |
|
1854 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
1855 |
|
1856 error = network_id_array.append( &network_id_parameter ); |
|
1857 if ( error != core_error_ok ) |
|
1858 { |
|
1859 return error; |
|
1860 } |
|
1861 network_id_list.next(); |
|
1862 } |
|
1863 |
|
1864 network_id_array_parameter.set_parameter_data( wlan_eapol_if_message_type_array, network_id_array.get_data(), network_id_array.size() ); |
|
1865 |
|
1866 |
|
1867 error = key_authentication_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_authentication_type, selected_eapol_key_authentication_type ); |
|
1868 if ( error != core_error_ok ) |
|
1869 { |
|
1870 return error; |
|
1871 } |
|
1872 error = pairwise_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, pairwise_key_cipher_suite); |
|
1873 if ( error != core_error_ok ) |
|
1874 { |
|
1875 return error; |
|
1876 } |
|
1877 error = group_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, group_key_cipher_suite ); |
|
1878 if ( error != core_error_ok ) |
|
1879 { |
|
1880 return error; |
|
1881 } |
|
1882 |
|
1883 |
|
1884 // Append parameters to parameter list |
|
1885 |
|
1886 error = append( &function ); |
|
1887 if ( error != core_error_ok ) |
|
1888 { |
|
1889 return error; |
|
1890 } |
|
1891 error = append( &network_id_array_parameter ); |
|
1892 if ( error != core_error_ok ) |
|
1893 { |
|
1894 return error; |
|
1895 } |
|
1896 error = append( &key_authentication_type_parameter ); |
|
1897 if ( error != core_error_ok ) |
|
1898 { |
|
1899 return error; |
|
1900 } |
|
1901 error = append( &pairwise_key_cipher_suite_parameter ); |
|
1902 if ( error != core_error_ok ) |
|
1903 { |
|
1904 return error; |
|
1905 } |
|
1906 error = append( &group_key_cipher_suite_parameter ); |
|
1907 if ( error != core_error_ok ) |
|
1908 { |
|
1909 return error; |
|
1910 } |
|
1911 |
|
1912 debug_print(); |
|
1913 |
|
1914 return error; |
|
1915 } |
|
1916 |
|
1917 |
|
1918 |
|
1919 |
|
1920 |
|
1921 core_error_e core_wlan_eapol_if_function_c::start_authentication( |
|
1922 u8_t * ssid, const u32_t ssid_length, |
|
1923 const wlan_eapol_if_eapol_key_authentication_type_e selected_eapol_key_authentication_type, |
|
1924 u8_t * wpa_psk, const u32_t wpa_psk_length, |
|
1925 const bool_t wpa_override_enabled, |
|
1926 const network_id_c * receive_network_id ) |
|
1927 { |
|
1928 DEBUG( "core_wlan_eapol_if_function_c::start_authentication()" ); |
|
1929 clear(); |
|
1930 |
|
1931 core_error_e error; |
|
1932 core_wlan_eapol_if_parameter_c function; |
|
1933 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_start_authentication ); |
|
1934 if ( error != core_error_ok ) |
|
1935 { |
|
1936 return error; |
|
1937 } |
|
1938 |
|
1939 core_wlan_eapol_if_parameter_c ssid_parameter; |
|
1940 core_wlan_eapol_if_parameter_c key_authentication_type_parameter; |
|
1941 core_wlan_eapol_if_parameter_c wpa_psk_parameter; |
|
1942 core_wlan_eapol_if_parameter_c wpa_override_enabled_parameter; |
|
1943 |
|
1944 |
|
1945 // Generate parameters |
|
1946 error = ssid_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, ssid, ssid_length ); |
|
1947 if ( error != core_error_ok ) |
|
1948 { |
|
1949 return error; |
|
1950 } |
|
1951 |
|
1952 error = key_authentication_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_authentication_type, selected_eapol_key_authentication_type ); |
|
1953 if ( error != core_error_ok ) |
|
1954 { |
|
1955 return error; |
|
1956 } |
|
1957 error = wpa_psk_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, wpa_psk, wpa_psk_length ); |
|
1958 if ( error != core_error_ok ) |
|
1959 { |
|
1960 return error; |
|
1961 } |
|
1962 error = wpa_override_enabled_parameter.set_parameter_data( wlan_eapol_if_message_type_boolean, wpa_override_enabled ); |
|
1963 if ( error != core_error_ok ) |
|
1964 { |
|
1965 return error; |
|
1966 } |
|
1967 |
|
1968 core_wlan_eapol_if_function_c network_id; |
|
1969 error = network_id.generate_network_id( |
|
1970 receive_network_id ); |
|
1971 if ( error != core_error_ok ) |
|
1972 { |
|
1973 return error; |
|
1974 } |
|
1975 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
1976 |
|
1977 // Append parameters to parameter list |
|
1978 |
|
1979 error = append( &function ); |
|
1980 if ( error != core_error_ok ) |
|
1981 { |
|
1982 return error; |
|
1983 } |
|
1984 error = append( &ssid_parameter ); |
|
1985 if ( error != core_error_ok ) |
|
1986 { |
|
1987 return error; |
|
1988 } |
|
1989 error = append( &key_authentication_type_parameter ); |
|
1990 if ( error != core_error_ok ) |
|
1991 { |
|
1992 return error; |
|
1993 } |
|
1994 error = append( &wpa_psk_parameter ); |
|
1995 if ( error != core_error_ok ) |
|
1996 { |
|
1997 return error; |
|
1998 } |
|
1999 error = append( &wpa_override_enabled_parameter ); |
|
2000 if ( error != core_error_ok ) |
|
2001 { |
|
2002 return error; |
|
2003 } |
|
2004 error = append( &network_id_parameter ); |
|
2005 if ( error != core_error_ok ) |
|
2006 { |
|
2007 return error; |
|
2008 } |
|
2009 |
|
2010 debug_print(); |
|
2011 |
|
2012 return error; |
|
2013 } |
|
2014 |
|
2015 |
|
2016 core_error_e core_wlan_eapol_if_function_c::complete_association( |
|
2017 const wlan_eapol_if_eapol_wlan_authentication_state_e association_result, |
|
2018 const network_id_c * receive_network_id, |
|
2019 u8_t * received_wpa_ie, const u32_t received_wpa_ie_length, |
|
2020 u8_t * sent_wpa_ie, const u32_t sent_wpa_ie_length, |
|
2021 const wlan_eapol_if_rsna_cipher_e pairwise_key_cipher_suite, |
|
2022 const wlan_eapol_if_rsna_cipher_e group_key_cipher_suite ) |
|
2023 { |
|
2024 DEBUG( "core_wlan_eapol_if_function_c::complete_association()" ); |
|
2025 clear(); |
|
2026 |
|
2027 core_error_e error; |
|
2028 core_wlan_eapol_if_parameter_c function; |
|
2029 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_complete_association ); |
|
2030 if ( error != core_error_ok ) |
|
2031 { |
|
2032 return error; |
|
2033 } |
|
2034 |
|
2035 core_wlan_eapol_if_parameter_c association_result_parameter; |
|
2036 core_wlan_eapol_if_parameter_c received_wpa_ie_parameter; |
|
2037 core_wlan_eapol_if_parameter_c sent_wpa_ie_parameter; |
|
2038 core_wlan_eapol_if_parameter_c pairwise_key_cipher_suite_parameter; |
|
2039 core_wlan_eapol_if_parameter_c group_key_cipher_suite_parameter; |
|
2040 |
|
2041 |
|
2042 // Generate parameters |
|
2043 error = association_result_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_wlan_authentication_state, association_result ); |
|
2044 if ( error != core_error_ok ) |
|
2045 { |
|
2046 return error; |
|
2047 } |
|
2048 |
|
2049 core_wlan_eapol_if_function_c network_id; |
|
2050 error = network_id.generate_network_id( |
|
2051 receive_network_id ); |
|
2052 if ( error != core_error_ok ) |
|
2053 { |
|
2054 return error; |
|
2055 } |
|
2056 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2057 |
|
2058 |
|
2059 |
|
2060 error = received_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, received_wpa_ie, received_wpa_ie_length ); |
|
2061 if ( error != core_error_ok ) |
|
2062 { |
|
2063 return error; |
|
2064 } |
|
2065 error = sent_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, sent_wpa_ie, sent_wpa_ie_length ); |
|
2066 if ( error != core_error_ok ) |
|
2067 { |
|
2068 return error; |
|
2069 } |
|
2070 |
|
2071 error = pairwise_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, pairwise_key_cipher_suite ); |
|
2072 if ( error != core_error_ok ) |
|
2073 { |
|
2074 return error; |
|
2075 } |
|
2076 error = group_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, group_key_cipher_suite ); |
|
2077 if ( error != core_error_ok ) |
|
2078 { |
|
2079 return error; |
|
2080 } |
|
2081 |
|
2082 |
|
2083 // Append parameters to parameter list |
|
2084 |
|
2085 error = append( &function ); |
|
2086 if ( error != core_error_ok ) |
|
2087 { |
|
2088 return error; |
|
2089 } |
|
2090 error = append( &association_result_parameter ); |
|
2091 if ( error != core_error_ok ) |
|
2092 { |
|
2093 return error; |
|
2094 } |
|
2095 error = append( &network_id_parameter ); |
|
2096 if ( error != core_error_ok ) |
|
2097 { |
|
2098 return error; |
|
2099 } |
|
2100 error = append( &received_wpa_ie_parameter ); |
|
2101 if ( error != core_error_ok ) |
|
2102 { |
|
2103 return error; |
|
2104 } |
|
2105 error = append( &sent_wpa_ie_parameter ); |
|
2106 if ( error != core_error_ok ) |
|
2107 { |
|
2108 return error; |
|
2109 } |
|
2110 error = append( &pairwise_key_cipher_suite_parameter ); |
|
2111 if ( error != core_error_ok ) |
|
2112 { |
|
2113 return error; |
|
2114 } |
|
2115 error = append( &group_key_cipher_suite_parameter ); |
|
2116 if ( error != core_error_ok ) |
|
2117 { |
|
2118 return error; |
|
2119 } |
|
2120 |
|
2121 debug_print(); |
|
2122 |
|
2123 return error; |
|
2124 } |
|
2125 |
|
2126 |
|
2127 |
|
2128 |
|
2129 core_error_e core_wlan_eapol_if_function_c::disassociation( |
|
2130 const network_id_c * receive_network_id ) |
|
2131 { |
|
2132 DEBUG( "core_wlan_eapol_if_function_c::disassociation()" ); |
|
2133 clear(); |
|
2134 |
|
2135 core_error_e error; |
|
2136 core_wlan_eapol_if_parameter_c function; |
|
2137 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_disassociation ); |
|
2138 if ( error != core_error_ok ) |
|
2139 { |
|
2140 return error; |
|
2141 } |
|
2142 |
|
2143 // Generate parameters |
|
2144 core_wlan_eapol_if_function_c network_id; |
|
2145 error = network_id.generate_network_id( |
|
2146 receive_network_id ); |
|
2147 if ( error != core_error_ok ) |
|
2148 { |
|
2149 return error; |
|
2150 } |
|
2151 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2152 |
|
2153 |
|
2154 // Append parameters to parameter list |
|
2155 |
|
2156 error = append( &function ); |
|
2157 if ( error != core_error_ok ) |
|
2158 { |
|
2159 return error; |
|
2160 } |
|
2161 error = append( &network_id_parameter ); |
|
2162 if ( error != core_error_ok ) |
|
2163 { |
|
2164 return error; |
|
2165 } |
|
2166 |
|
2167 debug_print(); |
|
2168 |
|
2169 return error; |
|
2170 } |
|
2171 |
|
2172 |
|
2173 |
|
2174 core_error_e core_wlan_eapol_if_function_c::start_preauthentication( |
|
2175 const network_id_c * receive_network_id ) |
|
2176 { |
|
2177 DEBUG( "core_wlan_eapol_if_function_c::start_preauthentication()" ); |
|
2178 clear(); |
|
2179 |
|
2180 core_error_e error; |
|
2181 core_wlan_eapol_if_parameter_c function; |
|
2182 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_start_preauthentication ); |
|
2183 if ( error != core_error_ok ) |
|
2184 { |
|
2185 return error; |
|
2186 } |
|
2187 |
|
2188 // Generate parameters |
|
2189 core_wlan_eapol_if_function_c network_id; |
|
2190 error = network_id.generate_network_id( |
|
2191 receive_network_id ); |
|
2192 if ( error != core_error_ok ) |
|
2193 { |
|
2194 return error; |
|
2195 } |
|
2196 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2197 |
|
2198 |
|
2199 // Append parameters to parameter list |
|
2200 |
|
2201 error = append( &function ); |
|
2202 if ( error != core_error_ok ) |
|
2203 { |
|
2204 return error; |
|
2205 } |
|
2206 error = append( &network_id_parameter ); |
|
2207 if ( error != core_error_ok ) |
|
2208 { |
|
2209 return error; |
|
2210 } |
|
2211 |
|
2212 debug_print(); |
|
2213 |
|
2214 return error; |
|
2215 } |
|
2216 |
|
2217 |
|
2218 |
|
2219 |
|
2220 core_error_e core_wlan_eapol_if_function_c::start_reassociation( |
|
2221 const network_id_c * old_receive_network_id, |
|
2222 const network_id_c * new_receive_network_id, |
|
2223 const wlan_eapol_if_eapol_key_authentication_type_e selected_eapol_key_authentication_type ) |
|
2224 { |
|
2225 DEBUG( "core_wlan_eapol_if_function_c::start_reassociation()" ); |
|
2226 clear(); |
|
2227 |
|
2228 core_error_e error; |
|
2229 core_wlan_eapol_if_parameter_c function; |
|
2230 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_start_reassociation ); |
|
2231 if ( error != core_error_ok ) |
|
2232 { |
|
2233 return error; |
|
2234 } |
|
2235 |
|
2236 |
|
2237 // Generate parameters |
|
2238 core_wlan_eapol_if_function_c old_network_id; |
|
2239 error = old_network_id.generate_network_id( |
|
2240 old_receive_network_id ); |
|
2241 if ( error != core_error_ok ) |
|
2242 { |
|
2243 return error; |
|
2244 } |
|
2245 core_wlan_eapol_if_parameter_c old_network_id_parameter( old_network_id.get_data(), old_network_id.size() ); |
|
2246 |
|
2247 |
|
2248 core_wlan_eapol_if_function_c new_network_id; |
|
2249 error = new_network_id.generate_network_id( |
|
2250 new_receive_network_id ); |
|
2251 if ( error != core_error_ok ) |
|
2252 { |
|
2253 return error; |
|
2254 } |
|
2255 core_wlan_eapol_if_parameter_c new_network_id_parameter( new_network_id.get_data(), new_network_id.size() ); |
|
2256 |
|
2257 |
|
2258 core_wlan_eapol_if_parameter_c key_authentication_type_parameter; |
|
2259 error = key_authentication_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_authentication_type, selected_eapol_key_authentication_type ); |
|
2260 if ( error != core_error_ok ) |
|
2261 { |
|
2262 return error; |
|
2263 } |
|
2264 |
|
2265 |
|
2266 // Append parameters to parameter list |
|
2267 |
|
2268 error = append( &function ); |
|
2269 if ( error != core_error_ok ) |
|
2270 { |
|
2271 return error; |
|
2272 } |
|
2273 error = append( &old_network_id_parameter ); |
|
2274 if ( error != core_error_ok ) |
|
2275 { |
|
2276 return error; |
|
2277 } |
|
2278 error = append( &new_network_id_parameter ); |
|
2279 if ( error != core_error_ok ) |
|
2280 { |
|
2281 return error; |
|
2282 } |
|
2283 error = append( &key_authentication_type_parameter ); |
|
2284 if ( error != core_error_ok ) |
|
2285 { |
|
2286 return error; |
|
2287 } |
|
2288 |
|
2289 |
|
2290 debug_print(); |
|
2291 |
|
2292 return error; |
|
2293 } |
|
2294 |
|
2295 |
|
2296 |
|
2297 core_error_e core_wlan_eapol_if_function_c::complete_reassociation( |
|
2298 const wlan_eapol_if_eapol_wlan_authentication_state_e association_result, |
|
2299 const network_id_c * receive_network_id, |
|
2300 u8_t * received_wpa_ie, const u32_t received_wpa_ie_length, |
|
2301 u8_t * sent_wpa_ie, const u32_t sent_wpa_ie_length, |
|
2302 const wlan_eapol_if_rsna_cipher_e pairwise_key_cipher_suite, |
|
2303 const wlan_eapol_if_rsna_cipher_e group_key_cipher_suite ) |
|
2304 { |
|
2305 DEBUG( "core_wlan_eapol_if_function_c::complete_reassociation()" ); |
|
2306 clear(); |
|
2307 |
|
2308 core_error_e error; |
|
2309 core_wlan_eapol_if_parameter_c function; |
|
2310 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_complete_reassociation ); |
|
2311 if ( error != core_error_ok ) |
|
2312 { |
|
2313 return error; |
|
2314 } |
|
2315 |
|
2316 core_wlan_eapol_if_parameter_c association_result_parameter; |
|
2317 core_wlan_eapol_if_parameter_c received_wpa_ie_parameter; |
|
2318 core_wlan_eapol_if_parameter_c sent_wpa_ie_parameter; |
|
2319 core_wlan_eapol_if_parameter_c pairwise_key_cipher_suite_parameter; |
|
2320 core_wlan_eapol_if_parameter_c group_key_cipher_suite_parameter; |
|
2321 |
|
2322 |
|
2323 // Generate parameters |
|
2324 error = association_result_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_wlan_authentication_state, association_result ); |
|
2325 if ( error != core_error_ok ) |
|
2326 { |
|
2327 return error; |
|
2328 } |
|
2329 |
|
2330 core_wlan_eapol_if_function_c network_id; |
|
2331 error = network_id.generate_network_id( |
|
2332 receive_network_id ); |
|
2333 if ( error != core_error_ok ) |
|
2334 { |
|
2335 return error; |
|
2336 } |
|
2337 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2338 |
|
2339 |
|
2340 |
|
2341 error = received_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, received_wpa_ie, received_wpa_ie_length ); |
|
2342 if ( error != core_error_ok ) |
|
2343 { |
|
2344 return error; |
|
2345 } |
|
2346 error = sent_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, sent_wpa_ie, sent_wpa_ie_length ); |
|
2347 if ( error != core_error_ok ) |
|
2348 { |
|
2349 return error; |
|
2350 } |
|
2351 |
|
2352 error = pairwise_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, pairwise_key_cipher_suite ); |
|
2353 if ( error != core_error_ok ) |
|
2354 { |
|
2355 return error; |
|
2356 } |
|
2357 error = group_key_cipher_suite_parameter.set_parameter_data( wlan_eapol_if_message_type_RSNA_cipher, group_key_cipher_suite ); |
|
2358 if ( error != core_error_ok ) |
|
2359 { |
|
2360 return error; |
|
2361 } |
|
2362 |
|
2363 |
|
2364 // Append parameters to parameter list |
|
2365 |
|
2366 error = append( &function ); |
|
2367 if ( error != core_error_ok ) |
|
2368 { |
|
2369 return error; |
|
2370 } |
|
2371 error = append( &association_result_parameter ); |
|
2372 if ( error != core_error_ok ) |
|
2373 { |
|
2374 return error; |
|
2375 } |
|
2376 error = append( &network_id_parameter ); |
|
2377 if ( error != core_error_ok ) |
|
2378 { |
|
2379 return error; |
|
2380 } |
|
2381 error = append( &received_wpa_ie_parameter ); |
|
2382 if ( error != core_error_ok ) |
|
2383 { |
|
2384 return error; |
|
2385 } |
|
2386 error = append( &sent_wpa_ie_parameter ); |
|
2387 if ( error != core_error_ok ) |
|
2388 { |
|
2389 return error; |
|
2390 } |
|
2391 error = append( &pairwise_key_cipher_suite_parameter ); |
|
2392 if ( error != core_error_ok ) |
|
2393 { |
|
2394 return error; |
|
2395 } |
|
2396 error = append( &group_key_cipher_suite_parameter ); |
|
2397 if ( error != core_error_ok ) |
|
2398 { |
|
2399 return error; |
|
2400 } |
|
2401 |
|
2402 debug_print(); |
|
2403 |
|
2404 return error; |
|
2405 } |
|
2406 |
|
2407 |
|
2408 |
|
2409 core_error_e core_wlan_eapol_if_function_c::start_wpx_fast_roam_reassociation( |
|
2410 const network_id_c * old_network_id, |
|
2411 const network_id_c * new_network_id, |
|
2412 u8_t * reassociation_request_ie, |
|
2413 const u32_t reassociation_request_ie_length, |
|
2414 const u8_t* received_wpa_ie, |
|
2415 u32_t received_wpa_ie_length, |
|
2416 const u8_t* sent_wpa_ie, |
|
2417 u32_t sent_wpa_ie_length ) |
|
2418 { |
|
2419 DEBUG( "core_wlan_eapol_if_function_c::start_wpx_fast_roam_reassociation()" ); |
|
2420 clear(); |
|
2421 |
|
2422 core_error_e error; |
|
2423 core_wlan_eapol_if_parameter_c function; |
|
2424 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_start_wpx_fast_roam_reassociation ); |
|
2425 if ( error != core_error_ok ) |
|
2426 { |
|
2427 return error; |
|
2428 } |
|
2429 |
|
2430 |
|
2431 // Generate parameters |
|
2432 core_wlan_eapol_if_function_c network_id_old; |
|
2433 error = network_id_old.generate_network_id( |
|
2434 old_network_id ); |
|
2435 if ( error != core_error_ok ) |
|
2436 { |
|
2437 return error; |
|
2438 } |
|
2439 core_wlan_eapol_if_parameter_c old_network_id_parameter( network_id_old.get_data(), network_id_old.size() ); |
|
2440 |
|
2441 |
|
2442 core_wlan_eapol_if_function_c network_id_new; |
|
2443 error = network_id_new.generate_network_id( |
|
2444 new_network_id ); |
|
2445 if ( error != core_error_ok ) |
|
2446 { |
|
2447 return error; |
|
2448 } |
|
2449 core_wlan_eapol_if_parameter_c new_network_id_parameter( network_id_new.get_data(), network_id_new.size() ); |
|
2450 |
|
2451 |
|
2452 core_wlan_eapol_if_parameter_c reassociation_request_ie_parameter; |
|
2453 error = reassociation_request_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, reassociation_request_ie, reassociation_request_ie_length ); |
|
2454 if ( error != core_error_ok ) |
|
2455 { |
|
2456 return error; |
|
2457 } |
|
2458 |
|
2459 core_wlan_eapol_if_parameter_c received_wpa_ie_parameter; |
|
2460 error = received_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, received_wpa_ie, received_wpa_ie_length ); |
|
2461 if ( error != core_error_ok ) |
|
2462 { |
|
2463 return error; |
|
2464 } |
|
2465 |
|
2466 core_wlan_eapol_if_parameter_c sent_wpa_ie_parameter; |
|
2467 error = sent_wpa_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, sent_wpa_ie, sent_wpa_ie_length ); |
|
2468 if ( error != core_error_ok ) |
|
2469 { |
|
2470 return error; |
|
2471 } |
|
2472 |
|
2473 // Append parameters to parameter list |
|
2474 |
|
2475 error = append( &function ); |
|
2476 if ( error != core_error_ok ) |
|
2477 { |
|
2478 return error; |
|
2479 } |
|
2480 error = append( &old_network_id_parameter ); |
|
2481 if ( error != core_error_ok ) |
|
2482 { |
|
2483 return error; |
|
2484 } |
|
2485 error = append( &new_network_id_parameter ); |
|
2486 if ( error != core_error_ok ) |
|
2487 { |
|
2488 return error; |
|
2489 } |
|
2490 error = append( &reassociation_request_ie_parameter ); |
|
2491 if ( error != core_error_ok ) |
|
2492 { |
|
2493 return error; |
|
2494 } |
|
2495 error = append( &received_wpa_ie_parameter ); |
|
2496 if ( error != core_error_ok ) |
|
2497 { |
|
2498 return error; |
|
2499 } |
|
2500 error = append( &sent_wpa_ie_parameter ); |
|
2501 if ( error != core_error_ok ) |
|
2502 { |
|
2503 return error; |
|
2504 } |
|
2505 |
|
2506 debug_print(); |
|
2507 |
|
2508 return error; |
|
2509 } |
|
2510 |
|
2511 |
|
2512 |
|
2513 |
|
2514 core_error_e core_wlan_eapol_if_function_c::complete_wpx_fast_roam_reassociation( |
|
2515 const wlan_eapol_if_eapol_wlan_authentication_state_e reassociation_result, |
|
2516 const network_id_c * receive_network_id, |
|
2517 u8_t * received_reassociation_ie, const u32_t received_reassociation_ie_length ) |
|
2518 { |
|
2519 DEBUG( "core_wlan_eapol_if_function_c::complete_wpx_fast_roam_reassociation()" ); |
|
2520 clear(); |
|
2521 |
|
2522 core_error_e error; |
|
2523 core_wlan_eapol_if_parameter_c function; |
|
2524 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_complete_wpx_fast_roam_reassociation ); |
|
2525 if ( error != core_error_ok ) |
|
2526 { |
|
2527 return error; |
|
2528 } |
|
2529 |
|
2530 |
|
2531 // Generate parameters |
|
2532 core_wlan_eapol_if_parameter_c reassociation_result_parameter; |
|
2533 error = reassociation_result_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_wlan_authentication_state, reassociation_result ); |
|
2534 if ( error != core_error_ok ) |
|
2535 { |
|
2536 return error; |
|
2537 } |
|
2538 |
|
2539 core_wlan_eapol_if_function_c network_id; |
|
2540 error = network_id.generate_network_id( |
|
2541 receive_network_id ); |
|
2542 if ( error != core_error_ok ) |
|
2543 { |
|
2544 return error; |
|
2545 } |
|
2546 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2547 |
|
2548 |
|
2549 core_wlan_eapol_if_parameter_c received_reassociation_ie_parameter; |
|
2550 error = received_reassociation_ie_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, received_reassociation_ie, received_reassociation_ie_length ); |
|
2551 if ( error != core_error_ok ) |
|
2552 { |
|
2553 return error; |
|
2554 } |
|
2555 |
|
2556 |
|
2557 // Append parameters to parameter list |
|
2558 |
|
2559 error = append( &function ); |
|
2560 if ( error != core_error_ok ) |
|
2561 { |
|
2562 return error; |
|
2563 } |
|
2564 error = append( &reassociation_result_parameter ); |
|
2565 if ( error != core_error_ok ) |
|
2566 { |
|
2567 return error; |
|
2568 } |
|
2569 error = append( &network_id_parameter ); |
|
2570 if ( error != core_error_ok ) |
|
2571 { |
|
2572 return error; |
|
2573 } |
|
2574 error = append( &received_reassociation_ie_parameter ); |
|
2575 if ( error != core_error_ok ) |
|
2576 { |
|
2577 return error; |
|
2578 } |
|
2579 |
|
2580 |
|
2581 debug_print(); |
|
2582 |
|
2583 return error; |
|
2584 } |
|
2585 |
|
2586 |
|
2587 |
|
2588 core_error_e core_wlan_eapol_if_function_c::packet_process( |
|
2589 const network_id_c * receive_network_id, |
|
2590 const u8_t * packet_data, const u32_t packet_data_length ) |
|
2591 { |
|
2592 DEBUG( "core_wlan_eapol_if_function_c::packet_process()" ); |
|
2593 clear(); |
|
2594 |
|
2595 core_error_e error; |
|
2596 core_wlan_eapol_if_parameter_c function; |
|
2597 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_packet_process ); |
|
2598 if ( error != core_error_ok ) |
|
2599 { |
|
2600 return error; |
|
2601 } |
|
2602 |
|
2603 |
|
2604 // Generate parameters |
|
2605 core_wlan_eapol_if_function_c network_id; |
|
2606 error = network_id.generate_network_id( |
|
2607 receive_network_id ); |
|
2608 if ( error != core_error_ok ) |
|
2609 { |
|
2610 return error; |
|
2611 } |
|
2612 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2613 |
|
2614 |
|
2615 core_wlan_eapol_if_parameter_c packet_data_parameter; |
|
2616 error = packet_data_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, packet_data, packet_data_length ); |
|
2617 if ( error != core_error_ok ) |
|
2618 { |
|
2619 return error; |
|
2620 } |
|
2621 |
|
2622 |
|
2623 // Append parameters to parameter list |
|
2624 |
|
2625 error = append( &function ); |
|
2626 if ( error != core_error_ok ) |
|
2627 { |
|
2628 return error; |
|
2629 } |
|
2630 error = append( &network_id_parameter ); |
|
2631 if ( error != core_error_ok ) |
|
2632 { |
|
2633 return error; |
|
2634 } |
|
2635 error = append( &packet_data_parameter ); |
|
2636 if ( error != core_error_ok ) |
|
2637 { |
|
2638 return error; |
|
2639 } |
|
2640 |
|
2641 |
|
2642 debug_print(); |
|
2643 |
|
2644 return error; |
|
2645 } |
|
2646 |
|
2647 |
|
2648 |
|
2649 |
|
2650 core_error_e core_wlan_eapol_if_function_c::tkip_mic_failure( |
|
2651 const network_id_c * receive_network_id, |
|
2652 const bool_t is_fatal_failure, |
|
2653 const wlan_eapol_if_eapol_tkip_mic_failure_type_e tkip_mic_failure_type ) |
|
2654 { |
|
2655 DEBUG( "core_wlan_eapol_if_function_c::tkip_mic_failure()" ); |
|
2656 clear(); |
|
2657 |
|
2658 core_error_e error; |
|
2659 core_wlan_eapol_if_parameter_c function; |
|
2660 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_tkip_mic_failure ); |
|
2661 if ( error != core_error_ok ) |
|
2662 { |
|
2663 return error; |
|
2664 } |
|
2665 |
|
2666 |
|
2667 // Generate parameters |
|
2668 core_wlan_eapol_if_function_c network_id; |
|
2669 error = network_id.generate_network_id( |
|
2670 receive_network_id ); |
|
2671 if ( error != core_error_ok ) |
|
2672 { |
|
2673 return error; |
|
2674 } |
|
2675 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2676 |
|
2677 |
|
2678 core_wlan_eapol_if_parameter_c is_fatal_failure_parameter; |
|
2679 error = is_fatal_failure_parameter.set_parameter_data( wlan_eapol_if_message_type_boolean, is_fatal_failure ); |
|
2680 if ( error != core_error_ok ) |
|
2681 { |
|
2682 return error; |
|
2683 } |
|
2684 |
|
2685 core_wlan_eapol_if_parameter_c tkip_mic_failure_type_parameter; |
|
2686 error = tkip_mic_failure_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_tkip_mic_failure_type, tkip_mic_failure_type ); |
|
2687 if ( error != core_error_ok ) |
|
2688 { |
|
2689 return error; |
|
2690 } |
|
2691 |
|
2692 // Append parameters to parameter list |
|
2693 |
|
2694 error = append( &function ); |
|
2695 if ( error != core_error_ok ) |
|
2696 { |
|
2697 return error; |
|
2698 } |
|
2699 error = append( &network_id_parameter ); |
|
2700 if ( error != core_error_ok ) |
|
2701 { |
|
2702 return error; |
|
2703 } |
|
2704 error = append( &is_fatal_failure_parameter ); |
|
2705 if ( error != core_error_ok ) |
|
2706 { |
|
2707 return error; |
|
2708 } |
|
2709 error = append( &tkip_mic_failure_type_parameter ); |
|
2710 if ( error != core_error_ok ) |
|
2711 { |
|
2712 return error; |
|
2713 } |
|
2714 |
|
2715 |
|
2716 debug_print(); |
|
2717 |
|
2718 return error; |
|
2719 } |
|
2720 |
|
2721 |
|
2722 |
|
2723 core_error_e core_wlan_eapol_if_function_c::eap_acknowledge( |
|
2724 const network_id_c * receive_network_id ) |
|
2725 { |
|
2726 DEBUG( "core_wlan_eapol_if_function_c::eap_acknowledge()" ); |
|
2727 clear(); |
|
2728 |
|
2729 core_error_e error; |
|
2730 core_wlan_eapol_if_parameter_c function; |
|
2731 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_eap_acknowledge ); |
|
2732 if ( error != core_error_ok ) |
|
2733 { |
|
2734 return error; |
|
2735 } |
|
2736 |
|
2737 |
|
2738 // Generate parameters |
|
2739 core_wlan_eapol_if_function_c network_id; |
|
2740 error = network_id.generate_network_id( |
|
2741 receive_network_id ); |
|
2742 if ( error != core_error_ok ) |
|
2743 { |
|
2744 return error; |
|
2745 } |
|
2746 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2747 |
|
2748 |
|
2749 // Append parameters to parameter list |
|
2750 error = append( &function ); |
|
2751 if ( error != core_error_ok ) |
|
2752 { |
|
2753 return error; |
|
2754 } |
|
2755 error = append( &network_id_parameter ); |
|
2756 if ( error != core_error_ok ) |
|
2757 { |
|
2758 return error; |
|
2759 } |
|
2760 |
|
2761 debug_print(); |
|
2762 |
|
2763 return error; |
|
2764 } |
|
2765 |
|
2766 |
|
2767 |
|
2768 core_error_e core_wlan_eapol_if_function_c::update_header_offset( |
|
2769 const u32_t header_offset, |
|
2770 const u32_t MTU, |
|
2771 const u32_t trailer_length ) |
|
2772 { |
|
2773 DEBUG( "core_wlan_eapol_if_function_c::update_header_offset()" ); |
|
2774 clear(); |
|
2775 |
|
2776 core_error_e error; |
|
2777 core_wlan_eapol_if_parameter_c function; |
|
2778 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_update_header_offset ); |
|
2779 if ( error != core_error_ok ) |
|
2780 { |
|
2781 return error; |
|
2782 } |
|
2783 |
|
2784 |
|
2785 // Generate parameters |
|
2786 core_wlan_eapol_if_parameter_c header_offset_parameter; |
|
2787 error = header_offset_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, header_offset ); |
|
2788 if ( error != core_error_ok ) |
|
2789 { |
|
2790 return error; |
|
2791 } |
|
2792 core_wlan_eapol_if_parameter_c MTU_parameter; |
|
2793 error = MTU_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, MTU ); |
|
2794 if ( error != core_error_ok ) |
|
2795 { |
|
2796 return error; |
|
2797 } |
|
2798 core_wlan_eapol_if_parameter_c trailer_length_parameter; |
|
2799 error = trailer_length_parameter.set_parameter_data( wlan_eapol_if_message_type_u32_t, trailer_length ); |
|
2800 if ( error != core_error_ok ) |
|
2801 { |
|
2802 return error; |
|
2803 } |
|
2804 |
|
2805 |
|
2806 |
|
2807 // Append parameters to parameter list |
|
2808 error = append( &function ); |
|
2809 if ( error != core_error_ok ) |
|
2810 { |
|
2811 return error; |
|
2812 } |
|
2813 error = append( &header_offset_parameter ); |
|
2814 if ( error != core_error_ok ) |
|
2815 { |
|
2816 return error; |
|
2817 } |
|
2818 error = append( &MTU_parameter ); |
|
2819 if ( error != core_error_ok ) |
|
2820 { |
|
2821 return error; |
|
2822 } |
|
2823 error = append( &trailer_length_parameter ); |
|
2824 if ( error != core_error_ok ) |
|
2825 { |
|
2826 return error; |
|
2827 } |
|
2828 |
|
2829 debug_print(); |
|
2830 |
|
2831 return error; |
|
2832 } |
|
2833 |
|
2834 |
|
2835 |
|
2836 |
|
2837 core_error_e core_wlan_eapol_if_function_c::generate_complete_check_pmksa_cache( |
|
2838 core_type_list_c<network_id_c> & network_id_list ) |
|
2839 { |
|
2840 DEBUG( "core_wlan_eapol_if_function_c::generate_complete_check_pmksa_cache()" ); |
|
2841 clear(); |
|
2842 |
|
2843 core_error_e error; |
|
2844 core_wlan_eapol_if_parameter_c function; |
|
2845 |
|
2846 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_complete_check_pmksa_cache ); |
|
2847 if ( error != core_error_ok ) |
|
2848 { |
|
2849 return error; |
|
2850 } |
|
2851 |
|
2852 error = append( &function ); |
|
2853 if ( error != core_error_ok ) |
|
2854 { |
|
2855 return error; |
|
2856 } |
|
2857 |
|
2858 // Generate parameters |
|
2859 core_wlan_eapol_if_function_c array; |
|
2860 core_wlan_eapol_if_parameter_c array_parameter; |
|
2861 |
|
2862 network_id_list.first(); |
|
2863 while ( network_id_list.current() ) |
|
2864 { |
|
2865 core_wlan_eapol_if_function_c network_id; |
|
2866 error = network_id.generate_network_id( |
|
2867 network_id_list.current() ); |
|
2868 if ( error != core_error_ok ) |
|
2869 { |
|
2870 return error; |
|
2871 } |
|
2872 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
2873 |
|
2874 error = array.append( &network_id_parameter ); |
|
2875 if ( error != core_error_ok ) |
|
2876 { |
|
2877 return error; |
|
2878 } |
|
2879 network_id_list.next(); |
|
2880 } |
|
2881 |
|
2882 array_parameter.set_parameter_data( wlan_eapol_if_message_type_array, array.get_data(), array.size() ); |
|
2883 error = append( &array_parameter ); |
|
2884 if ( error != core_error_ok ) |
|
2885 { |
|
2886 return error; |
|
2887 } |
|
2888 |
|
2889 |
|
2890 debug_print(); |
|
2891 |
|
2892 return error; |
|
2893 } |
|
2894 |
|
2895 |
|
2896 |
|
2897 |
|
2898 core_error_e core_wlan_eapol_if_function_c::parse_complete_check_pmksa_cache( |
|
2899 core_type_list_c<network_id_c> & network_id_list ) |
|
2900 { |
|
2901 DEBUG( "core_wlan_eapol_if_function_c::parse_complete_check_pmksa_cache()" ); |
|
2902 |
|
2903 core_error_e error( core_error_ok ); |
|
2904 network_id_list.clear(); |
|
2905 |
|
2906 first(); |
|
2907 if ( is_done() ) |
|
2908 { |
|
2909 DEBUG( "core_wlan_eapol_if_function_c::complete_check_pmksa_cache() - message is empty" ); |
|
2910 return core_error_not_found; |
|
2911 } |
|
2912 |
|
2913 // Check function |
|
2914 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
2915 { |
|
2916 return core_error_not_found; |
|
2917 } |
|
2918 |
|
2919 u32_t function_value(0); |
|
2920 current()->get_parameter_data( &function_value ); |
|
2921 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
2922 if ( func != wlan_eapol_if_message_type_function_complete_check_pmksa_cache ) |
|
2923 { |
|
2924 return core_error_not_found; |
|
2925 } |
|
2926 |
|
2927 next(); |
|
2928 |
|
2929 |
|
2930 // Check function parameters |
|
2931 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_array ) |
|
2932 { |
|
2933 return core_error_not_found; |
|
2934 } |
|
2935 |
|
2936 u32_t data_length; |
|
2937 u8_t * data; |
|
2938 error = current()->get_parameter_data( &data, &data_length ); |
|
2939 if ( error != core_error_ok ) |
|
2940 { |
|
2941 return error; |
|
2942 } |
|
2943 |
|
2944 core_wlan_eapol_if_function_c array( data, data_length ); |
|
2945 |
|
2946 // Loop through array, put every parsed network_id to network_id_list. |
|
2947 array.first(); |
|
2948 while ( !array.is_done() ) |
|
2949 { |
|
2950 if ( array.current()->get_parameter_type() != wlan_eapol_if_message_type_network_id ) |
|
2951 { |
|
2952 return core_error_not_found; |
|
2953 } |
|
2954 network_id_c * network_id = new network_id_c( NULL, 0, NULL, 0, 0 ); |
|
2955 if ( !network_id ) |
|
2956 { |
|
2957 DEBUG( "core_wlan_eapol_if_function_c::parse_complete_check_pmksa_cache() - Error: No enough memory!" ); |
|
2958 return core_error_no_memory; |
|
2959 } |
|
2960 error = array.parse_network_id( network_id ); |
|
2961 if ( error != core_error_ok ) |
|
2962 { |
|
2963 delete network_id; |
|
2964 network_id = NULL; |
|
2965 return error; |
|
2966 } |
|
2967 |
|
2968 error = network_id_list.append( network_id ); |
|
2969 if ( error != core_error_ok ) |
|
2970 { |
|
2971 delete network_id; |
|
2972 network_id = NULL; |
|
2973 return error; |
|
2974 } |
|
2975 |
|
2976 array.next(); |
|
2977 } |
|
2978 |
|
2979 return core_error_ok; |
|
2980 } |
|
2981 |
|
2982 core_error_e core_wlan_eapol_if_function_c::generate_packet_send( |
|
2983 network_id_c * send_network_id, |
|
2984 u8_t * packet_data, const u32_t packet_data_length ) |
|
2985 { |
|
2986 DEBUG( "core_wlan_eapol_if_function_c::generate_packet_send()" ); |
|
2987 ASSERT( send_network_id ); |
|
2988 ASSERT( packet_data ); |
|
2989 clear(); |
|
2990 |
|
2991 core_error_e error; |
|
2992 core_wlan_eapol_if_parameter_c function; |
|
2993 |
|
2994 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_packet_send ); |
|
2995 if ( error != core_error_ok ) |
|
2996 { |
|
2997 return error; |
|
2998 } |
|
2999 |
|
3000 error = append( &function ); |
|
3001 if ( error != core_error_ok ) |
|
3002 { |
|
3003 return error; |
|
3004 } |
|
3005 |
|
3006 // Generate parameters |
|
3007 core_wlan_eapol_if_function_c network_id; |
|
3008 error = network_id.generate_network_id( |
|
3009 send_network_id ); |
|
3010 if ( error != core_error_ok ) |
|
3011 { |
|
3012 return error; |
|
3013 } |
|
3014 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
3015 |
|
3016 error = append( &network_id_parameter ); |
|
3017 if ( error != core_error_ok ) |
|
3018 { |
|
3019 return error; |
|
3020 } |
|
3021 |
|
3022 core_wlan_eapol_if_parameter_c packet_parameter; |
|
3023 error = packet_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, packet_data, packet_data_length ); |
|
3024 if ( error != core_error_ok ) |
|
3025 { |
|
3026 return error; |
|
3027 } |
|
3028 |
|
3029 error = append( &packet_parameter ); |
|
3030 if ( error != core_error_ok ) |
|
3031 { |
|
3032 return error; |
|
3033 } |
|
3034 |
|
3035 |
|
3036 debug_print(); |
|
3037 |
|
3038 return error; |
|
3039 } |
|
3040 |
|
3041 core_error_e core_wlan_eapol_if_function_c::parse_packet_send( |
|
3042 network_id_c * network_id, |
|
3043 u8_t ** packet_data, u32_t * packet_data_length ) |
|
3044 { |
|
3045 DEBUG( "core_wlan_eapol_if_function_c::parse_packet_send()" ); |
|
3046 ASSERT( network_id ); |
|
3047 ASSERT( packet_data ); |
|
3048 ASSERT( packet_data_length ); |
|
3049 |
|
3050 core_error_e error( core_error_ok ); |
|
3051 |
|
3052 first(); |
|
3053 if ( is_done() ) |
|
3054 { |
|
3055 DEBUG( "core_wlan_eapol_if_function_c::parse_packet_send() - message is empty" ); |
|
3056 return core_error_not_found; |
|
3057 } |
|
3058 |
|
3059 // Check function |
|
3060 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3061 { |
|
3062 return core_error_not_found; |
|
3063 } |
|
3064 |
|
3065 u32_t function_value(0); |
|
3066 current()->get_parameter_data( &function_value ); |
|
3067 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3068 if ( func != wlan_eapol_if_message_type_function_packet_send ) |
|
3069 { |
|
3070 return core_error_not_found; |
|
3071 } |
|
3072 |
|
3073 next(); |
|
3074 |
|
3075 |
|
3076 // Check function parameters |
|
3077 error = parse_network_id( network_id ); |
|
3078 if ( error != core_error_ok ) |
|
3079 { |
|
3080 return error; |
|
3081 } |
|
3082 |
|
3083 next(); |
|
3084 |
|
3085 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
3086 { |
|
3087 return core_error_not_found; |
|
3088 } |
|
3089 error = current()->get_parameter_data( packet_data, packet_data_length ); |
|
3090 if ( error != core_error_ok ) |
|
3091 { |
|
3092 return error; |
|
3093 } |
|
3094 |
|
3095 |
|
3096 return core_error_ok; |
|
3097 } |
|
3098 |
|
3099 |
|
3100 |
|
3101 core_error_e core_wlan_eapol_if_function_c::generate_associate( |
|
3102 const wlan_eapol_if_eapol_key_authentication_mode_e authentication_mode ) |
|
3103 { |
|
3104 DEBUG( "core_wlan_eapol_if_function_c::generate_associate()" ); |
|
3105 clear(); |
|
3106 |
|
3107 core_error_e error; |
|
3108 core_wlan_eapol_if_parameter_c function; |
|
3109 |
|
3110 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_associate ); |
|
3111 if ( error != core_error_ok ) |
|
3112 { |
|
3113 return error; |
|
3114 } |
|
3115 |
|
3116 error = append( &function ); |
|
3117 if ( error != core_error_ok ) |
|
3118 { |
|
3119 return error; |
|
3120 } |
|
3121 |
|
3122 // Generate parameters |
|
3123 core_wlan_eapol_if_parameter_c authentication_mode_parameter; |
|
3124 error = authentication_mode_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_802_11_authentication_mode, authentication_mode ); |
|
3125 if ( error != core_error_ok ) |
|
3126 { |
|
3127 return error; |
|
3128 } |
|
3129 |
|
3130 error = append( &authentication_mode_parameter ); |
|
3131 if ( error != core_error_ok ) |
|
3132 { |
|
3133 return error; |
|
3134 } |
|
3135 |
|
3136 debug_print(); |
|
3137 |
|
3138 return error; |
|
3139 } |
|
3140 |
|
3141 |
|
3142 |
|
3143 core_error_e core_wlan_eapol_if_function_c::parse_associate( |
|
3144 wlan_eapol_if_eapol_key_authentication_mode_e * authentication_mode ) |
|
3145 { |
|
3146 DEBUG( "core_wlan_eapol_if_function_c::parse_associate()" ); |
|
3147 ASSERT( authentication_mode ); |
|
3148 |
|
3149 core_error_e error( core_error_ok ); |
|
3150 |
|
3151 first(); |
|
3152 if ( is_done() ) |
|
3153 { |
|
3154 DEBUG( "core_wlan_eapol_if_function_c::parse_associate() - message is empty" ); |
|
3155 return core_error_not_found; |
|
3156 } |
|
3157 |
|
3158 // Check function |
|
3159 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3160 { |
|
3161 return core_error_not_found; |
|
3162 } |
|
3163 |
|
3164 u32_t function_value(0); |
|
3165 current()->get_parameter_data( &function_value ); |
|
3166 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3167 if ( func != wlan_eapol_if_message_type_function_associate ) |
|
3168 { |
|
3169 return core_error_not_found; |
|
3170 } |
|
3171 |
|
3172 next(); |
|
3173 |
|
3174 |
|
3175 // Check function parameters |
|
3176 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_eapol_key_802_11_authentication_mode ) |
|
3177 { |
|
3178 return core_error_not_found; |
|
3179 } |
|
3180 u32_t temp_authentication_mode( 0 ); |
|
3181 error = current()->get_parameter_data( &temp_authentication_mode ); |
|
3182 if ( error != core_error_ok ) |
|
3183 { |
|
3184 return error; |
|
3185 } |
|
3186 *authentication_mode = static_cast<wlan_eapol_if_eapol_key_authentication_mode_e>( temp_authentication_mode ); |
|
3187 |
|
3188 return core_error_ok; |
|
3189 } |
|
3190 |
|
3191 |
|
3192 |
|
3193 core_error_e core_wlan_eapol_if_function_c::generate_disassociate( |
|
3194 network_id_c * receive_network_id, |
|
3195 const bool_t self_disassociation ) |
|
3196 { |
|
3197 DEBUG( "core_wlan_eapol_if_function_c::generate_disassociate()" ); |
|
3198 ASSERT( receive_network_id ); |
|
3199 clear(); |
|
3200 |
|
3201 core_error_e error; |
|
3202 core_wlan_eapol_if_parameter_c function; |
|
3203 |
|
3204 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_disassociate ); |
|
3205 if ( error != core_error_ok ) |
|
3206 { |
|
3207 return error; |
|
3208 } |
|
3209 |
|
3210 error = append( &function ); |
|
3211 if ( error != core_error_ok ) |
|
3212 { |
|
3213 return error; |
|
3214 } |
|
3215 |
|
3216 // Generate parameters |
|
3217 core_wlan_eapol_if_function_c network_id; |
|
3218 error = network_id.generate_network_id( |
|
3219 receive_network_id ); |
|
3220 if ( error != core_error_ok ) |
|
3221 { |
|
3222 return error; |
|
3223 } |
|
3224 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
3225 |
|
3226 error = append( &network_id_parameter ); |
|
3227 if ( error != core_error_ok ) |
|
3228 { |
|
3229 return error; |
|
3230 } |
|
3231 |
|
3232 core_wlan_eapol_if_parameter_c self_disassociation_parameter; |
|
3233 error = self_disassociation_parameter.set_parameter_data( wlan_eapol_if_message_type_boolean, self_disassociation ); |
|
3234 if ( error != core_error_ok ) |
|
3235 { |
|
3236 return error; |
|
3237 } |
|
3238 |
|
3239 error = append( &self_disassociation_parameter ); |
|
3240 if ( error != core_error_ok ) |
|
3241 { |
|
3242 return error; |
|
3243 } |
|
3244 |
|
3245 |
|
3246 debug_print(); |
|
3247 |
|
3248 return error; |
|
3249 } |
|
3250 |
|
3251 core_error_e core_wlan_eapol_if_function_c::parse_disassociate( |
|
3252 network_id_c * receive_network_id, |
|
3253 bool_t * self_disassociation ) |
|
3254 { |
|
3255 DEBUG( "core_wlan_eapol_if_function_c::parse_disassociate()" ); |
|
3256 ASSERT( receive_network_id ); |
|
3257 ASSERT( self_disassociation ); |
|
3258 |
|
3259 core_error_e error( core_error_ok ); |
|
3260 |
|
3261 first(); |
|
3262 if ( is_done() ) |
|
3263 { |
|
3264 DEBUG( "core_wlan_eapol_if_function_c::parse_disassociate() - message is empty" ); |
|
3265 return core_error_not_found; |
|
3266 } |
|
3267 |
|
3268 // Check function |
|
3269 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3270 { |
|
3271 return core_error_not_found; |
|
3272 } |
|
3273 |
|
3274 u32_t function_value(0); |
|
3275 current()->get_parameter_data( &function_value ); |
|
3276 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3277 if ( func != wlan_eapol_if_message_type_function_disassociate ) |
|
3278 { |
|
3279 return core_error_not_found; |
|
3280 } |
|
3281 |
|
3282 next(); |
|
3283 |
|
3284 |
|
3285 // Check function parameters |
|
3286 error = parse_network_id( receive_network_id ); |
|
3287 if ( error != core_error_ok ) |
|
3288 { |
|
3289 return error; |
|
3290 } |
|
3291 |
|
3292 next(); |
|
3293 |
|
3294 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_boolean ) |
|
3295 { |
|
3296 return core_error_not_found; |
|
3297 } |
|
3298 error = current()->get_parameter_data( self_disassociation ); |
|
3299 if ( error != core_error_ok ) |
|
3300 { |
|
3301 return error; |
|
3302 } |
|
3303 |
|
3304 |
|
3305 return core_error_ok; |
|
3306 } |
|
3307 |
|
3308 |
|
3309 |
|
3310 |
|
3311 |
|
3312 core_error_e core_wlan_eapol_if_function_c::generate_packet_data_session_key( |
|
3313 network_id_c * send_network_id, |
|
3314 session_key_c * session_key ) |
|
3315 { |
|
3316 DEBUG( "core_wlan_eapol_if_function_c::generate_packet_data_session_key()" ); |
|
3317 ASSERT( send_network_id ); |
|
3318 ASSERT( session_key ); |
|
3319 clear(); |
|
3320 |
|
3321 core_error_e error; |
|
3322 core_wlan_eapol_if_parameter_c function; |
|
3323 |
|
3324 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_packet_data_session_key ); |
|
3325 if ( error != core_error_ok ) |
|
3326 { |
|
3327 return error; |
|
3328 } |
|
3329 |
|
3330 error = append( &function ); |
|
3331 if ( error != core_error_ok ) |
|
3332 { |
|
3333 return error; |
|
3334 } |
|
3335 |
|
3336 // Generate parameters |
|
3337 core_wlan_eapol_if_function_c network_id; |
|
3338 error = network_id.generate_network_id( |
|
3339 send_network_id ); |
|
3340 if ( error != core_error_ok ) |
|
3341 { |
|
3342 return error; |
|
3343 } |
|
3344 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
3345 |
|
3346 error = append( &network_id_parameter ); |
|
3347 if ( error != core_error_ok ) |
|
3348 { |
|
3349 return error; |
|
3350 } |
|
3351 |
|
3352 |
|
3353 core_wlan_eapol_if_function_c generated_session_key; |
|
3354 error = generated_session_key.generate_session_key( |
|
3355 session_key ); |
|
3356 if ( error != core_error_ok ) |
|
3357 { |
|
3358 return error; |
|
3359 } |
|
3360 core_wlan_eapol_if_parameter_c session_key_parameter( generated_session_key.get_data(), generated_session_key.size() ); |
|
3361 |
|
3362 error = append( &session_key_parameter ); |
|
3363 if ( error != core_error_ok ) |
|
3364 { |
|
3365 return error; |
|
3366 } |
|
3367 |
|
3368 debug_print(); |
|
3369 |
|
3370 return error; |
|
3371 } |
|
3372 |
|
3373 |
|
3374 |
|
3375 |
|
3376 core_error_e core_wlan_eapol_if_function_c::parse_packet_data_session_key( |
|
3377 network_id_c * send_network_id, |
|
3378 session_key_c * session_key ) |
|
3379 { |
|
3380 DEBUG( "core_wlan_eapol_if_function_c::parse_packet_data_session_key()" ); |
|
3381 ASSERT( send_network_id ); |
|
3382 ASSERT( session_key ); |
|
3383 |
|
3384 core_error_e error( core_error_ok ); |
|
3385 |
|
3386 first(); |
|
3387 if ( is_done() ) |
|
3388 { |
|
3389 DEBUG( "core_wlan_eapol_if_function_c::parse_packet_data_session_key() - message is empty" ); |
|
3390 return core_error_not_found; |
|
3391 } |
|
3392 |
|
3393 // Check function |
|
3394 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3395 { |
|
3396 return core_error_not_found; |
|
3397 } |
|
3398 |
|
3399 u32_t function_value(0); |
|
3400 current()->get_parameter_data( &function_value ); |
|
3401 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3402 if ( func != wlan_eapol_if_message_type_function_packet_data_session_key ) |
|
3403 { |
|
3404 return core_error_not_found; |
|
3405 } |
|
3406 |
|
3407 next(); |
|
3408 |
|
3409 |
|
3410 // Check function parameters |
|
3411 error = parse_network_id( send_network_id ); |
|
3412 if ( error != core_error_ok ) |
|
3413 { |
|
3414 return error; |
|
3415 } |
|
3416 |
|
3417 next(); |
|
3418 |
|
3419 error = parse_session_key( |
|
3420 session_key ); |
|
3421 if ( error != core_error_ok ) |
|
3422 { |
|
3423 return error; |
|
3424 } |
|
3425 |
|
3426 return core_error_ok; |
|
3427 } |
|
3428 |
|
3429 |
|
3430 |
|
3431 |
|
3432 core_error_e core_wlan_eapol_if_function_c::generate_state_notification( |
|
3433 state_notification_c * state_notification ) |
|
3434 { |
|
3435 DEBUG( "core_wlan_eapol_if_function_c::generate_state_notification()" ); |
|
3436 ASSERT( state_notification ); |
|
3437 clear(); |
|
3438 |
|
3439 core_error_e error; |
|
3440 core_wlan_eapol_if_parameter_c function; |
|
3441 |
|
3442 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_state_notification ); |
|
3443 if ( error != core_error_ok ) |
|
3444 { |
|
3445 return error; |
|
3446 } |
|
3447 |
|
3448 error = append( &function ); |
|
3449 if ( error != core_error_ok ) |
|
3450 { |
|
3451 return error; |
|
3452 } |
|
3453 |
|
3454 // Generate parameters |
|
3455 core_wlan_eapol_if_function_c state_notif; |
|
3456 error = state_notif.generate_eap_state_notification( |
|
3457 state_notification ); |
|
3458 if ( error != core_error_ok ) |
|
3459 { |
|
3460 return error; |
|
3461 } |
|
3462 core_wlan_eapol_if_parameter_c state_notification_parameter( state_notif.get_data(), state_notif.size() ); |
|
3463 |
|
3464 error = append( &state_notification_parameter ); |
|
3465 if ( error != core_error_ok ) |
|
3466 { |
|
3467 return error; |
|
3468 } |
|
3469 |
|
3470 debug_print(); |
|
3471 |
|
3472 return error; |
|
3473 } |
|
3474 |
|
3475 |
|
3476 |
|
3477 |
|
3478 core_error_e core_wlan_eapol_if_function_c::parse_state_notification( |
|
3479 state_notification_c * state_notification ) |
|
3480 { |
|
3481 DEBUG( "core_wlan_eapol_if_function_c::parse_state_notification()" ); |
|
3482 ASSERT( state_notification ); |
|
3483 |
|
3484 core_error_e error( core_error_ok ); |
|
3485 |
|
3486 first(); |
|
3487 if ( is_done() ) |
|
3488 { |
|
3489 DEBUG( "core_wlan_eapol_if_function_c::parse_state_notification() - message is empty" ); |
|
3490 return core_error_not_found; |
|
3491 } |
|
3492 |
|
3493 // Check function |
|
3494 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3495 { |
|
3496 return core_error_not_found; |
|
3497 } |
|
3498 |
|
3499 u32_t function_value(0); |
|
3500 current()->get_parameter_data( &function_value ); |
|
3501 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3502 if ( func != wlan_eapol_if_message_type_function_state_notification ) |
|
3503 { |
|
3504 return core_error_not_found; |
|
3505 } |
|
3506 |
|
3507 next(); |
|
3508 |
|
3509 |
|
3510 // Check function parameters |
|
3511 error = parse_eap_state_notification( state_notification ); |
|
3512 if ( error != core_error_ok ) |
|
3513 { |
|
3514 return error; |
|
3515 } |
|
3516 |
|
3517 return core_error_ok; |
|
3518 } |
|
3519 |
|
3520 |
|
3521 core_error_e core_wlan_eapol_if_function_c::generate_reassociate( |
|
3522 network_id_c * send_network_id, |
|
3523 wlan_eapol_if_eapol_key_authentication_type_e authentication_type, |
|
3524 u8_t * pmkid, |
|
3525 u32_t pmkid_length ) |
|
3526 { |
|
3527 DEBUG( "core_wlan_eapol_if_function_c::generate_reassociate()" ); |
|
3528 ASSERT( send_network_id ); |
|
3529 ASSERT( pmkid ); |
|
3530 clear(); |
|
3531 |
|
3532 core_error_e error; |
|
3533 core_wlan_eapol_if_parameter_c function; |
|
3534 |
|
3535 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_reassociate ); |
|
3536 if ( error != core_error_ok ) |
|
3537 { |
|
3538 return error; |
|
3539 } |
|
3540 |
|
3541 error = append( &function ); |
|
3542 if ( error != core_error_ok ) |
|
3543 { |
|
3544 return error; |
|
3545 } |
|
3546 |
|
3547 // Generate parameters |
|
3548 core_wlan_eapol_if_function_c network_id; |
|
3549 error = network_id.generate_network_id( |
|
3550 send_network_id ); |
|
3551 if ( error != core_error_ok ) |
|
3552 { |
|
3553 return error; |
|
3554 } |
|
3555 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
3556 |
|
3557 error = append( &network_id_parameter ); |
|
3558 if ( error != core_error_ok ) |
|
3559 { |
|
3560 return error; |
|
3561 } |
|
3562 |
|
3563 core_wlan_eapol_if_parameter_c authentication_type_parameter; |
|
3564 error = authentication_type_parameter.set_parameter_data( wlan_eapol_if_message_type_eapol_key_authentication_type, authentication_type ); |
|
3565 if ( error != core_error_ok ) |
|
3566 { |
|
3567 return error; |
|
3568 } |
|
3569 |
|
3570 error = append( &authentication_type_parameter ); |
|
3571 if ( error != core_error_ok ) |
|
3572 { |
|
3573 return error; |
|
3574 } |
|
3575 |
|
3576 core_wlan_eapol_if_parameter_c pmkid_parameter; |
|
3577 error = pmkid_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, pmkid, pmkid_length ); |
|
3578 if ( error != core_error_ok ) |
|
3579 { |
|
3580 return error; |
|
3581 } |
|
3582 |
|
3583 error = append( &pmkid_parameter ); |
|
3584 if ( error != core_error_ok ) |
|
3585 { |
|
3586 return error; |
|
3587 } |
|
3588 |
|
3589 debug_print(); |
|
3590 |
|
3591 return error; |
|
3592 } |
|
3593 |
|
3594 |
|
3595 core_error_e core_wlan_eapol_if_function_c::parse_reassociate( |
|
3596 network_id_c * send_network_id, |
|
3597 wlan_eapol_if_eapol_key_authentication_type_e * authentication_type, |
|
3598 u8_t ** pmkid, |
|
3599 u32_t * pmkid_length ) |
|
3600 { |
|
3601 DEBUG( "core_wlan_eapol_if_function_c::parse_reassociate()" ); |
|
3602 ASSERT( send_network_id ); |
|
3603 ASSERT( authentication_type ); |
|
3604 ASSERT( pmkid ); |
|
3605 ASSERT( pmkid_length ); |
|
3606 |
|
3607 core_error_e error( core_error_ok ); |
|
3608 |
|
3609 first(); |
|
3610 if ( is_done() ) |
|
3611 { |
|
3612 DEBUG( "core_wlan_eapol_if_function_c::parse_reassociate() - message is empty" ); |
|
3613 return core_error_not_found; |
|
3614 } |
|
3615 |
|
3616 // Check function |
|
3617 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3618 { |
|
3619 return core_error_not_found; |
|
3620 } |
|
3621 |
|
3622 u32_t function_value(0); |
|
3623 current()->get_parameter_data( &function_value ); |
|
3624 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3625 if ( func != wlan_eapol_if_message_type_function_reassociate ) |
|
3626 { |
|
3627 return core_error_not_found; |
|
3628 } |
|
3629 |
|
3630 next(); |
|
3631 |
|
3632 // Check function parameters |
|
3633 error = parse_network_id( send_network_id ); |
|
3634 if ( error != core_error_ok ) |
|
3635 { |
|
3636 return error; |
|
3637 } |
|
3638 |
|
3639 next(); |
|
3640 |
|
3641 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_eapol_key_authentication_type ) |
|
3642 { |
|
3643 return core_error_not_found; |
|
3644 } |
|
3645 u32_t temp_authentication_type( 0 ); |
|
3646 error = current()->get_parameter_data( &temp_authentication_type ); |
|
3647 if ( error != core_error_ok ) |
|
3648 { |
|
3649 return error; |
|
3650 } |
|
3651 *authentication_type = static_cast<wlan_eapol_if_eapol_key_authentication_type_e>( temp_authentication_type ); |
|
3652 |
|
3653 next(); |
|
3654 |
|
3655 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
3656 { |
|
3657 return core_error_not_found; |
|
3658 } |
|
3659 error = current()->get_parameter_data( pmkid, pmkid_length ); |
|
3660 if ( error != core_error_ok ) |
|
3661 { |
|
3662 return error; |
|
3663 } |
|
3664 |
|
3665 |
|
3666 return core_error_ok; |
|
3667 } |
|
3668 |
|
3669 |
|
3670 core_error_e core_wlan_eapol_if_function_c::update_wlan_database_reference_values( |
|
3671 u8_t * database_reference_value, const u32_t database_reference_value_length ) |
|
3672 { |
|
3673 DEBUG( "core_wlan_eapol_if_function_c::update_wlan_database_reference_values()" ); |
|
3674 ASSERT( database_reference_value ); |
|
3675 clear(); |
|
3676 |
|
3677 core_error_e error; |
|
3678 core_wlan_eapol_if_parameter_c function; |
|
3679 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_update_wlan_database_reference_values ); |
|
3680 if ( error != core_error_ok ) |
|
3681 { |
|
3682 return error; |
|
3683 } |
|
3684 |
|
3685 |
|
3686 // Generate parameters |
|
3687 core_wlan_eapol_if_parameter_c database_reference_value_parameter; |
|
3688 error = database_reference_value_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, database_reference_value, database_reference_value_length ); |
|
3689 if ( error != core_error_ok ) |
|
3690 { |
|
3691 return error; |
|
3692 } |
|
3693 |
|
3694 // Append parameters to parameter list |
|
3695 error = append( &function ); |
|
3696 if ( error != core_error_ok ) |
|
3697 { |
|
3698 return error; |
|
3699 } |
|
3700 error = append( &database_reference_value_parameter ); |
|
3701 if ( error != core_error_ok ) |
|
3702 { |
|
3703 return error; |
|
3704 } |
|
3705 |
|
3706 debug_print(); |
|
3707 |
|
3708 return error; |
|
3709 } |
|
3710 |
|
3711 |
|
3712 |
|
3713 |
|
3714 |
|
3715 core_error_e core_wlan_eapol_if_function_c::generate_complete_start_wpx_fast_roam_reassociation( |
|
3716 network_id_c * receive_network_id, |
|
3717 u8_t * reassociation_request_ie, |
|
3718 u32_t reassociation_request_ie_length ) |
|
3719 { |
|
3720 DEBUG( "core_wlan_eapol_if_function_c::generate_complete_start_wpx_fast_roam_reassociation()" ); |
|
3721 ASSERT( receive_network_id ); |
|
3722 ASSERT( reassociation_request_ie ); |
|
3723 clear(); |
|
3724 |
|
3725 core_error_e error; |
|
3726 core_wlan_eapol_if_parameter_c function; |
|
3727 |
|
3728 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_complete_start_wpx_fast_roam_reassociation ); |
|
3729 if ( error != core_error_ok ) |
|
3730 { |
|
3731 return error; |
|
3732 } |
|
3733 |
|
3734 error = append( &function ); |
|
3735 if ( error != core_error_ok ) |
|
3736 { |
|
3737 return error; |
|
3738 } |
|
3739 |
|
3740 // Generate parameters |
|
3741 core_wlan_eapol_if_function_c network_id; |
|
3742 error = network_id.generate_network_id( |
|
3743 receive_network_id ); |
|
3744 if ( error != core_error_ok ) |
|
3745 { |
|
3746 return error; |
|
3747 } |
|
3748 core_wlan_eapol_if_parameter_c network_id_parameter( network_id.get_data(), network_id.size() ); |
|
3749 |
|
3750 error = append( &network_id_parameter ); |
|
3751 if ( error != core_error_ok ) |
|
3752 { |
|
3753 return error; |
|
3754 } |
|
3755 |
|
3756 |
|
3757 core_wlan_eapol_if_parameter_c pmkid_parameter; |
|
3758 error = pmkid_parameter.set_parameter_data( wlan_eapol_if_message_type_variable_data, reassociation_request_ie, reassociation_request_ie_length ); |
|
3759 if ( error != core_error_ok ) |
|
3760 { |
|
3761 return error; |
|
3762 } |
|
3763 |
|
3764 error = append( &pmkid_parameter ); |
|
3765 if ( error != core_error_ok ) |
|
3766 { |
|
3767 return error; |
|
3768 } |
|
3769 |
|
3770 debug_print(); |
|
3771 |
|
3772 return error; |
|
3773 } |
|
3774 |
|
3775 core_error_e core_wlan_eapol_if_function_c::parse_complete_start_wpx_fast_roam_reassociation( |
|
3776 network_id_c * receive_network_id, |
|
3777 u8_t ** reassociation_request_ie, |
|
3778 u32_t * reassociation_request_ie_length ) |
|
3779 { |
|
3780 DEBUG( "core_wlan_eapol_if_function_c::parse_complete_start_wpx_fast_roam_reassociation()" ); |
|
3781 ASSERT( receive_network_id ); |
|
3782 ASSERT( reassociation_request_ie ); |
|
3783 ASSERT( reassociation_request_ie_length ); |
|
3784 |
|
3785 core_error_e error( core_error_ok ); |
|
3786 |
|
3787 first(); |
|
3788 if ( is_done() ) |
|
3789 { |
|
3790 DEBUG( "core_wlan_eapol_if_function_c::parse_complete_start_wpx_fast_roam_reassociation() - message is empty" ); |
|
3791 return core_error_not_found; |
|
3792 } |
|
3793 |
|
3794 // Check function |
|
3795 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3796 { |
|
3797 return core_error_not_found; |
|
3798 } |
|
3799 |
|
3800 u32_t function_value(0); |
|
3801 current()->get_parameter_data( &function_value ); |
|
3802 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
3803 if ( func != wlan_eapol_if_message_type_function_complete_start_wpx_fast_roam_reassociation ) |
|
3804 { |
|
3805 return core_error_not_found; |
|
3806 } |
|
3807 |
|
3808 next(); |
|
3809 |
|
3810 // Check function parameters |
|
3811 error = parse_network_id( receive_network_id ); |
|
3812 if ( error != core_error_ok ) |
|
3813 { |
|
3814 return error; |
|
3815 } |
|
3816 |
|
3817 next(); |
|
3818 |
|
3819 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_variable_data ) |
|
3820 { |
|
3821 return core_error_not_found; |
|
3822 } |
|
3823 error = current()->get_parameter_data( reassociation_request_ie, reassociation_request_ie_length ); |
|
3824 if ( error != core_error_ok ) |
|
3825 { |
|
3826 return error; |
|
3827 } |
|
3828 |
|
3829 |
|
3830 return core_error_ok; |
|
3831 } |
|
3832 |
|
3833 |
|
3834 core_error_e core_wlan_eapol_if_function_c::generate_error( |
|
3835 wlan_eapol_if_error_e errorcode, |
|
3836 wlan_eapol_if_message_type_function_e function ) |
|
3837 { |
|
3838 DEBUG( "core_wlan_eapol_if_function_c::generate_error()" ); |
|
3839 clear(); |
|
3840 |
|
3841 core_error_e error; |
|
3842 core_wlan_eapol_if_parameter_c error_parameter; |
|
3843 core_wlan_eapol_if_parameter_c function_parameter; |
|
3844 |
|
3845 error = error_parameter.set_parameter_data( wlan_eapol_if_message_type_error, errorcode ); |
|
3846 if ( error != core_error_ok ) |
|
3847 { |
|
3848 return error; |
|
3849 } |
|
3850 error = append( &error_parameter ); |
|
3851 if ( error != core_error_ok ) |
|
3852 { |
|
3853 return error; |
|
3854 } |
|
3855 |
|
3856 |
|
3857 error = function_parameter.set_parameter_data( wlan_eapol_if_message_type_function, function ); |
|
3858 if ( error != core_error_ok ) |
|
3859 { |
|
3860 return error; |
|
3861 } |
|
3862 error = append( &function_parameter ); |
|
3863 if ( error != core_error_ok ) |
|
3864 { |
|
3865 return error; |
|
3866 } |
|
3867 |
|
3868 debug_print(); |
|
3869 |
|
3870 return error; |
|
3871 } |
|
3872 |
|
3873 |
|
3874 |
|
3875 |
|
3876 core_error_e core_wlan_eapol_if_function_c::parse_error( |
|
3877 wlan_eapol_if_error_e * errorcode, |
|
3878 wlan_eapol_if_message_type_function_e * function ) |
|
3879 { |
|
3880 DEBUG( "core_wlan_eapol_if_function_c::parse_error()" ); |
|
3881 ASSERT( errorcode ); |
|
3882 ASSERT( function ); |
|
3883 |
|
3884 core_error_e error( core_error_ok ); |
|
3885 |
|
3886 first(); |
|
3887 if ( is_done() ) |
|
3888 { |
|
3889 DEBUG( "core_wlan_eapol_if_function_c::parse_error() - message is empty" ); |
|
3890 return core_error_not_found; |
|
3891 } |
|
3892 |
|
3893 // Check error |
|
3894 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_error ) |
|
3895 { |
|
3896 return core_error_not_found; |
|
3897 } |
|
3898 u32_t temp_errorcode( 0 ); |
|
3899 error = current()->get_parameter_data( &temp_errorcode ); |
|
3900 if ( error != core_error_ok ) |
|
3901 { |
|
3902 return error; |
|
3903 } |
|
3904 *errorcode = static_cast<wlan_eapol_if_error_e>( temp_errorcode ); |
|
3905 |
|
3906 next(); |
|
3907 u32_t function_value(0); |
|
3908 current()->get_parameter_data( &function_value ); |
|
3909 *function = static_cast<wlan_eapol_if_message_type_function_e>( function_value ); |
|
3910 |
|
3911 DEBUG2( "core_wlan_eapol_if_function_c::parse_error() - Error message received: errorcode=%i, function=%i", *errorcode, *function ); |
|
3912 |
|
3913 return core_error_ok; |
|
3914 } |
|
3915 |
|
3916 |
|
3917 |
|
3918 core_error_e core_wlan_eapol_if_function_c::generate_new_protected_setup_credentials( |
|
3919 core_type_list_c< protected_setup_credential_c > & credential_list ) |
|
3920 { |
|
3921 DEBUG( "core_wlan_eapol_if_function_c::generate_new_protected_setup_credentials()" ); |
|
3922 clear(); |
|
3923 |
|
3924 core_error_e error; |
|
3925 core_wlan_eapol_if_parameter_c function; |
|
3926 |
|
3927 error = function.set_parameter_data( wlan_eapol_if_message_type_function, wlan_eapol_if_message_type_function_new_protected_setup_credentials ); |
|
3928 if ( error != core_error_ok ) |
|
3929 { |
|
3930 return error; |
|
3931 } |
|
3932 |
|
3933 error = append( &function ); |
|
3934 if ( error != core_error_ok ) |
|
3935 { |
|
3936 return error; |
|
3937 } |
|
3938 |
|
3939 // Generate parameters |
|
3940 core_wlan_eapol_if_function_c array; |
|
3941 core_wlan_eapol_if_parameter_c array_parameter; |
|
3942 |
|
3943 credential_list.first(); |
|
3944 while ( credential_list.current() ) |
|
3945 { |
|
3946 core_wlan_eapol_if_function_c credential; |
|
3947 error = credential.generate_protected_setup_credential( |
|
3948 credential_list.current() ); |
|
3949 if ( error != core_error_ok ) |
|
3950 { |
|
3951 return error; |
|
3952 } |
|
3953 core_wlan_eapol_if_parameter_c credential_parameter( credential.get_data(), credential.size() ); |
|
3954 |
|
3955 error = array.append( &credential_parameter ); |
|
3956 if ( error != core_error_ok ) |
|
3957 { |
|
3958 return error; |
|
3959 } |
|
3960 credential_list.next(); |
|
3961 } |
|
3962 |
|
3963 array_parameter.set_parameter_data( wlan_eapol_if_message_type_array, array.get_data(), array.size() ); |
|
3964 error = append( &array_parameter ); |
|
3965 if ( error != core_error_ok ) |
|
3966 { |
|
3967 return error; |
|
3968 } |
|
3969 |
|
3970 |
|
3971 debug_print(); |
|
3972 |
|
3973 return error; |
|
3974 } |
|
3975 |
|
3976 |
|
3977 |
|
3978 core_error_e core_wlan_eapol_if_function_c::parse_new_protected_setup_credentials( |
|
3979 core_type_list_c< protected_setup_credential_c > & credential_list ) |
|
3980 { |
|
3981 DEBUG( "core_wlan_eapol_if_function_c::parse_new_protected_setup_credentials()" ); |
|
3982 |
|
3983 core_error_e error( core_error_ok ); |
|
3984 credential_list.clear(); |
|
3985 |
|
3986 first(); |
|
3987 if ( is_done() ) |
|
3988 { |
|
3989 DEBUG( "core_wlan_eapol_if_function_c::parse_new_protected_setup_credentials() - message is empty" ); |
|
3990 return core_error_not_found; |
|
3991 } |
|
3992 |
|
3993 // Check function |
|
3994 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_function ) |
|
3995 { |
|
3996 return core_error_not_found; |
|
3997 } |
|
3998 |
|
3999 u32_t function_value(0); |
|
4000 current()->get_parameter_data( &function_value ); |
|
4001 wlan_eapol_if_message_type_function_e func( static_cast<wlan_eapol_if_message_type_function_e>( function_value ) ); |
|
4002 if ( func != wlan_eapol_if_message_type_function_new_protected_setup_credentials ) |
|
4003 { |
|
4004 return core_error_not_found; |
|
4005 } |
|
4006 |
|
4007 next(); |
|
4008 |
|
4009 |
|
4010 // Check function parameters |
|
4011 if ( current()->get_parameter_type() != wlan_eapol_if_message_type_array ) |
|
4012 { |
|
4013 return core_error_not_found; |
|
4014 } |
|
4015 |
|
4016 u32_t data_length; |
|
4017 u8_t * data; |
|
4018 error = current()->get_parameter_data( &data, &data_length ); |
|
4019 if ( error != core_error_ok ) |
|
4020 { |
|
4021 return error; |
|
4022 } |
|
4023 |
|
4024 core_wlan_eapol_if_function_c array( data, data_length ); |
|
4025 |
|
4026 // Loop through array, put every parsed credential to credential_list. |
|
4027 array.first(); |
|
4028 while ( !array.is_done() ) |
|
4029 { |
|
4030 if ( array.current()->get_parameter_type() != wlan_eapol_if_message_type_protected_setup_credential ) |
|
4031 { |
|
4032 return core_error_not_found; |
|
4033 } |
|
4034 protected_setup_credential_c * credential = new protected_setup_credential_c( 0, NULL, 0, 0, 0, NULL, 0 ); |
|
4035 if ( !credential ) |
|
4036 { |
|
4037 DEBUG( "core_wlan_eapol_if_function_c::parse_new_protected_setup_credentials() - Error: No enough memory!" ); |
|
4038 return core_error_no_memory; |
|
4039 } |
|
4040 error = array.parse_protected_setup_credential( credential ); |
|
4041 if ( error != core_error_ok ) |
|
4042 { |
|
4043 delete credential; |
|
4044 credential = NULL; |
|
4045 return error; |
|
4046 } |
|
4047 |
|
4048 error = credential_list.append( credential ); |
|
4049 if ( error != core_error_ok ) |
|
4050 { |
|
4051 delete credential; |
|
4052 credential = NULL; |
|
4053 return error; |
|
4054 } |
|
4055 |
|
4056 array.next(); |
|
4057 } |
|
4058 |
|
4059 return core_error_ok; |
|
4060 } |
|
4061 |
|
4062 |