Disconnect hostapd from building in base
[dragonfly.git] / contrib / hostapd / src / eap_peer / eap_vendor_test.c
1 /*
2  * EAP peer method: Test method for vendor specific (expanded) EAP type
3  * Copyright (c) 2005-2006, Jouni Malinen <j@w1.fi>
4  *
5  * This software may be distributed under the terms of the BSD license.
6  * See README for more details.
7  *
8  * This file implements a vendor specific test method using EAP expanded types.
9  * This is only for test use and must not be used for authentication since no
10  * security is provided.
11  */
12
13 #include "includes.h"
14
15 #include "common.h"
16 #include "eap_i.h"
17 #ifdef TEST_PENDING_REQUEST
18 #include "eloop.h"
19 #endif /* TEST_PENDING_REQUEST */
20
21
22 #define EAP_VENDOR_ID EAP_VENDOR_HOSTAP
23 #define EAP_VENDOR_TYPE 0xfcfbfaf9
24
25
26 /* #define TEST_PENDING_REQUEST */
27
28 struct eap_vendor_test_data {
29         enum { INIT, CONFIRM, SUCCESS } state;
30         int first_try;
31 };
32
33
34 static void * eap_vendor_test_init(struct eap_sm *sm)
35 {
36         struct eap_vendor_test_data *data;
37         data = os_zalloc(sizeof(*data));
38         if (data == NULL)
39                 return NULL;
40         data->state = INIT;
41         data->first_try = 1;
42         return data;
43 }
44
45
46 static void eap_vendor_test_deinit(struct eap_sm *sm, void *priv)
47 {
48         struct eap_vendor_test_data *data = priv;
49         os_free(data);
50 }
51
52
53 #ifdef TEST_PENDING_REQUEST
54 static void eap_vendor_ready(void *eloop_ctx, void *timeout_ctx)
55 {
56         struct eap_sm *sm = eloop_ctx;
57         wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Ready to re-process pending "
58                    "request");
59         eap_notify_pending(sm);
60 }
61 #endif /* TEST_PENDING_REQUEST */
62
63
64 static struct wpabuf * eap_vendor_test_process(struct eap_sm *sm, void *priv,
65                                                struct eap_method_ret *ret,
66                                                const struct wpabuf *reqData)
67 {
68         struct eap_vendor_test_data *data = priv;
69         struct wpabuf *resp;
70         const u8 *pos;
71         size_t len;
72
73         pos = eap_hdr_validate(EAP_VENDOR_ID, EAP_VENDOR_TYPE, reqData, &len);
74         if (pos == NULL || len < 1) {
75                 ret->ignore = TRUE;
76                 return NULL;
77         }
78
79         if (data->state == INIT && *pos != 1) {
80                 wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Unexpected message "
81                            "%d in INIT state", *pos);
82                 ret->ignore = TRUE;
83                 return NULL;
84         }
85
86         if (data->state == CONFIRM && *pos != 3) {
87                 wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Unexpected message "
88                            "%d in CONFIRM state", *pos);
89                 ret->ignore = TRUE;
90                 return NULL;
91         }
92
93         if (data->state == SUCCESS) {
94                 wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Unexpected message "
95                            "in SUCCESS state");
96                 ret->ignore = TRUE;
97                 return NULL;
98         }
99
100         if (data->state == CONFIRM) {
101 #ifdef TEST_PENDING_REQUEST
102                 if (data->first_try) {
103                         data->first_try = 0;
104                         wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Testing "
105                                    "pending request");
106                         ret->ignore = TRUE;
107                         eloop_register_timeout(1, 0, eap_vendor_ready, sm,
108                                                NULL);
109                         return NULL;
110                 }
111 #endif /* TEST_PENDING_REQUEST */
112         }
113
114         ret->ignore = FALSE;
115
116         wpa_printf(MSG_DEBUG, "EAP-VENDOR-TEST: Generating Response");
117         ret->allowNotifications = TRUE;
118
119         resp = eap_msg_alloc(EAP_VENDOR_ID, EAP_VENDOR_TYPE, 1,
120                              EAP_CODE_RESPONSE, eap_get_id(reqData));
121         if (resp == NULL)
122                 return NULL;
123
124         if (data->state == INIT) {
125                 wpabuf_put_u8(resp, 2);
126                 data->state = CONFIRM;
127                 ret->methodState = METHOD_CONT;
128                 ret->decision = DECISION_FAIL;
129         } else {
130                 wpabuf_put_u8(resp, 4);
131                 data->state = SUCCESS;
132                 ret->methodState = METHOD_DONE;
133                 ret->decision = DECISION_UNCOND_SUCC;
134         }
135
136         return resp;
137 }
138
139
140 static Boolean eap_vendor_test_isKeyAvailable(struct eap_sm *sm, void *priv)
141 {
142         struct eap_vendor_test_data *data = priv;
143         return data->state == SUCCESS;
144 }
145
146
147 static u8 * eap_vendor_test_getKey(struct eap_sm *sm, void *priv, size_t *len)
148 {
149         struct eap_vendor_test_data *data = priv;
150         u8 *key;
151         const int key_len = 64;
152
153         if (data->state != SUCCESS)
154                 return NULL;
155
156         key = os_malloc(key_len);
157         if (key == NULL)
158                 return NULL;
159
160         os_memset(key, 0x11, key_len / 2);
161         os_memset(key + key_len / 2, 0x22, key_len / 2);
162         *len = key_len;
163
164         return key;
165 }
166
167
168 int eap_peer_vendor_test_register(void)
169 {
170         struct eap_method *eap;
171         int ret;
172
173         eap = eap_peer_method_alloc(EAP_PEER_METHOD_INTERFACE_VERSION,
174                                     EAP_VENDOR_ID, EAP_VENDOR_TYPE,
175                                     "VENDOR-TEST");
176         if (eap == NULL)
177                 return -1;
178
179         eap->init = eap_vendor_test_init;
180         eap->deinit = eap_vendor_test_deinit;
181         eap->process = eap_vendor_test_process;
182         eap->isKeyAvailable = eap_vendor_test_isKeyAvailable;
183         eap->getKey = eap_vendor_test_getKey;
184
185         ret = eap_peer_method_register(eap);
186         if (ret)
187                 eap_peer_method_free(eap);
188         return ret;
189 }