← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/wpasupplicant/gutsy

« back to all changes in this revision

Viewing changes to src/eap_peer/eap_vendor_test.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler, Alexander Sack
  • Date: 2007-08-26 16:06:57 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20070826160657-2m8pxoweuxe8f93t
Tags: 0.6.0+0.5.8-0ubuntu1
https://launchpad.net/bugs/140763
https://launchpad.net/bugs/141233
* New upstream release
* remove patch 11_erroneous_manpage_ref, applied upstream
* remove patch 25_wpas_dbus_unregister_iface_fix, applied upstream

[ Alexander Sack ]
* bumping upstream version to replace development version 0.6.0 with
  this package from stable release branch.
* attempt to fix wierd timeout and high latency issues by going
  back to stable upstream version (0.5.9) (LP: #140763,
  LP: #141233).

Show diffs side-by-side

added added

removed removed

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