~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/irda/irlmp_event.c

Version: ~ [ linux-6.2-rc3 ] ~ [ linux-6.1.5 ] ~ [ linux-6.0.19 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.87 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.162 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.228 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.269 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.302 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.337 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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  *
 21  *     Neither Dag Brattli nor University of Tromsø admit liability nor
 22  *     provide warranty for any of this software. This material is
 23  *     provided "AS-IS" and at no charge.
 24  *
 25  ********************************************************************/
 26 
 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 *const irlmp_state[] = {
 37         "LAP_STANDBY",
 38         "LAP_U_CONNECT",
 39         "LAP_ACTIVE",
 40 };
 41 
 42 const char *const 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 static const char *const irlmp_event[] __maybe_unused = {
 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 };
 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         /*
121           pr_debug("%s(), LMP LAP = %s\n", __func__, irlmp_state[state]);
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;);
131         pr_debug("%s(), LMP LSAP = %s\n", __func__, irlsap_state[state]);
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 
143         pr_debug("%s(), EVENT = %s, STATE = %s\n",
144                  __func__, irlmp_event[event], irlsap_state[self->lsap_state]);
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 
161         pr_debug("%s(), EVENT = %s, STATE = %s\n", __func__,
162                  irlmp_event[event],
163                  irlmp_state[self->lap_state]);
164 
165         (*lap_state[self->lap_state]) (self, event, skb);
166 }
167 
168 void irlmp_discovery_timer_expired(void *data)
169 {
170         /* We always cleanup the log (active & passive discovery) */
171         irlmp_do_expiry();
172 
173         irlmp_do_discovery(sysctl_discovery_slots);
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 
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 
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 {
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:
270                 pr_debug("%s() LS_CONNECT_REQUEST\n", __func__);
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:
278                 pr_debug("%s(), Error LM_LAP_DISCONNECT_INDICATION\n",
279                          __func__);
280 
281                 irlmp_next_lap_state(self, LAP_STANDBY);
282                 break;
283         default:
284                 pr_debug("%s(), Unknown event %s\n",
285                          __func__, irlmp_event[event]);
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 {
300         pr_debug("%s(), event=%s\n", __func__, irlmp_event[event]);
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) {
320                         pr_debug("%s() NO LSAPs !\n",  __func__);
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) {
338                         pr_debug("%s() NO LSAPs !\n",  __func__);
339                         irlmp_start_idle_timer(self, LM_IDLE_TIMEOUT);
340                 }
341                 break;
342         case LM_LAP_DISCONNECT_INDICATION:
343                 pr_debug("%s(), LM_LAP_DISCONNECT_INDICATION\n",  __func__);
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:
351                 pr_debug("%s(), LM_LAP_DISCONNECT_REQUEST\n",  __func__);
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:
360                 pr_debug("%s(), Unknown event %s\n",
361                          __func__, irlmp_event[event]);
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 {
375         switch (event) {
376         case LM_LAP_CONNECT_REQUEST:
377                 pr_debug("%s(), LS_CONNECT_REQUEST\n", __func__);
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:
459                 pr_debug("%s(), Unknown event %s\n",
460                          __func__, irlmp_event[event]);
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 
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:
488                 /* This is most bizarre. Those packets are  aka unreliable
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:
495                 pr_debug("%s(), LM_CONNECT_REQUEST\n", __func__);
496 
497                 if (self->conn_skb) {
498                         net_warn_ratelimited("%s: busy with another request!\n",
499                                              __func__);
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) {
515                         net_warn_ratelimited("%s: busy with another request!\n",
516                                              __func__);
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:
541                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
542                          __func__, irlmp_event[event], self->slsap_sel);
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 
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 */
591                 pr_debug("%s() WATCHDOG_TIMEOUT!\n",  __func__);
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 */
601                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
602                          __func__, irlmp_event[event], self->slsap_sel);
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 
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:
628                 pr_debug("%s(), LM_CONNECT_RESPONSE, no indication issued yet\n",
629                          __func__);
630                 /* Keep state */
631                 break;
632         case LM_DISCONNECT_REQUEST:
633                 pr_debug("%s(), LM_DISCONNECT_REQUEST, not yet bound to IrLAP connection\n",
634                          __func__);
635                 /* Keep state */
636                 break;
637         case LM_LAP_CONNECT_CONFIRM:
638                 pr_debug("%s(), LS_CONNECT_CONFIRM\n",  __func__);
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 */
652                 pr_debug("%s() WATCHDOG_TIMEOUT!\n",  __func__);
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 */
665                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
666                          __func__, irlmp_event[event], self->slsap_sel);
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 
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:
705                 pr_debug("%s(), LM_CONNECT_REQUEST, error, LSAP already connected\n",
706                          __func__);
707                 /* Keep state */
708                 break;
709         case LM_CONNECT_RESPONSE:
710                 pr_debug("%s(), LM_CONNECT_RESPONSE, error, LSAP already connected\n",
711                          __func__);
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) {
723                         pr_debug("%s(), trying to close IrLAP\n",
724                                  __func__);
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 */
748                 pr_debug("%s(), trying to close IrLAP\n", __func__);
749                 irlmp_do_lap_event(self->lap, LM_LAP_DISCONNECT_REQUEST, NULL);
750 
751                 irlmp_disconnect_indication(self, reason, skb);
752                 break;
753         default:
754                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
755                          __func__, irlmp_event[event], self->slsap_sel);
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 
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 */
796                 pr_debug("%s(), trying to close IrLAP\n",  __func__);
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:
814                 pr_debug("%s() WATCHDOG_TIMEOUT!\n", __func__);
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:
823                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
824                          __func__, irlmp_event[event], self->slsap_sel);
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 
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:
863                 pr_debug("%s() : WATCHDOG_TIMEOUT !\n",  __func__);
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:
881                 pr_debug("%s(), Unknown event %s on LSAP %#02x\n",
882                          __func__, irlmp_event[event], self->slsap_sel);
883                 break;
884         }
885         return ret;
886 }
887 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp