wpa_supplicant: Update to work without verision tag
[dragonfly.git] / contrib / hostapd-0.5.8 / eap_tlv.c
1 /*
2  * hostapd / EAP-TLV (draft-josefsson-pppext-eap-tls-eap-07.txt)
3  * Copyright (c) 2004-2007, Jouni Malinen <j@w1.fi>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * Alternatively, this software may be distributed under the terms of BSD
10  * license.
11  *
12  * See README and COPYING for more details.
13  */
14
15 #include "includes.h"
16
17 #include "hostapd.h"
18 #include "common.h"
19 #include "eap_i.h"
20
21
22 /* EAP-TLV TLVs (draft-josefsson-ppext-eap-tls-eap-07.txt) */
23 #define EAP_TLV_RESULT_TLV 3 /* Acknowledged Result */
24 #define EAP_TLV_NAK_TLV 4
25 #define EAP_TLV_CRYPTO_BINDING_TLV 5
26 #define EAP_TLV_CONNECTION_BINDING_TLV 6
27 #define EAP_TLV_VENDOR_SPECIFIC_TLV 7
28 #define EAP_TLV_URI_TLV 8
29 #define EAP_TLV_EAP_PAYLOAD_TLV 9
30 #define EAP_TLV_INTERMEDIATE_RESULT_TLV 10
31
32 #define EAP_TLV_RESULT_SUCCESS 1
33 #define EAP_TLV_RESULT_FAILURE 2
34
35
36 struct eap_tlv_data {
37         enum { CONTINUE, SUCCESS, FAILURE } state;
38 };
39
40
41 static void * eap_tlv_init(struct eap_sm *sm)
42 {
43         struct eap_tlv_data *data;
44
45         data = wpa_zalloc(sizeof(*data));
46         if (data == NULL)
47                 return NULL;
48         data->state = CONTINUE;
49
50         return data;
51 }
52
53
54 static void eap_tlv_reset(struct eap_sm *sm, void *priv)
55 {
56         struct eap_tlv_data *data = priv;
57         free(data);
58 }
59
60
61 static u8 * eap_tlv_buildReq(struct eap_sm *sm, void *priv, int id,
62                              size_t *reqDataLen)
63 {
64         struct eap_hdr *req;
65         u8 *pos;
66         u16 status;
67
68         if (sm->tlv_request == TLV_REQ_SUCCESS) {
69                 status = EAP_TLV_RESULT_SUCCESS;
70         } else {
71                 status = EAP_TLV_RESULT_FAILURE;
72         }
73
74         *reqDataLen = sizeof(struct eap_hdr) + 1 + 6;
75         req = malloc(*reqDataLen);
76         if (req == NULL)
77                 return NULL;
78
79         req->code = EAP_CODE_REQUEST;
80         req->identifier = id;
81         req->length = host_to_be16(*reqDataLen);
82         pos = (u8 *) (req + 1);
83         *pos++ = EAP_TYPE_TLV;
84         *pos++ = 0x80; /* Mandatory */
85         *pos++ = EAP_TLV_RESULT_TLV;
86         /* Length */
87         *pos++ = 0;
88         *pos++ = 2;
89         /* Status */
90         *pos++ = status >> 8;
91         *pos++ = status & 0xff;
92
93         return (u8 *) req;
94 }
95
96
97 static Boolean eap_tlv_check(struct eap_sm *sm, void *priv,
98                              u8 *respData, size_t respDataLen)
99 {
100         struct eap_hdr *resp;
101         u8 *pos;
102
103         resp = (struct eap_hdr *) respData;
104         pos = (u8 *) (resp + 1);
105         if (respDataLen < sizeof(*resp) + 1 || *pos != EAP_TYPE_TLV ||
106             (ntohs(resp->length)) > respDataLen) {
107                 wpa_printf(MSG_INFO, "EAP-TLV: Invalid frame");
108                 return TRUE;
109         }
110
111         return FALSE;
112 }
113
114
115 static void eap_tlv_process(struct eap_sm *sm, void *priv,
116                             u8 *respData, size_t respDataLen)
117 {
118         struct eap_tlv_data *data = priv;
119         struct eap_hdr *resp;
120         u8 *pos;
121         size_t left;
122         u8 *result_tlv = NULL;
123         size_t result_tlv_len = 0;
124         int tlv_type, mandatory, tlv_len;
125
126         resp = (struct eap_hdr *) respData;
127         pos = (u8 *) (resp + 1);
128
129         /* Parse TLVs */
130         left = be_to_host16(resp->length) - sizeof(struct eap_hdr) - 1;
131         pos = (u8 *) (resp + 1);
132         pos++;
133         wpa_hexdump(MSG_DEBUG, "EAP-TLV: Received TLVs", pos, left);
134         while (left >= 4) {
135                 mandatory = !!(pos[0] & 0x80);
136                 tlv_type = pos[0] & 0x3f;
137                 tlv_type = (tlv_type << 8) | pos[1];
138                 tlv_len = ((int) pos[2] << 8) | pos[3];
139                 pos += 4;
140                 left -= 4;
141                 if ((size_t) tlv_len > left) {
142                         wpa_printf(MSG_DEBUG, "EAP-TLV: TLV underrun "
143                                    "(tlv_len=%d left=%lu)", tlv_len,
144                                    (unsigned long) left);
145                         data->state = FAILURE;
146                         return;
147                 }
148                 switch (tlv_type) {
149                 case EAP_TLV_RESULT_TLV:
150                         result_tlv = pos;
151                         result_tlv_len = tlv_len;
152                         break;
153                 default:
154                         wpa_printf(MSG_DEBUG, "EAP-TLV: Unsupported TLV Type "
155                                    "%d%s", tlv_type,
156                                    mandatory ? " (mandatory)" : "");
157                         if (mandatory) {
158                                 data->state = FAILURE;
159                                 return;
160                         }
161                         /* Ignore this TLV, but process other TLVs */
162                         break;
163                 }
164
165                 pos += tlv_len;
166                 left -= tlv_len;
167         }
168         if (left) {
169                 wpa_printf(MSG_DEBUG, "EAP-TLV: Last TLV too short in "
170                            "Request (left=%lu)", (unsigned long) left);
171                 data->state = FAILURE;
172                 return;
173         }
174
175         /* Process supported TLVs */
176         if (result_tlv) {
177                 int status;
178                 const char *requested;
179
180                 wpa_hexdump(MSG_DEBUG, "EAP-TLV: Result TLV",
181                             result_tlv, result_tlv_len);
182                 if (result_tlv_len < 2) {
183                         wpa_printf(MSG_INFO, "EAP-TLV: Too short Result TLV "
184                                    "(len=%lu)",
185                                    (unsigned long) result_tlv_len);
186                         data->state = FAILURE;
187                         return;
188                 }
189                 requested = sm->tlv_request == TLV_REQ_SUCCESS ? "Success" :
190                         "Failure";
191                 status = ((int) result_tlv[0] << 8) | result_tlv[1];
192                 if (status == EAP_TLV_RESULT_SUCCESS) {
193                         wpa_printf(MSG_INFO, "EAP-TLV: TLV Result - Success "
194                                    "- requested %s", requested);
195                         if (sm->tlv_request == TLV_REQ_SUCCESS)
196                                 data->state = SUCCESS;
197                         else
198                                 data->state = FAILURE;
199                         
200                 } else if (status == EAP_TLV_RESULT_FAILURE) {
201                         wpa_printf(MSG_INFO, "EAP-TLV: TLV Result - Failure - "
202                                    "requested %s", requested);
203                         if (sm->tlv_request == TLV_REQ_FAILURE)
204                                 data->state = SUCCESS;
205                         else
206                                 data->state = FAILURE;
207                 } else {
208                         wpa_printf(MSG_INFO, "EAP-TLV: Unknown TLV Result "
209                                    "Status %d", status);
210                         data->state = FAILURE;
211                 }
212         }
213 }
214
215
216 static Boolean eap_tlv_isDone(struct eap_sm *sm, void *priv)
217 {
218         struct eap_tlv_data *data = priv;
219         return data->state != CONTINUE;
220 }
221
222
223 static Boolean eap_tlv_isSuccess(struct eap_sm *sm, void *priv)
224 {
225         struct eap_tlv_data *data = priv;
226         return data->state == SUCCESS;
227 }
228
229
230 int eap_server_tlv_register(void)
231 {
232         struct eap_method *eap;
233         int ret;
234
235         eap = eap_server_method_alloc(EAP_SERVER_METHOD_INTERFACE_VERSION,
236                                       EAP_VENDOR_IETF, EAP_TYPE_TLV, "TLV");
237         if (eap == NULL)
238                 return -1;
239
240         eap->init = eap_tlv_init;
241         eap->reset = eap_tlv_reset;
242         eap->buildReq = eap_tlv_buildReq;
243         eap->check = eap_tlv_check;
244         eap->process = eap_tlv_process;
245         eap->isDone = eap_tlv_isDone;
246         eap->isSuccess = eap_tlv_isSuccess;
247
248         ret = eap_server_method_register(eap);
249         if (ret)
250                 eap_server_method_free(eap);
251         return ret;
252 }