PageRenderTime 74ms CodeModel.GetById 13ms app.highlight 55ms RepoModel.GetById 2ms app.codeStats 0ms

/net/irda/irlan/irlan_client.c

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