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

TOMOYO Linux Cross Reference
Linux/net/irda/irlan/irlan_client.c

Version: ~ [ linux-5.5-rc7 ] ~ [ linux-5.4.13 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.97 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.166 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.210 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.210 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*********************************************************************
  2  *
  3  * Filename:      irlan_client.c
  4  * Version:       0.9
  5  * Description:   IrDA LAN Access Protocol (IrLAN) Client
  6  * Status:        Experimental.
  7  * Author:        Dag Brattli <dagb@cs.uit.no>
  8  * Created at:    Sun Aug 31 20:14:37 1997
  9  * Modified at:   Tue Dec 14 15:47:02 1999
 10  * Modified by:   Dag Brattli <dagb@cs.uit.no>
 11  * Sources:       skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
 12  *                slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
 13  *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 14  *
 15  *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
 16  *     All Rights Reserved.
 17  *
 18  *     This program is free software; you can redistribute it and/or
 19  *     modify it under the terms of the GNU General Public License as
 20  *     published by the Free Software Foundation; either version 2 of
 21  *     the License, or (at your option) any later version.
 22  *
 23  *     Neither Dag Brattli nor University of Tromsø admit liability nor
 24  *     provide warranty for any of this software. This material is
 25  *     provided "AS-IS" and at no charge.
 26  *
 27  ********************************************************************/
 28 
 29 #include <linux/kernel.h>
 30 #include <linux/string.h>
 31 #include <linux/slab.h>
 32 #include <linux/errno.h>
 33 #include <linux/init.h>
 34 #include <linux/netdevice.h>
 35 #include <linux/etherdevice.h>
 36 #include <linux/if_arp.h>
 37 #include <linux/bitops.h>
 38 #include <net/arp.h>
 39 
 40 #include <asm/byteorder.h>
 41 
 42 #include <net/irda/irda.h>
 43 #include <net/irda/irttp.h>
 44 #include <net/irda/irlmp.h>
 45 #include <net/irda/irias_object.h>
 46 #include <net/irda/iriap.h>
 47 #include <net/irda/timer.h>
 48 
 49 #include <net/irda/irlan_common.h>
 50 #include <net/irda/irlan_event.h>
 51 #include <net/irda/irlan_eth.h>
 52 #include <net/irda/irlan_provider.h>
 53 #include <net/irda/irlan_client.h>
 54 
 55 #undef CONFIG_IRLAN_GRATUITOUS_ARP
 56 
 57 static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
 58                                                     LM_REASON reason,
 59                                                     struct sk_buff *);
 60 static int irlan_client_ctrl_data_indication(void *instance, void *sap,
 61                                              struct sk_buff *skb);
 62 static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
 63                                               struct qos_info *qos,
 64                                               __u32 max_sdu_size,
 65                                               __u8 max_header_size,
 66                                               struct sk_buff *);
 67 static void irlan_check_response_param(struct irlan_cb *self, char *param,
 68                                        char *value, int val_len);
 69 static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
 70 
 71 static void irlan_client_kick_timer_expired(void *data)
 72 {
 73         struct irlan_cb *self = (struct irlan_cb *) data;
 74 
 75         IRDA_DEBUG(2, "%s()\n", __func__ );
 76 
 77         IRDA_ASSERT(self != NULL, return;);
 78         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
 79 
 80         /*
 81          * If we are in peer mode, the client may not have got the discovery
 82          * indication it needs to make progress. If the client is still in
 83          * IDLE state, we must kick it to, but only if the provider is not IDLE
 84          */
 85         if ((self->provider.access_type == ACCESS_PEER) &&
 86             (self->client.state == IRLAN_IDLE) &&
 87             (self->provider.state != IRLAN_IDLE)) {
 88                 irlan_client_wakeup(self, self->saddr, self->daddr);
 89         }
 90 }
 91 
 92 static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
 93 {
 94         IRDA_DEBUG(4, "%s()\n", __func__ );
 95 
 96         irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
 97                          irlan_client_kick_timer_expired);
 98 }
 99 
100 /*
101  * Function irlan_client_wakeup (self, saddr, daddr)
102  *
103  *    Wake up client
104  *
105  */
106 void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr)
107 {
108         IRDA_DEBUG(1, "%s()\n", __func__ );
109 
110         IRDA_ASSERT(self != NULL, return;);
111         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
112 
113         /*
114          * Check if we are already awake, or if we are a provider in direct
115          * mode (in that case we must leave the client idle
116          */
117         if ((self->client.state != IRLAN_IDLE) ||
118             (self->provider.access_type == ACCESS_DIRECT))
119         {
120                         IRDA_DEBUG(0, "%s(), already awake!\n", __func__ );
121                         return;
122         }
123 
124         /* Addresses may have changed! */
125         self->saddr = saddr;
126         self->daddr = daddr;
127 
128         if (self->disconnect_reason == LM_USER_REQUEST) {
129                         IRDA_DEBUG(0, "%s(), still stopped by user\n", __func__ );
130                         return;
131         }
132 
133         /* Open TSAPs */
134         irlan_client_open_ctrl_tsap(self);
135         irlan_open_data_tsap(self);
136 
137         irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);
138 
139         /* Start kick timer */
140         irlan_client_start_kick_timer(self, 2*HZ);
141 }
142 
143 /*
144  * Function irlan_discovery_indication (daddr)
145  *
146  *    Remote device with IrLAN server support discovered
147  *
148  */
149 void irlan_client_discovery_indication(discinfo_t *discovery,
150                                        DISCOVERY_MODE mode,
151                                        void *priv)
152 {
153         struct irlan_cb *self;
154         __u32 saddr, daddr;
155 
156         IRDA_DEBUG(1, "%s()\n", __func__ );
157 
158         IRDA_ASSERT(discovery != NULL, return;);
159 
160         /*
161          * I didn't check it, but I bet that IrLAN suffer from the same
162          * deficiency as IrComm and doesn't handle two instances
163          * simultaneously connecting to each other.
164          * Same workaround, drop passive discoveries.
165          * Jean II */
166         if(mode == DISCOVERY_PASSIVE)
167                 return;
168 
169         saddr = discovery->saddr;
170         daddr = discovery->daddr;
171 
172         /* Find instance */
173         rcu_read_lock();
174         self = irlan_get_any();
175         if (self) {
176                 IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;);
177 
178                 IRDA_DEBUG(1, "%s(), Found instance (%08x)!\n", __func__ ,
179                       daddr);
180 
181                 irlan_client_wakeup(self, saddr, daddr);
182         }
183 IRDA_ASSERT_LABEL(out:)
184         rcu_read_unlock();
185 }
186 
187 /*
188  * Function irlan_client_data_indication (handle, skb)
189  *
190  *    This function gets the data that is received on the control channel
191  *
192  */
193 static int irlan_client_ctrl_data_indication(void *instance, void *sap,
194                                              struct sk_buff *skb)
195 {
196         struct irlan_cb *self;
197 
198         IRDA_DEBUG(2, "%s()\n", __func__ );
199 
200         self = instance;
201 
202         IRDA_ASSERT(self != NULL, return -1;);
203         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
204         IRDA_ASSERT(skb != NULL, return -1;);
205 
206         irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);
207 
208         /* Ready for a new command */
209         IRDA_DEBUG(2, "%s(), clearing tx_busy\n", __func__ );
210         self->client.tx_busy = FALSE;
211 
212         /* Check if we have some queued commands waiting to be sent */
213         irlan_run_ctrl_tx_queue(self);
214 
215         return 0;
216 }
217 
218 static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
219                                                     LM_REASON reason,
220                                                     struct sk_buff *userdata)
221 {
222         struct irlan_cb *self;
223         struct tsap_cb *tsap;
224         struct sk_buff *skb;
225 
226         IRDA_DEBUG(4, "%s(), reason=%d\n", __func__ , reason);
227 
228         self = instance;
229         tsap = sap;
230 
231         IRDA_ASSERT(self != NULL, return;);
232         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
233         IRDA_ASSERT(tsap != NULL, return;);
234         IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
235 
236         IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;);
237 
238         /* Remove frames queued on the control channel */
239         while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
240                 dev_kfree_skb(skb);
241         }
242         self->client.tx_busy = FALSE;
243 
244         irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
245 }
246 
247 /*
248  * Function irlan_client_open_tsaps (self)
249  *
250  *    Initialize callbacks and open IrTTP TSAPs
251  *
252  */
253 static void irlan_client_open_ctrl_tsap(struct irlan_cb *self)
254 {
255         struct tsap_cb *tsap;
256         notify_t notify;
257 
258         IRDA_DEBUG(4, "%s()\n", __func__ );
259 
260         IRDA_ASSERT(self != NULL, return;);
261         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
262 
263         /* Check if already open */
264         if (self->client.tsap_ctrl)
265                 return;
266 
267         irda_notify_init(&notify);
268 
269         /* Set up callbacks */
270         notify.data_indication       = irlan_client_ctrl_data_indication;
271         notify.connect_confirm       = irlan_client_ctrl_connect_confirm;
272         notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
273         notify.instance = self;
274         strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));
275 
276         tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
277         if (!tsap) {
278                 IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__ );
279                 return;
280         }
281         self->client.tsap_ctrl = tsap;
282 }
283 
284 /*
285  * Function irlan_client_connect_confirm (handle, skb)
286  *
287  *    Connection to peer IrLAN laye confirmed
288  *
289  */
290 static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
291                                               struct qos_info *qos,
292                                               __u32 max_sdu_size,
293                                               __u8 max_header_size,
294                                               struct sk_buff *skb)
295 {
296         struct irlan_cb *self;
297 
298         IRDA_DEBUG(4, "%s()\n", __func__ );
299 
300         self = instance;
301 
302         IRDA_ASSERT(self != NULL, return;);
303         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
304 
305         self->client.max_sdu_size = max_sdu_size;
306         self->client.max_header_size = max_header_size;
307 
308         /* TODO: we could set the MTU depending on the max_sdu_size */
309 
310         irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL);
311 }
312 
313 /*
314  * Function print_ret_code (code)
315  *
316  *    Print return code of request to peer IrLAN layer.
317  *
318  */
319 static void print_ret_code(__u8 code)
320 {
321         switch(code) {
322         case 0:
323                 printk(KERN_INFO "Success\n");
324                 break;
325         case 1:
326                 IRDA_WARNING("IrLAN: Insufficient resources\n");
327                 break;
328         case 2:
329                 IRDA_WARNING("IrLAN: Invalid command format\n");
330                 break;
331         case 3:
332                 IRDA_WARNING("IrLAN: Command not supported\n");
333                 break;
334         case 4:
335                 IRDA_WARNING("IrLAN: Parameter not supported\n");
336                 break;
337         case 5:
338                 IRDA_WARNING("IrLAN: Value not supported\n");
339                 break;
340         case 6:
341                 IRDA_WARNING("IrLAN: Not open\n");
342                 break;
343         case 7:
344                 IRDA_WARNING("IrLAN: Authentication required\n");
345                 break;
346         case 8:
347                 IRDA_WARNING("IrLAN: Invalid password\n");
348                 break;
349         case 9:
350                 IRDA_WARNING("IrLAN: Protocol error\n");
351                 break;
352         case 255:
353                 IRDA_WARNING("IrLAN: Asynchronous status\n");
354                 break;
355         }
356 }
357 
358 /*
359  * Function irlan_client_parse_response (self, skb)
360  *
361  *    Extract all parameters from received buffer, then feed them to
362  *    check_params for parsing
363  */
364 void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb)
365 {
366         __u8 *frame;
367         __u8 *ptr;
368         int count;
369         int ret;
370         __u16 val_len;
371         int i;
372         char *name;
373         char *value;
374 
375         IRDA_ASSERT(skb != NULL, return;);
376 
377         IRDA_DEBUG(4, "%s() skb->len=%d\n", __func__ , (int) skb->len);
378 
379         IRDA_ASSERT(self != NULL, return;);
380         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
381 
382         if (!skb) {
383                 IRDA_ERROR("%s(), Got NULL skb!\n", __func__);
384                 return;
385         }
386         frame = skb->data;
387 
388         /*
389          *  Check return code and print it if not success
390          */
391         if (frame[0]) {
392                 print_ret_code(frame[0]);
393                 return;
394         }
395 
396         name = kmalloc(255, GFP_ATOMIC);
397         if (!name)
398                 return;
399         value = kmalloc(1016, GFP_ATOMIC);
400         if (!value) {
401                 kfree(name);
402                 return;
403         }
404 
405         /* How many parameters? */
406         count = frame[1];
407 
408         IRDA_DEBUG(4, "%s(), got %d parameters\n", __func__ , count);
409 
410         ptr = frame+2;
411 
412         /* For all parameters */
413         for (i=0; i<count;i++) {
414                 ret = irlan_extract_param(ptr, name, value, &val_len);
415                 if (ret < 0) {
416                         IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __func__ );
417                         break;
418                 }
419                 ptr += ret;
420                 irlan_check_response_param(self, name, value, val_len);
421         }
422         /* Cleanup */
423         kfree(name);
424         kfree(value);
425 }
426 
427 /*
428  * Function irlan_check_response_param (self, param, value, val_len)
429  *
430  *     Check which parameter is received and update local variables
431  *
432  */
433 static void irlan_check_response_param(struct irlan_cb *self, char *param,
434                                        char *value, int val_len)
435 {
436         __u16 tmp_cpu; /* Temporary value in host order */
437         __u8 *bytes;
438         int i;
439 
440         IRDA_DEBUG(4, "%s(), parm=%s\n", __func__ , param);
441 
442         IRDA_ASSERT(self != NULL, return;);
443         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
444 
445         /* Media type */
446         if (strcmp(param, "MEDIA") == 0) {
447                 if (strcmp(value, "802.3") == 0)
448                         self->media = MEDIA_802_3;
449                 else
450                         self->media = MEDIA_802_5;
451                 return;
452         }
453         if (strcmp(param, "FILTER_TYPE") == 0) {
454                 if (strcmp(value, "DIRECTED") == 0)
455                         self->client.filter_type |= IRLAN_DIRECTED;
456                 else if (strcmp(value, "FUNCTIONAL") == 0)
457                         self->client.filter_type |= IRLAN_FUNCTIONAL;
458                 else if (strcmp(value, "GROUP") == 0)
459                         self->client.filter_type |= IRLAN_GROUP;
460                 else if (strcmp(value, "MAC_FRAME") == 0)
461                         self->client.filter_type |= IRLAN_MAC_FRAME;
462                 else if (strcmp(value, "MULTICAST") == 0)
463                         self->client.filter_type |= IRLAN_MULTICAST;
464                 else if (strcmp(value, "BROADCAST") == 0)
465                         self->client.filter_type |= IRLAN_BROADCAST;
466                 else if (strcmp(value, "IPX_SOCKET") == 0)
467                         self->client.filter_type |= IRLAN_IPX_SOCKET;
468 
469         }
470         if (strcmp(param, "ACCESS_TYPE") == 0) {
471                 if (strcmp(value, "DIRECT") == 0)
472                         self->client.access_type = ACCESS_DIRECT;
473                 else if (strcmp(value, "PEER") == 0)
474                         self->client.access_type = ACCESS_PEER;
475                 else if (strcmp(value, "HOSTED") == 0)
476                         self->client.access_type = ACCESS_HOSTED;
477                 else {
478                         IRDA_DEBUG(2, "%s(), unknown access type!\n", __func__ );
479                 }
480         }
481         /* IRLAN version */
482         if (strcmp(param, "IRLAN_VER") == 0) {
483                 IRDA_DEBUG(4, "IrLAN version %d.%d\n", (__u8) value[0],
484                       (__u8) value[1]);
485 
486                 self->version[0] = value[0];
487                 self->version[1] = value[1];
488                 return;
489         }
490         /* Which remote TSAP to use for data channel */
491         if (strcmp(param, "DATA_CHAN") == 0) {
492                 self->dtsap_sel_data = value[0];
493                 IRDA_DEBUG(4, "Data TSAP = %02x\n", self->dtsap_sel_data);
494                 return;
495         }
496         if (strcmp(param, "CON_ARB") == 0) {
497                 memcpy(&tmp_cpu, value, 2); /* Align value */
498                 le16_to_cpus(&tmp_cpu);     /* Convert to host order */
499                 self->client.recv_arb_val = tmp_cpu;
500                 IRDA_DEBUG(2, "%s(), receive arb val=%d\n", __func__ ,
501                            self->client.recv_arb_val);
502         }
503         if (strcmp(param, "MAX_FRAME") == 0) {
504                 memcpy(&tmp_cpu, value, 2); /* Align value */
505                 le16_to_cpus(&tmp_cpu);     /* Convert to host order */
506                 self->client.max_frame = tmp_cpu;
507                 IRDA_DEBUG(4, "%s(), max frame=%d\n", __func__ ,
508                            self->client.max_frame);
509         }
510 
511         /* RECONNECT_KEY, in case the link goes down! */
512         if (strcmp(param, "RECONNECT_KEY") == 0) {
513                 IRDA_DEBUG(4, "Got reconnect key: ");
514                 /* for (i = 0; i < val_len; i++) */
515 /*                      printk("%02x", value[i]); */
516                 memcpy(self->client.reconnect_key, value, val_len);
517                 self->client.key_len = val_len;
518                 IRDA_DEBUG(4, "\n");
519         }
520         /* FILTER_ENTRY, have we got an ethernet address? */
521         if (strcmp(param, "FILTER_ENTRY") == 0) {
522                 bytes = value;
523                 IRDA_DEBUG(4, "Ethernet address = %pM\n", bytes);
524                 for (i = 0; i < 6; i++)
525                         self->dev->dev_addr[i] = bytes[i];
526         }
527 }
528 
529 /*
530  * Function irlan_client_get_value_confirm (obj_id, value)
531  *
532  *    Got results from remote LM-IAS
533  *
534  */
535 void irlan_client_get_value_confirm(int result, __u16 obj_id,
536                                     struct ias_value *value, void *priv)
537 {
538         struct irlan_cb *self;
539 
540         IRDA_DEBUG(4, "%s()\n", __func__ );
541 
542         IRDA_ASSERT(priv != NULL, return;);
543 
544         self = priv;
545         IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
546 
547         /* We probably don't need to make any more queries */
548         iriap_close(self->client.iriap);
549         self->client.iriap = NULL;
550 
551         /* Check if request succeeded */
552         if (result != IAS_SUCCESS) {
553                 IRDA_DEBUG(2, "%s(), got NULL value!\n", __func__ );
554                 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
555                                       NULL);
556                 return;
557         }
558 
559         switch (value->type) {
560         case IAS_INTEGER:
561                 self->dtsap_sel_ctrl = value->t.integer;
562 
563                 if (value->t.integer != -1) {
564                         irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL,
565                                               NULL);
566                         return;
567                 }
568                 irias_delete_value(value);
569                 break;
570         default:
571                 IRDA_DEBUG(2, "%s(), unknown type!\n", __func__ );
572                 break;
573         }
574         irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL);
575 }
576 

~ [ 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