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