xref: /freebsd/contrib/wpa/src/pae/ieee802_1x_cp.c (revision 85732ac8) 
1 /*
2  * IEEE 802.1X-2010 Controlled Port of PAE state machine - CP state machine
3  * Copyright (c) 2013-2014, Qualcomm Atheros, Inc.
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  */
8 
9 #include "utils/includes.h"
10 
11 #include "utils/common.h"
12 #include "utils/eloop.h"
13 #include "common/defs.h"
14 #include "common/ieee802_1x_defs.h"
15 #include "utils/state_machine.h"
16 #include "ieee802_1x_kay.h"
17 #include "ieee802_1x_secy_ops.h"
18 #include "pae/ieee802_1x_cp.h"
19 
20 #define STATE_MACHINE_DATA struct ieee802_1x_cp_sm
21 #define STATE_MACHINE_DEBUG_PREFIX "CP"
22 
23 static u64 default_cs_id = CS_ID_GCM_AES_128;
24 
25 /* The variable defined in clause 12 in IEEE Std 802.1X-2010 */
26 enum connect_type { PENDING, UNAUTHENTICATED, AUTHENTICATED, SECURE };
27 
28 struct ieee802_1x_cp_sm {
29 	enum cp_states {
30 		CP_BEGIN, CP_INIT, CP_CHANGE, CP_ALLOWED, CP_AUTHENTICATED,
31 		CP_SECURED, CP_RECEIVE, CP_RECEIVING, CP_READY, CP_TRANSMIT,
32 		CP_TRANSMITTING, CP_ABANDON, CP_RETIRE
33 	} CP_state;
34 	Boolean changed;
35 
36 	/* CP -> Client */
37 	Boolean port_valid;
38 
39 	/* Logon -> CP */
40 	enum connect_type connect;
41 	u8 *authorization_data;
42 
43 	/* KaY -> CP */
44 	Boolean chgd_server; /* clear by CP */
45 	Boolean elected_self;
46 	u8 *authorization_data1;
47 	enum confidentiality_offset cipher_offset;
48 	u64 cipher_suite;
49 	Boolean new_sak; /* clear by CP */
50 	struct ieee802_1x_mka_ki distributed_ki;
51 	u8 distributed_an;
52 	Boolean using_receive_sas;
53 	Boolean all_receiving;
54 	Boolean server_transmitting;
55 	Boolean using_transmit_sa;
56 
57 	/* CP -> KaY */
58 	struct ieee802_1x_mka_ki *lki;
59 	u8 lan;
60 	Boolean ltx;
61 	Boolean lrx;
62 	struct ieee802_1x_mka_ki *oki;
63 	u8 oan;
64 	Boolean otx;
65 	Boolean orx;
66 
67 	/* CP -> SecY */
68 	Boolean protect_frames;
69 	enum validate_frames validate_frames;
70 
71 	Boolean replay_protect;
72 	u32 replay_window;
73 
74 	u64 current_cipher_suite;
75 	enum confidentiality_offset confidentiality_offset;
76 	Boolean controlled_port_enabled;
77 
78 	/* SecY -> CP */
79 	Boolean port_enabled; /* SecY->CP */
80 
81 	/* private */
82 	u32 transmit_when;
83 	u32 transmit_delay;
84 	u32 retire_when;
85 	u32 retire_delay;
86 
87 	/* not defined IEEE Std 802.1X-2010 */
88 	struct ieee802_1x_kay *kay;
89 };
90 
91 static void ieee802_1x_cp_retire_when_timeout(void *eloop_ctx,
92 					      void *timeout_ctx);
93 static void ieee802_1x_cp_transmit_when_timeout(void *eloop_ctx,
94 						void *timeout_ctx);
95 
96 
97 static int changed_cipher(struct ieee802_1x_cp_sm *sm)
98 {
99 	return sm->confidentiality_offset != sm->cipher_offset ||
100 		sm->current_cipher_suite != sm->cipher_suite;
101 }
102 
103 
104 static int changed_connect(struct ieee802_1x_cp_sm *sm)
105 {
106 	return sm->connect != SECURE || sm->chgd_server || changed_cipher(sm);
107 }
108 
109 
110 SM_STATE(CP, INIT)
111 {
112 	SM_ENTRY(CP, INIT);
113 
114 	sm->controlled_port_enabled = FALSE;
115 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
116 
117 	sm->port_valid = FALSE;
118 
119 	os_free(sm->lki);
120 	sm->lki = NULL;
121 	sm->ltx = FALSE;
122 	sm->lrx = FALSE;
123 
124 	os_free(sm->oki);
125 	sm->oki = NULL;
126 	sm->otx = FALSE;
127 	sm->orx = FALSE;
128 
129 	sm->port_enabled = TRUE;
130 	sm->chgd_server = FALSE;
131 }
132 
133 
134 SM_STATE(CP, CHANGE)
135 {
136 	SM_ENTRY(CP, CHANGE);
137 
138 	sm->port_valid = FALSE;
139 	sm->controlled_port_enabled = FALSE;
140 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
141 
142 	if (sm->lki)
143 		ieee802_1x_kay_delete_sas(sm->kay, sm->lki);
144 	if (sm->oki)
145 		ieee802_1x_kay_delete_sas(sm->kay, sm->oki);
146 }
147 
148 
149 SM_STATE(CP, ALLOWED)
150 {
151 	SM_ENTRY(CP, ALLOWED);
152 
153 	sm->protect_frames = FALSE;
154 	sm->replay_protect = FALSE;
155 	sm->validate_frames = Checked;
156 
157 	sm->port_valid = FALSE;
158 	sm->controlled_port_enabled = TRUE;
159 
160 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
161 	secy_cp_control_protect_frames(sm->kay, sm->protect_frames);
162 	secy_cp_control_encrypt(sm->kay, sm->kay->macsec_encrypt);
163 	secy_cp_control_validate_frames(sm->kay, sm->validate_frames);
164 	secy_cp_control_replay(sm->kay, sm->replay_protect, sm->replay_window);
165 }
166 
167 
168 SM_STATE(CP, AUTHENTICATED)
169 {
170 	SM_ENTRY(CP, AUTHENTICATED);
171 
172 	sm->protect_frames = FALSE;
173 	sm->replay_protect = FALSE;
174 	sm->validate_frames = Checked;
175 
176 	sm->port_valid = FALSE;
177 	sm->controlled_port_enabled = TRUE;
178 
179 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
180 	secy_cp_control_protect_frames(sm->kay, sm->protect_frames);
181 	secy_cp_control_encrypt(sm->kay, sm->kay->macsec_encrypt);
182 	secy_cp_control_validate_frames(sm->kay, sm->validate_frames);
183 	secy_cp_control_replay(sm->kay, sm->replay_protect, sm->replay_window);
184 }
185 
186 
187 SM_STATE(CP, SECURED)
188 {
189 	SM_ENTRY(CP, SECURED);
190 
191 	sm->chgd_server = FALSE;
192 
193 	sm->protect_frames = sm->kay->macsec_protect;
194 	sm->replay_protect = sm->kay->macsec_replay_protect;
195 	sm->validate_frames = sm->kay->macsec_validate;
196 
197 	/* NOTE: now no other than default cipher suite (AES-GCM-128) */
198 	sm->current_cipher_suite = sm->cipher_suite;
199 	secy_cp_control_current_cipher_suite(sm->kay, sm->current_cipher_suite);
200 
201 	sm->confidentiality_offset = sm->cipher_offset;
202 
203 	sm->port_valid = TRUE;
204 
205 	secy_cp_control_confidentiality_offset(sm->kay,
206 					       sm->confidentiality_offset);
207 	secy_cp_control_protect_frames(sm->kay, sm->protect_frames);
208 	secy_cp_control_encrypt(sm->kay, sm->kay->macsec_encrypt);
209 	secy_cp_control_validate_frames(sm->kay, sm->validate_frames);
210 	secy_cp_control_replay(sm->kay, sm->replay_protect, sm->replay_window);
211 }
212 
213 
214 SM_STATE(CP, RECEIVE)
215 {
216 	SM_ENTRY(CP, RECEIVE);
217 	/* RECEIVE state machine not keep with Figure 12-2 in
218 	 * IEEE Std 802.1X-2010 */
219 	sm->oki = sm->lki;
220 	sm->oan = sm->lan;
221 	sm->otx = sm->ltx;
222 	sm->orx = sm->lrx;
223 	ieee802_1x_kay_set_old_sa_attr(sm->kay, sm->oki, sm->oan,
224 				       sm->otx, sm->orx);
225 
226 	sm->lki = os_malloc(sizeof(*sm->lki));
227 	if (!sm->lki) {
228 		wpa_printf(MSG_ERROR, "CP-%s: Out of memory", __func__);
229 		return;
230 	}
231 	os_memcpy(sm->lki, &sm->distributed_ki, sizeof(*sm->lki));
232 	sm->lan = sm->distributed_an;
233 	sm->ltx = FALSE;
234 	sm->lrx = FALSE;
235 	ieee802_1x_kay_set_latest_sa_attr(sm->kay, sm->lki, sm->lan,
236 					  sm->ltx, sm->lrx);
237 	ieee802_1x_kay_create_sas(sm->kay, sm->lki);
238 	ieee802_1x_kay_enable_rx_sas(sm->kay, sm->lki);
239 	sm->new_sak = FALSE;
240 	sm->all_receiving = FALSE;
241 }
242 
243 
244 SM_STATE(CP, RECEIVING)
245 {
246 	SM_ENTRY(CP, RECEIVING);
247 
248 	sm->lrx = TRUE;
249 	ieee802_1x_kay_set_latest_sa_attr(sm->kay, sm->lki, sm->lan,
250 					  sm->ltx, sm->lrx);
251 	sm->transmit_when = sm->transmit_delay;
252 	eloop_cancel_timeout(ieee802_1x_cp_transmit_when_timeout, sm, NULL);
253 	eloop_register_timeout(sm->transmit_when / 1000, 0,
254 			       ieee802_1x_cp_transmit_when_timeout, sm, NULL);
255 	/* the electedSelf have been set before CP entering to RECEIVING
256 	 * but the CP will transmit from RECEIVING to READY under
257 	 * the !electedSelf when KaY is not key server */
258 	ieee802_1x_cp_sm_step(sm);
259 	sm->using_receive_sas = FALSE;
260 	sm->server_transmitting = FALSE;
261 }
262 
263 
264 SM_STATE(CP, READY)
265 {
266 	SM_ENTRY(CP, READY);
267 
268 	ieee802_1x_kay_enable_new_info(sm->kay);
269 }
270 
271 
272 SM_STATE(CP, TRANSMIT)
273 {
274 	SM_ENTRY(CP, TRANSMIT);
275 
276 	sm->controlled_port_enabled = TRUE;
277 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
278 	sm->ltx = TRUE;
279 	ieee802_1x_kay_set_latest_sa_attr(sm->kay, sm->lki, sm->lan,
280 					  sm->ltx, sm->lrx);
281 	ieee802_1x_kay_enable_tx_sas(sm->kay,  sm->lki);
282 	sm->all_receiving = FALSE;
283 	sm->server_transmitting = FALSE;
284 }
285 
286 
287 SM_STATE(CP, TRANSMITTING)
288 {
289 	SM_ENTRY(CP, TRANSMITTING);
290 	sm->retire_when = sm->orx ? sm->retire_delay : 0;
291 	sm->otx = FALSE;
292 	ieee802_1x_kay_set_old_sa_attr(sm->kay, sm->oki, sm->oan,
293 				       sm->otx, sm->orx);
294 	ieee802_1x_kay_enable_new_info(sm->kay);
295 	eloop_cancel_timeout(ieee802_1x_cp_retire_when_timeout, sm, NULL);
296 	eloop_register_timeout(sm->retire_when / 1000, 0,
297 			       ieee802_1x_cp_retire_when_timeout, sm, NULL);
298 	sm->using_transmit_sa = FALSE;
299 }
300 
301 
302 SM_STATE(CP, ABANDON)
303 {
304 	SM_ENTRY(CP, ABANDON);
305 	sm->lrx = FALSE;
306 	ieee802_1x_kay_set_latest_sa_attr(sm->kay, sm->lki, sm->lan,
307 					  sm->ltx, sm->lrx);
308 	ieee802_1x_kay_delete_sas(sm->kay, sm->lki);
309 
310 	os_free(sm->lki);
311 	sm->lki = NULL;
312 	ieee802_1x_kay_set_latest_sa_attr(sm->kay, sm->lki, sm->lan,
313 					  sm->ltx, sm->lrx);
314 	sm->new_sak = FALSE;
315 }
316 
317 
318 SM_STATE(CP, RETIRE)
319 {
320 	SM_ENTRY(CP, RETIRE);
321 	/* RETIRE state machine not keep with Figure 12-2 in
322 	 * IEEE Std 802.1X-2010 */
323 	os_free(sm->oki);
324 	sm->oki = NULL;
325 	sm->orx = FALSE;
326 	sm->otx = FALSE;
327 	ieee802_1x_kay_set_old_sa_attr(sm->kay, sm->oki, sm->oan,
328 				       sm->otx, sm->orx);
329 }
330 
331 
332 /**
333  * CP state machine handler entry
334  */
335 SM_STEP(CP)
336 {
337 	if (!sm->port_enabled)
338 		SM_ENTER(CP, INIT);
339 
340 	switch (sm->CP_state) {
341 	case CP_BEGIN:
342 		SM_ENTER(CP, INIT);
343 		break;
344 
345 	case CP_INIT:
346 		SM_ENTER(CP, CHANGE);
347 		break;
348 
349 	case CP_CHANGE:
350 		if (sm->connect == UNAUTHENTICATED)
351 			SM_ENTER(CP, ALLOWED);
352 		else if (sm->connect == AUTHENTICATED)
353 			SM_ENTER(CP, AUTHENTICATED);
354 		else if (sm->connect == SECURE)
355 			SM_ENTER(CP, SECURED);
356 		break;
357 
358 	case CP_ALLOWED:
359 		if (sm->connect != UNAUTHENTICATED)
360 			SM_ENTER(CP, CHANGE);
361 		break;
362 
363 	case CP_AUTHENTICATED:
364 		if (sm->connect != AUTHENTICATED)
365 			SM_ENTER(CP, CHANGE);
366 		break;
367 
368 	case CP_SECURED:
369 		if (changed_connect(sm))
370 			SM_ENTER(CP, CHANGE);
371 		else if (sm->new_sak)
372 			SM_ENTER(CP, RECEIVE);
373 		break;
374 
375 	case CP_RECEIVE:
376 		if (sm->using_receive_sas)
377 			SM_ENTER(CP, RECEIVING);
378 		break;
379 
380 	case CP_RECEIVING:
381 		if (sm->new_sak || changed_connect(sm))
382 			SM_ENTER(CP, ABANDON);
383 		if (!sm->elected_self)
384 			SM_ENTER(CP, READY);
385 		if (sm->elected_self &&
386 		    (sm->all_receiving || !sm->transmit_when))
387 			SM_ENTER(CP, TRANSMIT);
388 		break;
389 
390 	case CP_TRANSMIT:
391 		if (sm->using_transmit_sa)
392 			SM_ENTER(CP, TRANSMITTING);
393 		break;
394 
395 	case CP_TRANSMITTING:
396 		if (!sm->retire_when || changed_connect(sm))
397 			SM_ENTER(CP, RETIRE);
398 		break;
399 
400 	case CP_RETIRE:
401 		if (changed_connect(sm))
402 			SM_ENTER(CP, CHANGE);
403 		else if (sm->new_sak)
404 			SM_ENTER(CP, RECEIVE);
405 		break;
406 
407 	case CP_READY:
408 		if (sm->new_sak || changed_connect(sm))
409 			SM_ENTER(CP, RECEIVE);
410 		if (sm->server_transmitting)
411 			SM_ENTER(CP, TRANSMIT);
412 		break;
413 	case CP_ABANDON:
414 		if (changed_connect(sm))
415 			SM_ENTER(CP, RETIRE);
416 		else if (sm->new_sak)
417 			SM_ENTER(CP, RECEIVE);
418 		break;
419 	default:
420 		wpa_printf(MSG_ERROR, "CP: the state machine is not defined");
421 		break;
422 	}
423 }
424 
425 
426 /**
427  * ieee802_1x_cp_sm_init -
428  */
429 struct ieee802_1x_cp_sm * ieee802_1x_cp_sm_init(struct ieee802_1x_kay *kay)
430 {
431 	struct ieee802_1x_cp_sm *sm;
432 
433 	sm = os_zalloc(sizeof(*sm));
434 	if (sm == NULL) {
435 		wpa_printf(MSG_ERROR, "CP-%s: out of memory", __func__);
436 		return NULL;
437 	}
438 
439 	sm->kay = kay;
440 
441 	sm->port_valid = FALSE;
442 
443 	sm->chgd_server = FALSE;
444 
445 	sm->protect_frames = kay->macsec_protect;
446 	sm->validate_frames = kay->macsec_validate;
447 	sm->replay_protect = kay->macsec_replay_protect;
448 	sm->replay_window = kay->macsec_replay_window;
449 
450 	sm->controlled_port_enabled = FALSE;
451 
452 	sm->lki = NULL;
453 	sm->lrx = FALSE;
454 	sm->ltx = FALSE;
455 	sm->oki = NULL;
456 	sm->orx = FALSE;
457 	sm->otx = FALSE;
458 
459 	sm->current_cipher_suite = default_cs_id;
460 	sm->cipher_suite = default_cs_id;
461 	sm->cipher_offset = CONFIDENTIALITY_OFFSET_0;
462 	sm->confidentiality_offset = sm->cipher_offset;
463 	sm->transmit_delay = MKA_LIFE_TIME;
464 	sm->retire_delay = MKA_SAK_RETIRE_TIME;
465 	sm->CP_state = CP_BEGIN;
466 	sm->changed = FALSE;
467 	sm->authorization_data = NULL;
468 
469 	wpa_printf(MSG_DEBUG, "CP: state machine created");
470 
471 	secy_cp_control_protect_frames(sm->kay, sm->protect_frames);
472 	secy_cp_control_encrypt(sm->kay, sm->kay->macsec_encrypt);
473 	secy_cp_control_validate_frames(sm->kay, sm->validate_frames);
474 	secy_cp_control_replay(sm->kay, sm->replay_protect, sm->replay_window);
475 	secy_cp_control_enable_port(sm->kay, sm->controlled_port_enabled);
476 	secy_cp_control_confidentiality_offset(sm->kay,
477 					       sm->confidentiality_offset);
478 
479 	SM_ENTER(CP, INIT);
480 	SM_STEP_RUN(CP);
481 
482 	return sm;
483 }
484 
485 
486 static void ieee802_1x_cp_step_run(struct ieee802_1x_cp_sm *sm)
487 {
488 	enum cp_states prev_state;
489 	int i;
490 
491 	for (i = 0; i < 100; i++) {
492 		prev_state = sm->CP_state;
493 		SM_STEP_RUN(CP);
494 		if (prev_state == sm->CP_state)
495 			break;
496 	}
497 }
498 
499 
500 static void ieee802_1x_cp_step_cb(void *eloop_ctx, void *timeout_ctx)
501 {
502 	struct ieee802_1x_cp_sm *sm = eloop_ctx;
503 	ieee802_1x_cp_step_run(sm);
504 }
505 
506 
507 /**
508  * ieee802_1x_cp_sm_deinit -
509  */
510 void ieee802_1x_cp_sm_deinit(struct ieee802_1x_cp_sm *sm)
511 {
512 	wpa_printf(MSG_DEBUG, "CP: state machine removed");
513 	if (!sm)
514 		return;
515 
516 	eloop_cancel_timeout(ieee802_1x_cp_retire_when_timeout, sm, NULL);
517 	eloop_cancel_timeout(ieee802_1x_cp_transmit_when_timeout, sm, NULL);
518 	eloop_cancel_timeout(ieee802_1x_cp_step_cb, sm, NULL);
519 	os_free(sm->lki);
520 	os_free(sm->oki);
521 	os_free(sm->authorization_data);
522 	os_free(sm);
523 }
524 
525 
526 /**
527  * ieee802_1x_cp_connect_pending
528  */
529 void ieee802_1x_cp_connect_pending(void *cp_ctx)
530 {
531 	struct ieee802_1x_cp_sm *sm = cp_ctx;
532 
533 	sm->connect = PENDING;
534 }
535 
536 
537 /**
538  * ieee802_1x_cp_connect_unauthenticated
539  */
540 void ieee802_1x_cp_connect_unauthenticated(void *cp_ctx)
541 {
542 	struct ieee802_1x_cp_sm *sm = (struct ieee802_1x_cp_sm *)cp_ctx;
543 
544 	sm->connect = UNAUTHENTICATED;
545 }
546 
547 
548 /**
549  * ieee802_1x_cp_connect_authenticated
550  */
551 void ieee802_1x_cp_connect_authenticated(void *cp_ctx)
552 {
553 	struct ieee802_1x_cp_sm *sm = cp_ctx;
554 
555 	sm->connect = AUTHENTICATED;
556 }
557 
558 
559 /**
560  * ieee802_1x_cp_connect_secure
561  */
562 void ieee802_1x_cp_connect_secure(void *cp_ctx)
563 {
564 	struct ieee802_1x_cp_sm *sm = cp_ctx;
565 
566 	sm->connect = SECURE;
567 }
568 
569 
570 /**
571  * ieee802_1x_cp_set_chgdserver -
572  */
573 void ieee802_1x_cp_signal_chgdserver(void *cp_ctx)
574 {
575 	struct ieee802_1x_cp_sm *sm = cp_ctx;
576 
577 	sm->chgd_server = TRUE;
578 }
579 
580 
581 /**
582  * ieee802_1x_cp_set_electedself -
583  */
584 void ieee802_1x_cp_set_electedself(void *cp_ctx, Boolean status)
585 {
586 	struct ieee802_1x_cp_sm *sm = cp_ctx;
587 	sm->elected_self = status;
588 }
589 
590 
591 /**
592  * ieee802_1x_cp_set_authorizationdata -
593  */
594 void ieee802_1x_cp_set_authorizationdata(void *cp_ctx, u8 *pdata, int len)
595 {
596 	struct ieee802_1x_cp_sm *sm = cp_ctx;
597 	os_free(sm->authorization_data);
598 	sm->authorization_data = os_zalloc(len);
599 	if (sm->authorization_data)
600 		os_memcpy(sm->authorization_data, pdata, len);
601 }
602 
603 
604 /**
605  * ieee802_1x_cp_set_ciphersuite -
606  */
607 void ieee802_1x_cp_set_ciphersuite(void *cp_ctx, u64 cs)
608 {
609 	struct ieee802_1x_cp_sm *sm = cp_ctx;
610 	sm->cipher_suite = cs;
611 }
612 
613 
614 /**
615  * ieee802_1x_cp_set_offset -
616  */
617 void ieee802_1x_cp_set_offset(void *cp_ctx, enum confidentiality_offset offset)
618 {
619 	struct ieee802_1x_cp_sm *sm = cp_ctx;
620 	sm->cipher_offset = offset;
621 }
622 
623 
624 /**
625  * ieee802_1x_cp_signal_newsak -
626  */
627 void ieee802_1x_cp_signal_newsak(void *cp_ctx)
628 {
629 	struct ieee802_1x_cp_sm *sm = cp_ctx;
630 	sm->new_sak = TRUE;
631 }
632 
633 
634 /**
635  * ieee802_1x_cp_set_distributedki -
636  */
637 void ieee802_1x_cp_set_distributedki(void *cp_ctx,
638 				     const struct ieee802_1x_mka_ki *dki)
639 {
640 	struct ieee802_1x_cp_sm *sm = cp_ctx;
641 	os_memcpy(&sm->distributed_ki, dki, sizeof(struct ieee802_1x_mka_ki));
642 }
643 
644 
645 /**
646  * ieee802_1x_cp_set_distributedan -
647  */
648 void ieee802_1x_cp_set_distributedan(void *cp_ctx, u8 an)
649 {
650 	struct ieee802_1x_cp_sm *sm = cp_ctx;
651 	sm->distributed_an = an;
652 }
653 
654 
655 /**
656  * ieee802_1x_cp_set_usingreceivesas -
657  */
658 void ieee802_1x_cp_set_usingreceivesas(void *cp_ctx, Boolean status)
659 {
660 	struct ieee802_1x_cp_sm *sm = cp_ctx;
661 	sm->using_receive_sas = status;
662 }
663 
664 
665 /**
666  * ieee802_1x_cp_set_allreceiving -
667  */
668 void ieee802_1x_cp_set_allreceiving(void *cp_ctx, Boolean status)
669 {
670 	struct ieee802_1x_cp_sm *sm = cp_ctx;
671 	sm->all_receiving = status;
672 }
673 
674 
675 /**
676  * ieee802_1x_cp_set_servertransmitting -
677  */
678 void ieee802_1x_cp_set_servertransmitting(void *cp_ctx, Boolean status)
679 {
680 	struct ieee802_1x_cp_sm *sm = cp_ctx;
681 	sm->server_transmitting = status;
682 }
683 
684 
685 /**
686  * ieee802_1x_cp_set_usingtransmitsas -
687  */
688 void ieee802_1x_cp_set_usingtransmitas(void *cp_ctx, Boolean status)
689 {
690 	struct ieee802_1x_cp_sm *sm = cp_ctx;
691 	sm->using_transmit_sa = status;
692 }
693 
694 
695 /**
696  * ieee802_1x_cp_sm_step - Advance EAPOL state machines
697  * @sm: EAPOL state machine
698  *
699  * This function is called to advance CP state machines after any change
700  * that could affect their state.
701  */
702 void ieee802_1x_cp_sm_step(void *cp_ctx)
703 {
704 	/*
705 	 * Run ieee802_1x_cp_step_run from a registered timeout
706 	 * to make sure that other possible timeouts/events are processed
707 	 * and to avoid long function call chains.
708 	 */
709 	struct ieee802_1x_cp_sm *sm = cp_ctx;
710 	eloop_cancel_timeout(ieee802_1x_cp_step_cb, sm, NULL);
711 	eloop_register_timeout(0, 0, ieee802_1x_cp_step_cb, sm, NULL);
712 }
713 
714 
715 static void ieee802_1x_cp_retire_when_timeout(void *eloop_ctx,
716 					      void *timeout_ctx)
717 {
718 	struct ieee802_1x_cp_sm *sm = eloop_ctx;
719 	sm->retire_when = 0;
720 	ieee802_1x_cp_step_run(sm);
721 }
722 
723 
724 static void
725 ieee802_1x_cp_transmit_when_timeout(void *eloop_ctx, void *timeout_ctx)
726 {
727 	struct ieee802_1x_cp_sm *sm = eloop_ctx;
728 	sm->transmit_when = 0;
729 	ieee802_1x_cp_step_run(sm);
730 }
731