Branch data Line data Source code
1 : : /*
2 : : * Generic advertisement service (GAS) query
3 : : * Copyright (c) 2009, Atheros Communications
4 : : * Copyright (c) 2011-2013, Qualcomm Atheros, Inc.
5 : : *
6 : : * This software may be distributed under the terms of the BSD license.
7 : : * See README for more details.
8 : : */
9 : :
10 : : #include "includes.h"
11 : :
12 : : #include "common.h"
13 : : #include "utils/eloop.h"
14 : : #include "common/ieee802_11_defs.h"
15 : : #include "common/gas.h"
16 : : #include "common/wpa_ctrl.h"
17 : : #include "wpa_supplicant_i.h"
18 : : #include "driver_i.h"
19 : : #include "offchannel.h"
20 : : #include "gas_query.h"
21 : :
22 : :
23 : : /** GAS query timeout in seconds */
24 : : #define GAS_QUERY_TIMEOUT_PERIOD 2
25 : :
26 : :
27 : : /**
28 : : * struct gas_query_pending - Pending GAS query
29 : : */
30 : : struct gas_query_pending {
31 : : struct dl_list list;
32 : : struct gas_query *gas;
33 : : u8 addr[ETH_ALEN];
34 : : u8 dialog_token;
35 : : u8 next_frag_id;
36 : : unsigned int wait_comeback:1;
37 : : unsigned int offchannel_tx_started:1;
38 : : int freq;
39 : : u16 status_code;
40 : : struct wpabuf *req;
41 : : struct wpabuf *adv_proto;
42 : : struct wpabuf *resp;
43 : : void (*cb)(void *ctx, const u8 *dst, u8 dialog_token,
44 : : enum gas_query_result result,
45 : : const struct wpabuf *adv_proto,
46 : : const struct wpabuf *resp, u16 status_code);
47 : : void *ctx;
48 : : };
49 : :
50 : : /**
51 : : * struct gas_query - Internal GAS query data
52 : : */
53 : : struct gas_query {
54 : : struct wpa_supplicant *wpa_s;
55 : : struct dl_list pending; /* struct gas_query_pending */
56 : : struct gas_query_pending *current;
57 : : struct wpa_radio_work *work;
58 : : };
59 : :
60 : :
61 : : static void gas_query_tx_comeback_timeout(void *eloop_data, void *user_ctx);
62 : : static void gas_query_timeout(void *eloop_data, void *user_ctx);
63 : :
64 : :
65 : : /**
66 : : * gas_query_init - Initialize GAS query component
67 : : * @wpa_s: Pointer to wpa_supplicant data
68 : : * Returns: Pointer to GAS query data or %NULL on failure
69 : : */
70 : 33 : struct gas_query * gas_query_init(struct wpa_supplicant *wpa_s)
71 : : {
72 : : struct gas_query *gas;
73 : :
74 : 33 : gas = os_zalloc(sizeof(*gas));
75 [ - + ]: 33 : if (gas == NULL)
76 : 0 : return NULL;
77 : :
78 : 33 : gas->wpa_s = wpa_s;
79 : 33 : dl_list_init(&gas->pending);
80 : :
81 : 33 : return gas;
82 : : }
83 : :
84 : :
85 : 54 : static const char * gas_result_txt(enum gas_query_result result)
86 : : {
87 [ + + + - : 54 : switch (result) {
- - - - ]
88 : : case GAS_QUERY_SUCCESS:
89 : 51 : return "SUCCESS";
90 : : case GAS_QUERY_FAILURE:
91 : 1 : return "FAILURE";
92 : : case GAS_QUERY_TIMEOUT:
93 : 2 : return "TIMEOUT";
94 : : case GAS_QUERY_PEER_ERROR:
95 : 0 : return "PEER_ERROR";
96 : : case GAS_QUERY_INTERNAL_ERROR:
97 : 0 : return "INTERNAL_ERROR";
98 : : case GAS_QUERY_CANCELLED:
99 : 0 : return "CANCELLED";
100 : : case GAS_QUERY_DELETED_AT_DEINIT:
101 : 0 : return "DELETED_AT_DEINIT";
102 : : }
103 : :
104 : 54 : return "N/A";
105 : : }
106 : :
107 : :
108 : 54 : static void gas_query_free(struct gas_query_pending *query, int del_list)
109 : : {
110 : 54 : struct gas_query *gas = query->gas;
111 : :
112 [ - + ]: 54 : if (del_list)
113 : 0 : dl_list_del(&query->list);
114 : :
115 [ + - ][ + - ]: 54 : if (gas->work && gas->work->ctx == query) {
116 : 54 : radio_work_done(gas->work);
117 : 54 : gas->work = NULL;
118 : : }
119 : :
120 : 54 : wpabuf_free(query->req);
121 : 54 : wpabuf_free(query->adv_proto);
122 : 54 : wpabuf_free(query->resp);
123 : 54 : os_free(query);
124 : 54 : }
125 : :
126 : :
127 : 54 : static void gas_query_done(struct gas_query *gas,
128 : : struct gas_query_pending *query,
129 : : enum gas_query_result result)
130 : : {
131 : 54 : wpa_msg(gas->wpa_s, MSG_INFO, GAS_QUERY_DONE "addr=" MACSTR
132 : : " dialog_token=%u freq=%d status_code=%u result=%s",
133 : 378 : MAC2STR(query->addr), query->dialog_token, query->freq,
134 : 54 : query->status_code, gas_result_txt(result));
135 [ + - ]: 54 : if (gas->current == query)
136 : 54 : gas->current = NULL;
137 [ + - ]: 54 : if (query->offchannel_tx_started)
138 : 54 : offchannel_send_action_done(gas->wpa_s);
139 : 54 : eloop_cancel_timeout(gas_query_tx_comeback_timeout, gas, query);
140 : 54 : eloop_cancel_timeout(gas_query_timeout, gas, query);
141 : 54 : dl_list_del(&query->list);
142 : 54 : query->cb(query->ctx, query->addr, query->dialog_token, result,
143 : 108 : query->adv_proto, query->resp, query->status_code);
144 : 54 : gas_query_free(query, 0);
145 : 54 : }
146 : :
147 : :
148 : : /**
149 : : * gas_query_deinit - Deinitialize GAS query component
150 : : * @gas: GAS query data from gas_query_init()
151 : : */
152 : 33 : void gas_query_deinit(struct gas_query *gas)
153 : : {
154 : : struct gas_query_pending *query, *next;
155 : :
156 [ - + ]: 33 : if (gas == NULL)
157 : 33 : return;
158 : :
159 [ - + ]: 33 : dl_list_for_each_safe(query, next, &gas->pending,
160 : : struct gas_query_pending, list)
161 : 0 : gas_query_done(gas, query, GAS_QUERY_DELETED_AT_DEINIT);
162 : :
163 : 33 : os_free(gas);
164 : : }
165 : :
166 : :
167 : : static struct gas_query_pending *
168 : 105 : gas_query_get_pending(struct gas_query *gas, const u8 *addr, u8 dialog_token)
169 : : {
170 : : struct gas_query_pending *q;
171 [ + + ]: 108 : dl_list_for_each(q, &gas->pending, struct gas_query_pending, list) {
172 [ + - ][ + + ]: 86 : if (os_memcmp(q->addr, addr, ETH_ALEN) == 0 &&
173 : 86 : q->dialog_token == dialog_token)
174 : 83 : return q;
175 : : }
176 : 105 : return NULL;
177 : : }
178 : :
179 : :
180 : 65 : static int gas_query_append(struct gas_query_pending *query, const u8 *data,
181 : : size_t len)
182 : : {
183 [ - + ]: 65 : if (wpabuf_resize(&query->resp, len) < 0) {
184 : 0 : wpa_printf(MSG_DEBUG, "GAS: No memory to store the response");
185 : 0 : return -1;
186 : : }
187 : 65 : wpabuf_put_data(query->resp, data, len);
188 : 65 : return 0;
189 : : }
190 : :
191 : :
192 : 72 : static void gas_query_tx_status(struct wpa_supplicant *wpa_s,
193 : : unsigned int freq, const u8 *dst,
194 : : const u8 *src, const u8 *bssid,
195 : : const u8 *data, size_t data_len,
196 : : enum offchannel_send_action_result result)
197 : : {
198 : : struct gas_query_pending *query;
199 : 72 : struct gas_query *gas = wpa_s->gas;
200 : :
201 [ - + ]: 72 : if (gas->current == NULL) {
202 : 0 : wpa_printf(MSG_DEBUG, "GAS: Unexpected TX status: freq=%u dst="
203 : : MACSTR " result=%d - no query in progress",
204 : 0 : freq, MAC2STR(dst), result);
205 : 0 : return;
206 : : }
207 : :
208 : 72 : query = gas->current;
209 : :
210 : 72 : wpa_printf(MSG_DEBUG, "GAS: TX status: freq=%u dst=" MACSTR
211 : : " result=%d query=%p dialog_token=%u",
212 : 504 : freq, MAC2STR(dst), result, query, query->dialog_token);
213 [ - + ]: 72 : if (os_memcmp(dst, query->addr, ETH_ALEN) != 0) {
214 : 0 : wpa_printf(MSG_DEBUG, "GAS: TX status for unexpected destination");
215 : 0 : return;
216 : : }
217 : :
218 [ + - ]: 72 : if (result == OFFCHANNEL_SEND_ACTION_SUCCESS) {
219 : 72 : eloop_cancel_timeout(gas_query_timeout, gas, query);
220 : 72 : eloop_register_timeout(GAS_QUERY_TIMEOUT_PERIOD, 0,
221 : : gas_query_timeout, gas, query);
222 : : }
223 [ - + ]: 72 : if (result == OFFCHANNEL_SEND_ACTION_FAILED) {
224 : 0 : eloop_cancel_timeout(gas_query_timeout, gas, query);
225 : 72 : eloop_register_timeout(0, 0, gas_query_timeout, gas, query);
226 : : }
227 : : }
228 : :
229 : :
230 : 72 : static int gas_query_tx(struct gas_query *gas, struct gas_query_pending *query,
231 : : struct wpabuf *req)
232 : : {
233 : : int res;
234 : 72 : wpa_printf(MSG_DEBUG, "GAS: Send action frame to " MACSTR " len=%u "
235 : 432 : "freq=%d", MAC2STR(query->addr),
236 : 72 : (unsigned int) wpabuf_len(req), query->freq);
237 : 144 : res = offchannel_send_action(gas->wpa_s, query->freq, query->addr,
238 : 72 : gas->wpa_s->own_addr, query->addr,
239 : 72 : wpabuf_head(req), wpabuf_len(req), 1000,
240 : : gas_query_tx_status, 0);
241 [ + - ]: 72 : if (res == 0)
242 : 72 : query->offchannel_tx_started = 1;
243 : 72 : return res;
244 : : }
245 : :
246 : :
247 : 18 : static void gas_query_tx_comeback_req(struct gas_query *gas,
248 : : struct gas_query_pending *query)
249 : : {
250 : : struct wpabuf *req;
251 : :
252 : 18 : req = gas_build_comeback_req(query->dialog_token);
253 [ - + ]: 18 : if (req == NULL) {
254 : 0 : gas_query_done(gas, query, GAS_QUERY_INTERNAL_ERROR);
255 : 18 : return;
256 : : }
257 : :
258 [ - + ]: 18 : if (gas_query_tx(gas, query, req) < 0) {
259 : 0 : wpa_printf(MSG_DEBUG, "GAS: Failed to send Action frame to "
260 : 0 : MACSTR, MAC2STR(query->addr));
261 : 0 : gas_query_done(gas, query, GAS_QUERY_INTERNAL_ERROR);
262 : : }
263 : :
264 : 18 : wpabuf_free(req);
265 : : }
266 : :
267 : :
268 : 4 : static void gas_query_tx_comeback_timeout(void *eloop_data, void *user_ctx)
269 : : {
270 : 4 : struct gas_query *gas = eloop_data;
271 : 4 : struct gas_query_pending *query = user_ctx;
272 : :
273 : 4 : wpa_printf(MSG_DEBUG, "GAS: Comeback timeout for request to " MACSTR,
274 : 24 : MAC2STR(query->addr));
275 : 4 : gas_query_tx_comeback_req(gas, query);
276 : 4 : }
277 : :
278 : :
279 : 4 : static void gas_query_tx_comeback_req_delay(struct gas_query *gas,
280 : : struct gas_query_pending *query,
281 : : u16 comeback_delay)
282 : : {
283 : : unsigned int secs, usecs;
284 : :
285 : 4 : secs = (comeback_delay * 1024) / 1000000;
286 : 4 : usecs = comeback_delay * 1024 - secs * 1000000;
287 : 4 : wpa_printf(MSG_DEBUG, "GAS: Send comeback request to " MACSTR
288 : 24 : " in %u secs %u usecs", MAC2STR(query->addr), secs, usecs);
289 : 4 : eloop_cancel_timeout(gas_query_tx_comeback_timeout, gas, query);
290 : 4 : eloop_register_timeout(secs, usecs, gas_query_tx_comeback_timeout,
291 : : gas, query);
292 : 4 : }
293 : :
294 : :
295 : 51 : static void gas_query_rx_initial(struct gas_query *gas,
296 : : struct gas_query_pending *query,
297 : : const u8 *adv_proto, const u8 *resp,
298 : : size_t len, u16 comeback_delay)
299 : : {
300 : 51 : wpa_printf(MSG_DEBUG, "GAS: Received initial response from "
301 : : MACSTR " (dialog_token=%u comeback_delay=%u)",
302 : 357 : MAC2STR(query->addr), query->dialog_token, comeback_delay);
303 : :
304 : 51 : query->adv_proto = wpabuf_alloc_copy(adv_proto, 2 + adv_proto[1]);
305 [ - + ]: 51 : if (query->adv_proto == NULL) {
306 : 0 : gas_query_done(gas, query, GAS_QUERY_INTERNAL_ERROR);
307 : 0 : return;
308 : : }
309 : :
310 [ + + ]: 51 : if (comeback_delay) {
311 : 4 : query->wait_comeback = 1;
312 : 4 : gas_query_tx_comeback_req_delay(gas, query, comeback_delay);
313 : 4 : return;
314 : : }
315 : :
316 : : /* Query was completed without comeback mechanism */
317 [ - + ]: 47 : if (gas_query_append(query, resp, len) < 0) {
318 : 0 : gas_query_done(gas, query, GAS_QUERY_INTERNAL_ERROR);
319 : 0 : return;
320 : : }
321 : :
322 : 51 : gas_query_done(gas, query, GAS_QUERY_SUCCESS);
323 : : }
324 : :
325 : :
326 : 18 : static void gas_query_rx_comeback(struct gas_query *gas,
327 : : struct gas_query_pending *query,
328 : : const u8 *adv_proto, const u8 *resp,
329 : : size_t len, u8 frag_id, u8 more_frags,
330 : : u16 comeback_delay)
331 : : {
332 : 18 : wpa_printf(MSG_DEBUG, "GAS: Received comeback response from "
333 : : MACSTR " (dialog_token=%u frag_id=%u more_frags=%u "
334 : : "comeback_delay=%u)",
335 : 126 : MAC2STR(query->addr), query->dialog_token, frag_id,
336 : : more_frags, comeback_delay);
337 : :
338 [ + - - + ]: 36 : if ((size_t) 2 + adv_proto[1] != wpabuf_len(query->adv_proto) ||
339 : 18 : os_memcmp(adv_proto, wpabuf_head(query->adv_proto),
340 : : wpabuf_len(query->adv_proto)) != 0) {
341 : 0 : wpa_printf(MSG_DEBUG, "GAS: Advertisement Protocol changed "
342 : : "between initial and comeback response from "
343 : 0 : MACSTR, MAC2STR(query->addr));
344 : 0 : gas_query_done(gas, query, GAS_QUERY_PEER_ERROR);
345 : 0 : return;
346 : : }
347 : :
348 [ - + ]: 18 : if (comeback_delay) {
349 [ # # ]: 0 : if (frag_id) {
350 : 0 : wpa_printf(MSG_DEBUG, "GAS: Invalid comeback response "
351 : : "with non-zero frag_id and comeback_delay "
352 : 0 : "from " MACSTR, MAC2STR(query->addr));
353 : 0 : gas_query_done(gas, query, GAS_QUERY_PEER_ERROR);
354 : 0 : return;
355 : : }
356 : 0 : gas_query_tx_comeback_req_delay(gas, query, comeback_delay);
357 : 0 : return;
358 : : }
359 : :
360 [ - + ]: 18 : if (frag_id != query->next_frag_id) {
361 : 0 : wpa_printf(MSG_DEBUG, "GAS: Unexpected frag_id in response "
362 : 0 : "from " MACSTR, MAC2STR(query->addr));
363 [ # # ]: 0 : if (frag_id + 1 == query->next_frag_id) {
364 : 0 : wpa_printf(MSG_DEBUG, "GAS: Drop frame as possible "
365 : : "retry of previous fragment");
366 : 0 : return;
367 : : }
368 : 0 : gas_query_done(gas, query, GAS_QUERY_PEER_ERROR);
369 : 0 : return;
370 : : }
371 : 18 : query->next_frag_id++;
372 : :
373 [ - + ]: 18 : if (gas_query_append(query, resp, len) < 0) {
374 : 0 : gas_query_done(gas, query, GAS_QUERY_INTERNAL_ERROR);
375 : 0 : return;
376 : : }
377 : :
378 [ + + ]: 18 : if (more_frags) {
379 : 14 : gas_query_tx_comeback_req(gas, query);
380 : 14 : return;
381 : : }
382 : :
383 : 18 : gas_query_done(gas, query, GAS_QUERY_SUCCESS);
384 : : }
385 : :
386 : :
387 : : /**
388 : : * gas_query_rx - Indicate reception of a Public Action frame
389 : : * @gas: GAS query data from gas_query_init()
390 : : * @da: Destination MAC address of the Action frame
391 : : * @sa: Source MAC address of the Action frame
392 : : * @bssid: BSSID of the Action frame
393 : : * @data: Payload of the Action frame
394 : : * @len: Length of @data
395 : : * @freq: Frequency (in MHz) on which the frame was received
396 : : * Returns: 0 if the Public Action frame was a GAS frame or -1 if not
397 : : */
398 : 305 : int gas_query_rx(struct gas_query *gas, const u8 *da, const u8 *sa,
399 : : const u8 *bssid, const u8 *data, size_t len, int freq)
400 : : {
401 : : struct gas_query_pending *query;
402 : 305 : u8 action, dialog_token, frag_id = 0, more_frags = 0;
403 : : u16 comeback_delay, resp_len;
404 : : const u8 *pos, *adv_proto;
405 : :
406 [ + - ][ + + ]: 305 : if (gas == NULL || len < 4)
407 : 13 : return -1;
408 : :
409 : 292 : pos = data;
410 : 292 : action = *pos++;
411 : 292 : dialog_token = *pos++;
412 : :
413 [ + + ][ + + ]: 292 : if (action != WLAN_PA_GAS_INITIAL_RESP &&
414 : : action != WLAN_PA_GAS_COMEBACK_RESP)
415 : 187 : return -1; /* Not a GAS response */
416 : :
417 : 105 : query = gas_query_get_pending(gas, sa, dialog_token);
418 [ + + ]: 105 : if (query == NULL) {
419 : 22 : wpa_printf(MSG_DEBUG, "GAS: No pending query found for " MACSTR
420 : 132 : " dialog token %u", MAC2STR(sa), dialog_token);
421 : 22 : return -1;
422 : : }
423 : :
424 [ + + ][ - + ]: 83 : if (query->wait_comeback && action == WLAN_PA_GAS_INITIAL_RESP) {
425 : 0 : wpa_printf(MSG_DEBUG, "GAS: Unexpected initial response from "
426 : : MACSTR " dialog token %u when waiting for comeback "
427 : 0 : "response", MAC2STR(sa), dialog_token);
428 : 0 : return 0;
429 : : }
430 : :
431 [ + + ][ + + ]: 83 : if (!query->wait_comeback && action == WLAN_PA_GAS_COMEBACK_RESP) {
432 : 3 : wpa_printf(MSG_DEBUG, "GAS: Unexpected comeback response from "
433 : : MACSTR " dialog token %u when waiting for initial "
434 : 18 : "response", MAC2STR(sa), dialog_token);
435 : 3 : return 0;
436 : : }
437 : :
438 : 80 : query->status_code = WPA_GET_LE16(pos);
439 : 80 : pos += 2;
440 : :
441 [ + + ]: 80 : if (query->status_code != WLAN_STATUS_SUCCESS) {
442 : 1 : wpa_printf(MSG_DEBUG, "GAS: Query to " MACSTR " dialog token "
443 : : "%u failed - status code %u",
444 : 7 : MAC2STR(sa), dialog_token, query->status_code);
445 : 1 : gas_query_done(gas, query, GAS_QUERY_FAILURE);
446 : 1 : return 0;
447 : : }
448 : :
449 [ + + ]: 79 : if (action == WLAN_PA_GAS_COMEBACK_RESP) {
450 [ - + ]: 18 : if (pos + 1 > data + len)
451 : 0 : return 0;
452 : 18 : frag_id = *pos & 0x7f;
453 : 18 : more_frags = (*pos & 0x80) >> 7;
454 : 18 : pos++;
455 : : }
456 : :
457 : : /* Comeback Delay */
458 [ - + ]: 79 : if (pos + 2 > data + len)
459 : 0 : return 0;
460 : 79 : comeback_delay = WPA_GET_LE16(pos);
461 : 79 : pos += 2;
462 : :
463 : : /* Advertisement Protocol element */
464 [ + + ][ + + ]: 79 : if (pos + 2 > data + len || pos + 2 + pos[1] > data + len) {
465 : 4 : wpa_printf(MSG_DEBUG, "GAS: No room for Advertisement "
466 : : "Protocol element in the response from " MACSTR,
467 : 24 : MAC2STR(sa));
468 : 4 : return 0;
469 : : }
470 : :
471 [ + + ]: 75 : if (*pos != WLAN_EID_ADV_PROTO) {
472 : 1 : wpa_printf(MSG_DEBUG, "GAS: Unexpected Advertisement "
473 : : "Protocol element ID %u in response from " MACSTR,
474 : 7 : *pos, MAC2STR(sa));
475 : 1 : return 0;
476 : : }
477 : :
478 : 74 : adv_proto = pos;
479 : 74 : pos += 2 + pos[1];
480 : :
481 : : /* Query Response Length */
482 [ + + ]: 74 : if (pos + 2 > data + len) {
483 : 2 : wpa_printf(MSG_DEBUG, "GAS: No room for GAS Response Length");
484 : 2 : return 0;
485 : : }
486 : 72 : resp_len = WPA_GET_LE16(pos);
487 : 72 : pos += 2;
488 : :
489 [ + + ]: 72 : if (pos + resp_len > data + len) {
490 : 3 : wpa_printf(MSG_DEBUG, "GAS: Truncated Query Response in "
491 : 18 : "response from " MACSTR, MAC2STR(sa));
492 : 3 : return 0;
493 : : }
494 : :
495 [ + + ]: 69 : if (pos + resp_len < data + len) {
496 : 1 : wpa_printf(MSG_DEBUG, "GAS: Ignore %u octets of extra data "
497 : : "after Query Response from " MACSTR,
498 : 1 : (unsigned int) (data + len - pos - resp_len),
499 : 6 : MAC2STR(sa));
500 : : }
501 : :
502 [ + + ]: 69 : if (action == WLAN_PA_GAS_COMEBACK_RESP)
503 : 18 : gas_query_rx_comeback(gas, query, adv_proto, pos, resp_len,
504 : : frag_id, more_frags, comeback_delay);
505 : : else
506 : 51 : gas_query_rx_initial(gas, query, adv_proto, pos, resp_len,
507 : : comeback_delay);
508 : :
509 : 305 : return 0;
510 : : }
511 : :
512 : :
513 : 2 : static void gas_query_timeout(void *eloop_data, void *user_ctx)
514 : : {
515 : 2 : struct gas_query *gas = eloop_data;
516 : 2 : struct gas_query_pending *query = user_ctx;
517 : :
518 : 2 : wpa_printf(MSG_DEBUG, "GAS: No response received for query to " MACSTR
519 : : " dialog token %u",
520 : 14 : MAC2STR(query->addr), query->dialog_token);
521 : 2 : gas_query_done(gas, query, GAS_QUERY_TIMEOUT);
522 : 2 : }
523 : :
524 : :
525 : 54 : static int gas_query_dialog_token_available(struct gas_query *gas,
526 : : const u8 *dst, u8 dialog_token)
527 : : {
528 : : struct gas_query_pending *q;
529 [ + + ]: 57 : dl_list_for_each(q, &gas->pending, struct gas_query_pending, list) {
530 [ + - ][ - + ]: 3 : if (os_memcmp(dst, q->addr, ETH_ALEN) == 0 &&
531 : 3 : dialog_token == q->dialog_token)
532 : 0 : return 0;
533 : : }
534 : :
535 : 54 : return 1;
536 : : }
537 : :
538 : :
539 : 54 : static void gas_query_start_cb(struct wpa_radio_work *work, int deinit)
540 : : {
541 : 54 : struct gas_query_pending *query = work->ctx;
542 : 54 : struct gas_query *gas = query->gas;
543 : :
544 [ - + ]: 54 : if (deinit) {
545 : 0 : gas_query_free(query, 1);
546 : 0 : return;
547 : : }
548 : :
549 : 54 : gas->work = work;
550 : :
551 [ - + ]: 54 : if (gas_query_tx(gas, query, query->req) < 0) {
552 : 0 : wpa_printf(MSG_DEBUG, "GAS: Failed to send Action frame to "
553 : 0 : MACSTR, MAC2STR(query->addr));
554 : 0 : gas_query_free(query, 1);
555 : 0 : return;
556 : : }
557 : 54 : gas->current = query;
558 : :
559 : 54 : wpa_printf(MSG_DEBUG, "GAS: Starting query timeout for dialog token %u",
560 : 54 : query->dialog_token);
561 : 54 : eloop_register_timeout(GAS_QUERY_TIMEOUT_PERIOD, 0,
562 : : gas_query_timeout, gas, query);
563 : :
564 : : }
565 : :
566 : :
567 : : /**
568 : : * gas_query_req - Request a GAS query
569 : : * @gas: GAS query data from gas_query_init()
570 : : * @dst: Destination MAC address for the query
571 : : * @freq: Frequency (in MHz) for the channel on which to send the query
572 : : * @req: GAS query payload (to be freed by gas_query module in case of success
573 : : * return)
574 : : * @cb: Callback function for reporting GAS query result and response
575 : : * @ctx: Context pointer to use with the @cb call
576 : : * Returns: dialog token (>= 0) on success or -1 on failure
577 : : */
578 : 54 : int gas_query_req(struct gas_query *gas, const u8 *dst, int freq,
579 : : struct wpabuf *req,
580 : : void (*cb)(void *ctx, const u8 *dst, u8 dialog_token,
581 : : enum gas_query_result result,
582 : : const struct wpabuf *adv_proto,
583 : : const struct wpabuf *resp, u16 status_code),
584 : : void *ctx)
585 : : {
586 : : struct gas_query_pending *query;
587 : : int dialog_token;
588 : : static int next_start = 0;
589 : :
590 [ - + ]: 54 : if (wpabuf_len(req) < 3)
591 : 0 : return -1;
592 : :
593 [ + - ]: 54 : for (dialog_token = 0; dialog_token < 256; dialog_token++) {
594 [ + - ]: 54 : if (gas_query_dialog_token_available(
595 : 54 : gas, dst, (next_start + dialog_token) % 256))
596 : 54 : break;
597 : : }
598 [ - + ]: 54 : if (dialog_token == 256)
599 : 0 : return -1; /* Too many pending queries */
600 : 54 : dialog_token = (next_start + dialog_token) % 256;
601 : 54 : next_start = (dialog_token + 1) % 256;
602 : :
603 : 54 : query = os_zalloc(sizeof(*query));
604 [ - + ]: 54 : if (query == NULL)
605 : 0 : return -1;
606 : :
607 : 54 : query->gas = gas;
608 : 54 : os_memcpy(query->addr, dst, ETH_ALEN);
609 : 54 : query->dialog_token = dialog_token;
610 : 54 : query->freq = freq;
611 : 54 : query->cb = cb;
612 : 54 : query->ctx = ctx;
613 : 54 : query->req = req;
614 : 54 : dl_list_add(&gas->pending, &query->list);
615 : :
616 : 54 : *(wpabuf_mhead_u8(req) + 2) = dialog_token;
617 : :
618 : 54 : wpa_msg(gas->wpa_s, MSG_INFO, GAS_QUERY_START "addr=" MACSTR
619 : : " dialog_token=%u freq=%d",
620 : 378 : MAC2STR(query->addr), query->dialog_token, query->freq);
621 : :
622 [ - + ]: 54 : if (radio_add_work(gas->wpa_s, freq, "gas-query", 0, gas_query_start_cb,
623 : : query) < 0) {
624 : 0 : gas_query_free(query, 1);
625 : 0 : return -1;
626 : : }
627 : :
628 : 54 : return dialog_token;
629 : : }
630 : :
631 : :
632 : : /**
633 : : * gas_query_cancel - Cancel a pending GAS query
634 : : * @gas: GAS query data from gas_query_init()
635 : : * @dst: Destination MAC address for the query
636 : : * @dialog_token: Dialog token from gas_query_req()
637 : : */
638 : 0 : void gas_query_cancel(struct gas_query *gas, const u8 *dst, u8 dialog_token)
639 : : {
640 : : struct gas_query_pending *query;
641 : :
642 : 0 : query = gas_query_get_pending(gas, dst, dialog_token);
643 [ # # ]: 0 : if (query)
644 : 0 : gas_query_done(gas, query, GAS_QUERY_CANCELLED);
645 : :
646 : 0 : }
|
