Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /********************************************************************* |
2 | * | |
3 | * Filename: irlmp_event.c | |
4 | * Version: 0.8 | |
5 | * Description: An IrDA LMP event driver for Linux | |
6 | * Status: Experimental. | |
7 | * Author: Dag Brattli <dagb@cs.uit.no> | |
8 | * Created at: Mon Aug 4 20:40:53 1997 | |
9 | * Modified at: Tue Dec 14 23:04:16 1999 | |
10 | * Modified by: Dag Brattli <dagb@cs.uit.no> | |
11 | * | |
12 | * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>, | |
13 | * All Rights Reserved. | |
14 | * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> | |
15 | * | |
16 | * This program is free software; you can redistribute it and/or | |
17 | * modify it under the terms of the GNU General Public License as | |
18 | * published by the Free Software Foundation; either version 2 of | |
19 | * the License, or (at your option) any later version. | |
20 | * | |
96de0e25 | 21 | * Neither Dag Brattli nor University of Tromsø admit liability nor |
1da177e4 LT |
22 | * provide warranty for any of this software. This material is |
23 | * provided "AS-IS" and at no charge. | |
24 | * | |
25 | ********************************************************************/ | |
26 | ||
1da177e4 LT |
27 | #include <linux/kernel.h> |
28 | ||
29 | #include <net/irda/irda.h> | |
30 | #include <net/irda/timer.h> | |
31 | #include <net/irda/irlap.h> | |
32 | #include <net/irda/irlmp.h> | |
33 | #include <net/irda/irlmp_frame.h> | |
34 | #include <net/irda/irlmp_event.h> | |
35 | ||
36cbd3dc | 36 | const char *const irlmp_state[] = { |
1da177e4 LT |
37 | "LAP_STANDBY", |
38 | "LAP_U_CONNECT", | |
39 | "LAP_ACTIVE", | |
40 | }; | |
41 | ||
36cbd3dc | 42 | const char *const irlsap_state[] = { |
1da177e4 LT |
43 | "LSAP_DISCONNECTED", |
44 | "LSAP_CONNECT", | |
45 | "LSAP_CONNECT_PEND", | |
46 | "LSAP_DATA_TRANSFER_READY", | |
47 | "LSAP_SETUP", | |
48 | "LSAP_SETUP_PEND", | |
49 | }; | |
50 | ||
a768851f | 51 | static const char *const irlmp_event[] __maybe_unused = { |
1da177e4 LT |
52 | "LM_CONNECT_REQUEST", |
53 | "LM_CONNECT_CONFIRM", | |
54 | "LM_CONNECT_RESPONSE", | |
55 | "LM_CONNECT_INDICATION", | |
56 | ||
57 | "LM_DISCONNECT_INDICATION", | |
58 | "LM_DISCONNECT_REQUEST", | |
59 | ||
60 | "LM_DATA_REQUEST", | |
61 | "LM_UDATA_REQUEST", | |
62 | "LM_DATA_INDICATION", | |
63 | "LM_UDATA_INDICATION", | |
64 | ||
65 | "LM_WATCHDOG_TIMEOUT", | |
66 | ||
67 | /* IrLAP events */ | |
68 | "LM_LAP_CONNECT_REQUEST", | |
69 | "LM_LAP_CONNECT_INDICATION", | |
70 | "LM_LAP_CONNECT_CONFIRM", | |
71 | "LM_LAP_DISCONNECT_INDICATION", | |
72 | "LM_LAP_DISCONNECT_REQUEST", | |
73 | "LM_LAP_DISCOVERY_REQUEST", | |
74 | "LM_LAP_DISCOVERY_CONFIRM", | |
75 | "LM_LAP_IDLE_TIMEOUT", | |
76 | }; | |
1da177e4 LT |
77 | |
78 | /* LAP Connection control proto declarations */ | |
79 | static void irlmp_state_standby (struct lap_cb *, IRLMP_EVENT, | |
80 | struct sk_buff *); | |
81 | static void irlmp_state_u_connect(struct lap_cb *, IRLMP_EVENT, | |
82 | struct sk_buff *); | |
83 | static void irlmp_state_active (struct lap_cb *, IRLMP_EVENT, | |
84 | struct sk_buff *); | |
85 | ||
86 | /* LSAP Connection control proto declarations */ | |
87 | static int irlmp_state_disconnected(struct lsap_cb *, IRLMP_EVENT, | |
88 | struct sk_buff *); | |
89 | static int irlmp_state_connect (struct lsap_cb *, IRLMP_EVENT, | |
90 | struct sk_buff *); | |
91 | static int irlmp_state_connect_pend(struct lsap_cb *, IRLMP_EVENT, | |
92 | struct sk_buff *); | |
93 | static int irlmp_state_dtr (struct lsap_cb *, IRLMP_EVENT, | |
94 | struct sk_buff *); | |
95 | static int irlmp_state_setup (struct lsap_cb *, IRLMP_EVENT, | |
96 | struct sk_buff *); | |
97 | static int irlmp_state_setup_pend (struct lsap_cb *, IRLMP_EVENT, | |
98 | struct sk_buff *); | |
99 | ||
100 | static void (*lap_state[]) (struct lap_cb *, IRLMP_EVENT, struct sk_buff *) = | |
101 | { | |
102 | irlmp_state_standby, | |
103 | irlmp_state_u_connect, | |
104 | irlmp_state_active, | |
105 | }; | |
106 | ||
107 | static int (*lsap_state[])( struct lsap_cb *, IRLMP_EVENT, struct sk_buff *) = | |
108 | { | |
109 | irlmp_state_disconnected, | |
110 | irlmp_state_connect, | |
111 | irlmp_state_connect_pend, | |
112 | irlmp_state_dtr, | |
113 | irlmp_state_setup, | |
114 | irlmp_state_setup_pend | |
115 | }; | |
116 | ||
117 | static inline void irlmp_next_lap_state(struct lap_cb *self, | |
118 | IRLMP_STATE state) | |
119 | { | |
120 | /* | |
955a9d20 | 121 | pr_debug("%s(), LMP LAP = %s\n", __func__, irlmp_state[state]); |
1da177e4 LT |
122 | */ |
123 | self->lap_state = state; | |
124 | } | |
125 | ||
126 | static inline void irlmp_next_lsap_state(struct lsap_cb *self, | |
127 | LSAP_STATE state) | |
128 | { | |
129 | /* | |
130 | IRDA_ASSERT(self != NULL, return;); | |
955a9d20 | 131 | pr_debug("%s(), LMP LSAP = %s\n", __func__, irlsap_state[state]); |
1da177e4 LT |
132 | */ |
133 | self->lsap_state = state; | |
134 | } | |
135 | ||
136 | /* Do connection control events */ | |
137 | int irlmp_do_lsap_event(struct lsap_cb *self, IRLMP_EVENT event, | |
138 | struct sk_buff *skb) | |
139 | { | |
140 | IRDA_ASSERT(self != NULL, return -1;); | |
141 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
142 | ||
955a9d20 JP |
143 | pr_debug("%s(), EVENT = %s, STATE = %s\n", |
144 | __func__, irlmp_event[event], irlsap_state[self->lsap_state]); | |
1da177e4 LT |
145 | |
146 | return (*lsap_state[self->lsap_state]) (self, event, skb); | |
147 | } | |
148 | ||
149 | /* | |
150 | * Function do_lap_event (event, skb, info) | |
151 | * | |
152 | * Do IrLAP control events | |
153 | * | |
154 | */ | |
155 | void irlmp_do_lap_event(struct lap_cb *self, IRLMP_EVENT event, | |
156 | struct sk_buff *skb) | |
157 | { | |
158 | IRDA_ASSERT(self != NULL, return;); | |
159 | IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); | |
160 | ||
955a9d20 JP |
161 | pr_debug("%s(), EVENT = %s, STATE = %s\n", __func__, |
162 | irlmp_event[event], | |
163 | irlmp_state[self->lap_state]); | |
1da177e4 LT |
164 | |
165 | (*lap_state[self->lap_state]) (self, event, skb); | |
166 | } | |
167 | ||
168 | void irlmp_discovery_timer_expired(void *data) | |
169 | { | |
1da177e4 LT |
170 | /* We always cleanup the log (active & passive discovery) */ |
171 | irlmp_do_expiry(); | |
172 | ||
91cde6f7 | 173 | irlmp_do_discovery(sysctl_discovery_slots); |
1da177e4 LT |
174 | |
175 | /* Restart timer */ | |
176 | irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout * HZ); | |
177 | } | |
178 | ||
179 | void irlmp_watchdog_timer_expired(void *data) | |
180 | { | |
181 | struct lsap_cb *self = (struct lsap_cb *) data; | |
182 | ||
1da177e4 LT |
183 | IRDA_ASSERT(self != NULL, return;); |
184 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return;); | |
185 | ||
186 | irlmp_do_lsap_event(self, LM_WATCHDOG_TIMEOUT, NULL); | |
187 | } | |
188 | ||
189 | void irlmp_idle_timer_expired(void *data) | |
190 | { | |
191 | struct lap_cb *self = (struct lap_cb *) data; | |
192 | ||
1da177e4 LT |
193 | IRDA_ASSERT(self != NULL, return;); |
194 | IRDA_ASSERT(self->magic == LMP_LAP_MAGIC, return;); | |
195 | ||
196 | irlmp_do_lap_event(self, LM_LAP_IDLE_TIMEOUT, NULL); | |
197 | } | |
198 | ||
199 | /* | |
200 | * Send an event on all LSAPs attached to this LAP. | |
201 | */ | |
202 | static inline void | |
203 | irlmp_do_all_lsap_event(hashbin_t * lsap_hashbin, | |
204 | IRLMP_EVENT event) | |
205 | { | |
206 | struct lsap_cb *lsap; | |
207 | struct lsap_cb *lsap_next; | |
208 | ||
209 | /* Note : this function use the new hashbin_find_next() | |
210 | * function, instead of the old hashbin_get_next(). | |
211 | * This make sure that we are always pointing one lsap | |
212 | * ahead, so that if the current lsap is removed as the | |
213 | * result of sending the event, we don't care. | |
214 | * Also, as we store the context ourselves, if an enumeration | |
215 | * of the same lsap hashbin happens as the result of sending the | |
216 | * event, we don't care. | |
217 | * The only problem is if the next lsap is removed. In that case, | |
218 | * hashbin_find_next() will return NULL and we will abort the | |
219 | * enumeration. - Jean II */ | |
220 | ||
221 | /* Also : we don't accept any skb in input. We can *NOT* pass | |
222 | * the same skb to multiple clients safely, we would need to | |
223 | * skb_clone() it. - Jean II */ | |
224 | ||
225 | lsap = (struct lsap_cb *) hashbin_get_first(lsap_hashbin); | |
226 | ||
227 | while (NULL != hashbin_find_next(lsap_hashbin, | |
228 | (long) lsap, | |
229 | NULL, | |
230 | (void *) &lsap_next) ) { | |
231 | irlmp_do_lsap_event(lsap, event, NULL); | |
232 | lsap = lsap_next; | |
233 | } | |
234 | } | |
235 | ||
236 | /********************************************************************* | |
237 | * | |
238 | * LAP connection control states | |
239 | * | |
240 | ********************************************************************/ | |
241 | ||
242 | /* | |
243 | * Function irlmp_state_standby (event, skb, info) | |
244 | * | |
245 | * STANDBY, The IrLAP connection does not exist. | |
246 | * | |
247 | */ | |
248 | static void irlmp_state_standby(struct lap_cb *self, IRLMP_EVENT event, | |
249 | struct sk_buff *skb) | |
250 | { | |
1da177e4 LT |
251 | IRDA_ASSERT(self->irlap != NULL, return;); |
252 | ||
253 | switch (event) { | |
254 | case LM_LAP_DISCOVERY_REQUEST: | |
255 | /* irlmp_next_station_state( LMP_DISCOVER); */ | |
256 | ||
257 | irlap_discovery_request(self->irlap, &irlmp->discovery_cmd); | |
258 | break; | |
259 | case LM_LAP_CONNECT_INDICATION: | |
260 | /* It's important to switch state first, to avoid IrLMP to | |
261 | * think that the link is free since IrLMP may then start | |
262 | * discovery before the connection is properly set up. DB. | |
263 | */ | |
264 | irlmp_next_lap_state(self, LAP_ACTIVE); | |
265 | ||
266 | /* Just accept connection TODO, this should be fixed */ | |
267 | irlap_connect_response(self->irlap, skb); | |
268 | break; | |
269 | case LM_LAP_CONNECT_REQUEST: | |
955a9d20 | 270 | pr_debug("%s() LS_CONNECT_REQUEST\n", __func__); |
1da177e4 LT |
271 | |
272 | irlmp_next_lap_state(self, LAP_U_CONNECT); | |
273 | ||
274 | /* FIXME: need to set users requested QoS */ | |
275 | irlap_connect_request(self->irlap, self->daddr, NULL, 0); | |
276 | break; | |
277 | case LM_LAP_DISCONNECT_INDICATION: | |
955a9d20 JP |
278 | pr_debug("%s(), Error LM_LAP_DISCONNECT_INDICATION\n", |
279 | __func__); | |
1da177e4 LT |
280 | |
281 | irlmp_next_lap_state(self, LAP_STANDBY); | |
282 | break; | |
283 | default: | |
955a9d20 JP |
284 | pr_debug("%s(), Unknown event %s\n", |
285 | __func__, irlmp_event[event]); | |
1da177e4 LT |
286 | break; |
287 | } | |
288 | } | |
289 | ||
290 | /* | |
291 | * Function irlmp_state_u_connect (event, skb, info) | |
292 | * | |
293 | * U_CONNECT, The layer above has tried to open an LSAP connection but | |
294 | * since the IrLAP connection does not exist, we must first start an | |
295 | * IrLAP connection. We are now waiting response from IrLAP. | |
296 | * */ | |
297 | static void irlmp_state_u_connect(struct lap_cb *self, IRLMP_EVENT event, | |
298 | struct sk_buff *skb) | |
299 | { | |
955a9d20 | 300 | pr_debug("%s(), event=%s\n", __func__, irlmp_event[event]); |
1da177e4 LT |
301 | |
302 | switch (event) { | |
303 | case LM_LAP_CONNECT_INDICATION: | |
304 | /* It's important to switch state first, to avoid IrLMP to | |
305 | * think that the link is free since IrLMP may then start | |
306 | * discovery before the connection is properly set up. DB. | |
307 | */ | |
308 | irlmp_next_lap_state(self, LAP_ACTIVE); | |
309 | ||
310 | /* Just accept connection TODO, this should be fixed */ | |
311 | irlap_connect_response(self->irlap, skb); | |
312 | ||
313 | /* Tell LSAPs that they can start sending data */ | |
314 | irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); | |
315 | ||
316 | /* Note : by the time we get there (LAP retries and co), | |
317 | * the lsaps may already have gone. This avoid getting stuck | |
318 | * forever in LAP_ACTIVE state - Jean II */ | |
319 | if (HASHBIN_GET_SIZE(self->lsaps) == 0) { | |
955a9d20 | 320 | pr_debug("%s() NO LSAPs !\n", __func__); |
1da177e4 LT |
321 | irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT); |
322 | } | |
323 | break; | |
324 | case LM_LAP_CONNECT_REQUEST: | |
325 | /* Already trying to connect */ | |
326 | break; | |
327 | case LM_LAP_CONNECT_CONFIRM: | |
328 | /* For all lsap_ce E Associated do LS_Connect_confirm */ | |
329 | irlmp_next_lap_state(self, LAP_ACTIVE); | |
330 | ||
331 | /* Tell LSAPs that they can start sending data */ | |
332 | irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); | |
333 | ||
334 | /* Note : by the time we get there (LAP retries and co), | |
335 | * the lsaps may already have gone. This avoid getting stuck | |
336 | * forever in LAP_ACTIVE state - Jean II */ | |
337 | if (HASHBIN_GET_SIZE(self->lsaps) == 0) { | |
955a9d20 | 338 | pr_debug("%s() NO LSAPs !\n", __func__); |
1da177e4 LT |
339 | irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT); |
340 | } | |
341 | break; | |
342 | case LM_LAP_DISCONNECT_INDICATION: | |
955a9d20 | 343 | pr_debug("%s(), LM_LAP_DISCONNECT_INDICATION\n", __func__); |
1da177e4 LT |
344 | irlmp_next_lap_state(self, LAP_STANDBY); |
345 | ||
346 | /* Send disconnect event to all LSAPs using this link */ | |
347 | irlmp_do_all_lsap_event(self->lsaps, | |
348 | LM_LAP_DISCONNECT_INDICATION); | |
349 | break; | |
350 | case LM_LAP_DISCONNECT_REQUEST: | |
955a9d20 | 351 | pr_debug("%s(), LM_LAP_DISCONNECT_REQUEST\n", __func__); |
1da177e4 LT |
352 | |
353 | /* One of the LSAP did timeout or was closed, if it was | |
354 | * the last one, try to get out of here - Jean II */ | |
355 | if (HASHBIN_GET_SIZE(self->lsaps) <= 1) { | |
356 | irlap_disconnect_request(self->irlap); | |
357 | } | |
358 | break; | |
359 | default: | |
955a9d20 | 360 | pr_debug("%s(), Unknown event %s\n", |
0dc47877 | 361 | __func__, irlmp_event[event]); |
1da177e4 LT |
362 | break; |
363 | } | |
364 | } | |
365 | ||
366 | /* | |
367 | * Function irlmp_state_active (event, skb, info) | |
368 | * | |
369 | * ACTIVE, IrLAP connection is active | |
370 | * | |
371 | */ | |
372 | static void irlmp_state_active(struct lap_cb *self, IRLMP_EVENT event, | |
373 | struct sk_buff *skb) | |
374 | { | |
1da177e4 LT |
375 | switch (event) { |
376 | case LM_LAP_CONNECT_REQUEST: | |
955a9d20 | 377 | pr_debug("%s(), LS_CONNECT_REQUEST\n", __func__); |
1da177e4 LT |
378 | |
379 | /* | |
380 | * IrLAP may have a pending disconnect. We tried to close | |
381 | * IrLAP, but it was postponed because the link was | |
382 | * busy or we were still sending packets. As we now | |
383 | * need it, make sure it stays on. Jean II | |
384 | */ | |
385 | irlap_clear_disconnect(self->irlap); | |
386 | ||
387 | /* | |
388 | * LAP connection already active, just bounce back! Since we | |
389 | * don't know which LSAP that tried to do this, we have to | |
390 | * notify all LSAPs using this LAP, but that should be safe to | |
391 | * do anyway. | |
392 | */ | |
393 | irlmp_do_all_lsap_event(self->lsaps, LM_LAP_CONNECT_CONFIRM); | |
394 | ||
395 | /* Needed by connect indication */ | |
396 | irlmp_do_all_lsap_event(irlmp->unconnected_lsaps, | |
397 | LM_LAP_CONNECT_CONFIRM); | |
398 | /* Keep state */ | |
399 | break; | |
400 | case LM_LAP_DISCONNECT_REQUEST: | |
401 | /* | |
402 | * Need to find out if we should close IrLAP or not. If there | |
403 | * is only one LSAP connection left on this link, that LSAP | |
404 | * must be the one that tries to close IrLAP. It will be | |
405 | * removed later and moved to the list of unconnected LSAPs | |
406 | */ | |
407 | if (HASHBIN_GET_SIZE(self->lsaps) > 0) { | |
408 | /* Timer value is checked in irsysctl - Jean II */ | |
409 | irlmp_start_idle_timer(self, sysctl_lap_keepalive_time * HZ / 1000); | |
410 | } else { | |
411 | /* No more connections, so close IrLAP */ | |
412 | ||
413 | /* We don't want to change state just yet, because | |
414 | * we want to reflect accurately the real state of | |
415 | * the LAP, not the state we wish it was in, | |
416 | * so that we don't lose LM_LAP_CONNECT_REQUEST. | |
417 | * In some cases, IrLAP won't close the LAP | |
418 | * immediately. For example, it might still be | |
419 | * retrying packets or waiting for the pf bit. | |
420 | * As the LAP always send a DISCONNECT_INDICATION | |
421 | * in PCLOSE or SCLOSE, just change state on that. | |
422 | * Jean II */ | |
423 | irlap_disconnect_request(self->irlap); | |
424 | } | |
425 | break; | |
426 | case LM_LAP_IDLE_TIMEOUT: | |
427 | if (HASHBIN_GET_SIZE(self->lsaps) == 0) { | |
428 | /* Same reasoning as above - keep state */ | |
429 | irlap_disconnect_request(self->irlap); | |
430 | } | |
431 | break; | |
432 | case LM_LAP_DISCONNECT_INDICATION: | |
433 | irlmp_next_lap_state(self, LAP_STANDBY); | |
434 | ||
435 | /* In some case, at this point our side has already closed | |
436 | * all lsaps, and we are waiting for the idle_timer to | |
437 | * expire. If another device reconnect immediately, the | |
438 | * idle timer will expire in the midle of the connection | |
439 | * initialisation, screwing up things a lot... | |
440 | * Therefore, we must stop the timer... */ | |
441 | irlmp_stop_idle_timer(self); | |
442 | ||
443 | /* | |
444 | * Inform all connected LSAP's using this link | |
445 | */ | |
446 | irlmp_do_all_lsap_event(self->lsaps, | |
447 | LM_LAP_DISCONNECT_INDICATION); | |
448 | ||
449 | /* Force an expiry of the discovery log. | |
450 | * Now that the LAP is free, the system may attempt to | |
451 | * connect to another device. Unfortunately, our entries | |
452 | * are stale. There is a small window (<3s) before the | |
453 | * normal discovery will run and where irlmp_connect_request() | |
454 | * can get the wrong info, so make sure things get | |
455 | * cleaned *NOW* ;-) - Jean II */ | |
456 | irlmp_do_expiry(); | |
457 | break; | |
458 | default: | |
955a9d20 | 459 | pr_debug("%s(), Unknown event %s\n", |
0dc47877 | 460 | __func__, irlmp_event[event]); |
1da177e4 LT |
461 | break; |
462 | } | |
463 | } | |
464 | ||
465 | /********************************************************************* | |
466 | * | |
467 | * LSAP connection control states | |
468 | * | |
469 | ********************************************************************/ | |
470 | ||
471 | /* | |
472 | * Function irlmp_state_disconnected (event, skb, info) | |
473 | * | |
474 | * DISCONNECTED | |
475 | * | |
476 | */ | |
477 | static int irlmp_state_disconnected(struct lsap_cb *self, IRLMP_EVENT event, | |
478 | struct sk_buff *skb) | |
479 | { | |
480 | int ret = 0; | |
481 | ||
1da177e4 LT |
482 | IRDA_ASSERT(self != NULL, return -1;); |
483 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
484 | ||
485 | switch (event) { | |
486 | #ifdef CONFIG_IRDA_ULTRA | |
487 | case LM_UDATA_INDICATION: | |
25985edc | 488 | /* This is most bizarre. Those packets are aka unreliable |
1da177e4 LT |
489 | * connected, aka IrLPT or SOCK_DGRAM/IRDAPROTO_UNITDATA. |
490 | * Why do we pass them as Ultra ??? Jean II */ | |
491 | irlmp_connless_data_indication(self, skb); | |
492 | break; | |
493 | #endif /* CONFIG_IRDA_ULTRA */ | |
494 | case LM_CONNECT_REQUEST: | |
955a9d20 | 495 | pr_debug("%s(), LM_CONNECT_REQUEST\n", __func__); |
1da177e4 LT |
496 | |
497 | if (self->conn_skb) { | |
6c91023d JP |
498 | net_warn_ratelimited("%s: busy with another request!\n", |
499 | __func__); | |
1da177e4 LT |
500 | return -EBUSY; |
501 | } | |
502 | /* Don't forget to refcount it (see irlmp_connect_request()) */ | |
503 | skb_get(skb); | |
504 | self->conn_skb = skb; | |
505 | ||
506 | irlmp_next_lsap_state(self, LSAP_SETUP_PEND); | |
507 | ||
508 | /* Start watchdog timer (5 secs for now) */ | |
509 | irlmp_start_watchdog_timer(self, 5*HZ); | |
510 | ||
511 | irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL); | |
512 | break; | |
513 | case LM_CONNECT_INDICATION: | |
514 | if (self->conn_skb) { | |
6c91023d JP |
515 | net_warn_ratelimited("%s: busy with another request!\n", |
516 | __func__); | |
1da177e4 LT |
517 | return -EBUSY; |
518 | } | |
519 | /* Don't forget to refcount it (see irlap_driver_rcv()) */ | |
520 | skb_get(skb); | |
521 | self->conn_skb = skb; | |
522 | ||
523 | irlmp_next_lsap_state(self, LSAP_CONNECT_PEND); | |
524 | ||
525 | /* Start watchdog timer | |
526 | * This is not mentionned in the spec, but there is a rare | |
527 | * race condition that can get the socket stuck. | |
528 | * If we receive this event while our LAP is closing down, | |
529 | * the LM_LAP_CONNECT_REQUEST get lost and we get stuck in | |
530 | * CONNECT_PEND state forever. | |
531 | * The other cause of getting stuck down there is if the | |
532 | * higher layer never reply to the CONNECT_INDICATION. | |
533 | * Anyway, it make sense to make sure that we always have | |
534 | * a backup plan. 1 second is plenty (should be immediate). | |
535 | * Jean II */ | |
536 | irlmp_start_watchdog_timer(self, 1*HZ); | |
537 | ||
538 | irlmp_do_lap_event(self->lap, LM_LAP_CONNECT_REQUEST, NULL); | |
539 | break; | |
540 | default: | |
955a9d20 JP |
541 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
542 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
543 | break; |
544 | } | |
545 | return ret; | |
546 | } | |
547 | ||
548 | /* | |
549 | * Function irlmp_state_connect (self, event, skb) | |
550 | * | |
551 | * CONNECT | |
552 | * | |
553 | */ | |
554 | static int irlmp_state_connect(struct lsap_cb *self, IRLMP_EVENT event, | |
555 | struct sk_buff *skb) | |
556 | { | |
557 | struct lsap_cb *lsap; | |
558 | int ret = 0; | |
559 | ||
1da177e4 LT |
560 | IRDA_ASSERT(self != NULL, return -1;); |
561 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
562 | ||
563 | switch (event) { | |
564 | case LM_CONNECT_RESPONSE: | |
565 | /* | |
566 | * Bind this LSAP to the IrLAP link where the connect was | |
567 | * received | |
568 | */ | |
569 | lsap = hashbin_remove(irlmp->unconnected_lsaps, (long) self, | |
570 | NULL); | |
571 | ||
572 | IRDA_ASSERT(lsap == self, return -1;); | |
573 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
574 | IRDA_ASSERT(self->lap->lsaps != NULL, return -1;); | |
575 | ||
576 | hashbin_insert(self->lap->lsaps, (irda_queue_t *) self, | |
577 | (long) self, NULL); | |
578 | ||
579 | set_bit(0, &self->connected); /* TRUE */ | |
580 | ||
581 | irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, | |
582 | self->slsap_sel, CONNECT_CNF, skb); | |
583 | ||
584 | del_timer(&self->watchdog_timer); | |
585 | ||
586 | irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY); | |
587 | break; | |
588 | case LM_WATCHDOG_TIMEOUT: | |
589 | /* May happen, who knows... | |
590 | * Jean II */ | |
955a9d20 | 591 | pr_debug("%s() WATCHDOG_TIMEOUT!\n", __func__); |
1da177e4 LT |
592 | |
593 | /* Disconnect, get out... - Jean II */ | |
594 | self->lap = NULL; | |
595 | self->dlsap_sel = LSAP_ANY; | |
596 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
597 | break; | |
598 | default: | |
599 | /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we | |
600 | * are *not* yet bound to the IrLAP link. Jean II */ | |
955a9d20 JP |
601 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
602 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
603 | break; |
604 | } | |
605 | return ret; | |
606 | } | |
607 | ||
608 | /* | |
609 | * Function irlmp_state_connect_pend (event, skb, info) | |
610 | * | |
611 | * CONNECT_PEND | |
612 | * | |
613 | */ | |
614 | static int irlmp_state_connect_pend(struct lsap_cb *self, IRLMP_EVENT event, | |
615 | struct sk_buff *skb) | |
616 | { | |
617 | struct sk_buff *tx_skb; | |
618 | int ret = 0; | |
619 | ||
1da177e4 LT |
620 | IRDA_ASSERT(self != NULL, return -1;); |
621 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
622 | ||
623 | switch (event) { | |
624 | case LM_CONNECT_REQUEST: | |
625 | /* Keep state */ | |
626 | break; | |
627 | case LM_CONNECT_RESPONSE: | |
955a9d20 JP |
628 | pr_debug("%s(), LM_CONNECT_RESPONSE, no indication issued yet\n", |
629 | __func__); | |
1da177e4 LT |
630 | /* Keep state */ |
631 | break; | |
632 | case LM_DISCONNECT_REQUEST: | |
955a9d20 JP |
633 | pr_debug("%s(), LM_DISCONNECT_REQUEST, not yet bound to IrLAP connection\n", |
634 | __func__); | |
1da177e4 LT |
635 | /* Keep state */ |
636 | break; | |
637 | case LM_LAP_CONNECT_CONFIRM: | |
955a9d20 | 638 | pr_debug("%s(), LS_CONNECT_CONFIRM\n", __func__); |
1da177e4 LT |
639 | irlmp_next_lsap_state(self, LSAP_CONNECT); |
640 | ||
641 | tx_skb = self->conn_skb; | |
642 | self->conn_skb = NULL; | |
643 | ||
644 | irlmp_connect_indication(self, tx_skb); | |
645 | /* Drop reference count - see irlmp_connect_indication(). */ | |
646 | dev_kfree_skb(tx_skb); | |
647 | break; | |
648 | case LM_WATCHDOG_TIMEOUT: | |
649 | /* Will happen in some rare cases because of a race condition. | |
650 | * Just make sure we don't stay there forever... | |
651 | * Jean II */ | |
955a9d20 | 652 | pr_debug("%s() WATCHDOG_TIMEOUT!\n", __func__); |
1da177e4 LT |
653 | |
654 | /* Go back to disconnected mode, keep the socket waiting */ | |
655 | self->lap = NULL; | |
656 | self->dlsap_sel = LSAP_ANY; | |
657 | if(self->conn_skb) | |
658 | dev_kfree_skb(self->conn_skb); | |
659 | self->conn_skb = NULL; | |
660 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
661 | break; | |
662 | default: | |
663 | /* LM_LAP_DISCONNECT_INDICATION : Should never happen, we | |
664 | * are *not* yet bound to the IrLAP link. Jean II */ | |
955a9d20 JP |
665 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
666 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
667 | break; |
668 | } | |
669 | return ret; | |
670 | } | |
671 | ||
672 | /* | |
673 | * Function irlmp_state_dtr (self, event, skb) | |
674 | * | |
675 | * DATA_TRANSFER_READY | |
676 | * | |
677 | */ | |
678 | static int irlmp_state_dtr(struct lsap_cb *self, IRLMP_EVENT event, | |
679 | struct sk_buff *skb) | |
680 | { | |
681 | LM_REASON reason; | |
682 | int ret = 0; | |
683 | ||
1da177e4 LT |
684 | IRDA_ASSERT(self != NULL, return -1;); |
685 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
686 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
687 | ||
688 | switch (event) { | |
689 | case LM_DATA_REQUEST: /* Optimize for the common case */ | |
690 | irlmp_send_data_pdu(self->lap, self->dlsap_sel, | |
691 | self->slsap_sel, FALSE, skb); | |
692 | break; | |
693 | case LM_DATA_INDICATION: /* Optimize for the common case */ | |
694 | irlmp_data_indication(self, skb); | |
695 | break; | |
696 | case LM_UDATA_REQUEST: | |
697 | IRDA_ASSERT(skb != NULL, return -1;); | |
698 | irlmp_send_data_pdu(self->lap, self->dlsap_sel, | |
699 | self->slsap_sel, TRUE, skb); | |
700 | break; | |
701 | case LM_UDATA_INDICATION: | |
702 | irlmp_udata_indication(self, skb); | |
703 | break; | |
704 | case LM_CONNECT_REQUEST: | |
955a9d20 JP |
705 | pr_debug("%s(), LM_CONNECT_REQUEST, error, LSAP already connected\n", |
706 | __func__); | |
1da177e4 LT |
707 | /* Keep state */ |
708 | break; | |
709 | case LM_CONNECT_RESPONSE: | |
955a9d20 JP |
710 | pr_debug("%s(), LM_CONNECT_RESPONSE, error, LSAP already connected\n", |
711 | __func__); | |
1da177e4 LT |
712 | /* Keep state */ |
713 | break; | |
714 | case LM_DISCONNECT_REQUEST: | |
715 | irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, self->slsap_sel, | |
716 | DISCONNECT, skb); | |
717 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
718 | /* Called only from irlmp_disconnect_request(), will | |
719 | * unbind from LAP over there. Jean II */ | |
720 | ||
721 | /* Try to close the LAP connection if its still there */ | |
722 | if (self->lap) { | |
955a9d20 JP |
723 | pr_debug("%s(), trying to close IrLAP\n", |
724 | __func__); | |
1da177e4 LT |
725 | irlmp_do_lap_event(self->lap, |
726 | LM_LAP_DISCONNECT_REQUEST, | |
727 | NULL); | |
728 | } | |
729 | break; | |
730 | case LM_LAP_DISCONNECT_INDICATION: | |
731 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
732 | ||
733 | reason = irlmp_convert_lap_reason(self->lap->reason); | |
734 | ||
735 | irlmp_disconnect_indication(self, reason, NULL); | |
736 | break; | |
737 | case LM_DISCONNECT_INDICATION: | |
738 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
739 | ||
740 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
741 | IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); | |
742 | ||
743 | IRDA_ASSERT(skb != NULL, return -1;); | |
744 | IRDA_ASSERT(skb->len > 3, return -1;); | |
745 | reason = skb->data[3]; | |
746 | ||
747 | /* Try to close the LAP connection */ | |
955a9d20 | 748 | pr_debug("%s(), trying to close IrLAP\n", __func__); |
1da177e4 LT |
749 | irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); |
750 | ||
751 | irlmp_disconnect_indication(self, reason, skb); | |
752 | break; | |
753 | default: | |
955a9d20 JP |
754 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
755 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
756 | break; |
757 | } | |
758 | return ret; | |
759 | } | |
760 | ||
761 | /* | |
762 | * Function irlmp_state_setup (event, skb, info) | |
763 | * | |
764 | * SETUP, Station Control has set up the underlying IrLAP connection. | |
765 | * An LSAP connection request has been transmitted to the peer | |
766 | * LSAP-Connection Control FSM and we are awaiting reply. | |
767 | */ | |
768 | static int irlmp_state_setup(struct lsap_cb *self, IRLMP_EVENT event, | |
769 | struct sk_buff *skb) | |
770 | { | |
771 | LM_REASON reason; | |
772 | int ret = 0; | |
773 | ||
774 | IRDA_ASSERT(self != NULL, return -1;); | |
775 | IRDA_ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;); | |
776 | ||
1da177e4 LT |
777 | switch (event) { |
778 | case LM_CONNECT_CONFIRM: | |
779 | irlmp_next_lsap_state(self, LSAP_DATA_TRANSFER_READY); | |
780 | ||
781 | del_timer(&self->watchdog_timer); | |
782 | ||
783 | irlmp_connect_confirm(self, skb); | |
784 | break; | |
785 | case LM_DISCONNECT_INDICATION: | |
786 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
787 | ||
788 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
789 | IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); | |
790 | ||
791 | IRDA_ASSERT(skb != NULL, return -1;); | |
792 | IRDA_ASSERT(skb->len > 3, return -1;); | |
793 | reason = skb->data[3]; | |
794 | ||
795 | /* Try to close the LAP connection */ | |
955a9d20 | 796 | pr_debug("%s(), trying to close IrLAP\n", __func__); |
1da177e4 LT |
797 | irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); |
798 | ||
799 | irlmp_disconnect_indication(self, reason, skb); | |
800 | break; | |
801 | case LM_LAP_DISCONNECT_INDICATION: | |
802 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
803 | ||
804 | del_timer(&self->watchdog_timer); | |
805 | ||
806 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
807 | IRDA_ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;); | |
808 | ||
809 | reason = irlmp_convert_lap_reason(self->lap->reason); | |
810 | ||
811 | irlmp_disconnect_indication(self, reason, skb); | |
812 | break; | |
813 | case LM_WATCHDOG_TIMEOUT: | |
955a9d20 | 814 | pr_debug("%s() WATCHDOG_TIMEOUT!\n", __func__); |
1da177e4 LT |
815 | |
816 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
817 | irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); | |
818 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
819 | ||
820 | irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL); | |
821 | break; | |
822 | default: | |
955a9d20 JP |
823 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
824 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
825 | break; |
826 | } | |
827 | return ret; | |
828 | } | |
829 | ||
830 | /* | |
831 | * Function irlmp_state_setup_pend (event, skb, info) | |
832 | * | |
833 | * SETUP_PEND, An LM_CONNECT_REQUEST has been received from the service | |
834 | * user to set up an LSAP connection. A request has been sent to the | |
835 | * LAP FSM to set up the underlying IrLAP connection, and we | |
836 | * are awaiting confirm. | |
837 | */ | |
838 | static int irlmp_state_setup_pend(struct lsap_cb *self, IRLMP_EVENT event, | |
839 | struct sk_buff *skb) | |
840 | { | |
841 | struct sk_buff *tx_skb; | |
842 | LM_REASON reason; | |
843 | int ret = 0; | |
844 | ||
1da177e4 LT |
845 | IRDA_ASSERT(self != NULL, return -1;); |
846 | IRDA_ASSERT(irlmp != NULL, return -1;); | |
847 | ||
848 | switch (event) { | |
849 | case LM_LAP_CONNECT_CONFIRM: | |
850 | IRDA_ASSERT(self->conn_skb != NULL, return -1;); | |
851 | ||
852 | tx_skb = self->conn_skb; | |
853 | self->conn_skb = NULL; | |
854 | ||
855 | irlmp_send_lcf_pdu(self->lap, self->dlsap_sel, | |
856 | self->slsap_sel, CONNECT_CMD, tx_skb); | |
857 | /* Drop reference count - see irlap_data_request(). */ | |
858 | dev_kfree_skb(tx_skb); | |
859 | ||
860 | irlmp_next_lsap_state(self, LSAP_SETUP); | |
861 | break; | |
862 | case LM_WATCHDOG_TIMEOUT: | |
955a9d20 | 863 | pr_debug("%s() : WATCHDOG_TIMEOUT !\n", __func__); |
1da177e4 LT |
864 | |
865 | IRDA_ASSERT(self->lap != NULL, return -1;); | |
866 | irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL); | |
867 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
868 | ||
869 | irlmp_disconnect_indication(self, LM_CONNECT_FAILURE, NULL); | |
870 | break; | |
871 | case LM_LAP_DISCONNECT_INDICATION: /* LS_Disconnect.indication */ | |
872 | del_timer( &self->watchdog_timer); | |
873 | ||
874 | irlmp_next_lsap_state(self, LSAP_DISCONNECTED); | |
875 | ||
876 | reason = irlmp_convert_lap_reason(self->lap->reason); | |
877 | ||
878 | irlmp_disconnect_indication(self, reason, NULL); | |
879 | break; | |
880 | default: | |
955a9d20 JP |
881 | pr_debug("%s(), Unknown event %s on LSAP %#02x\n", |
882 | __func__, irlmp_event[event], self->slsap_sel); | |
1da177e4 LT |
883 | break; |
884 | } | |
885 | return ret; | |
886 | } |