[mirror_ubuntu-artful-kernel.git] / net / irda / irlan / irlan_provider.c

/*********************************************************************
 *
 * Filename:      irlan_provider.c
 * Version:       0.9
 * Description:   IrDA LAN Access Protocol Implementation
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Sun Aug 31 20:14:37 1997
 * Modified at:   Sat Oct 30 12:52:10 1999
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 * Sources:       skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
 *                slip.c by Laurence Culhane,   <loz@holmes.demon.co.uk>
 *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 *
 *     Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
 *     All Rights Reserved.
 *
 *     This program is free software; you can redistribute it and/or
 *     modify it under the terms of the GNU General Public License as
 *     published by the Free Software Foundation; either version 2 of
 *     the License, or (at your option) any later version.
 *
 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 *     provide warranty for any of this software. This material is
 *     provided "AS-IS" and at no charge.
 *
 ********************************************************************/

#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/init.h>
#include <linux/random.h>
#include <linux/bitops.h>
#include <linux/slab.h>

#include <asm/system.h>
#include <asm/byteorder.h>

#include <net/irda/irda.h>
#include <net/irda/irttp.h>
#include <net/irda/irlmp.h>
#include <net/irda/irias_object.h>
#include <net/irda/iriap.h>
#include <net/irda/timer.h>

#include <net/irda/irlan_common.h>
#include <net/irda/irlan_eth.h>
#include <net/irda/irlan_event.h>
#include <net/irda/irlan_provider.h>
#include <net/irda/irlan_filter.h>
#include <net/irda/irlan_client.h>

static void irlan_provider_connect_indication(void *instance, void *sap,
					      struct qos_info *qos,
					      __u32 max_sdu_size,
					      __u8 max_header_size,
					      struct sk_buff *skb);

/*
 * Function irlan_provider_control_data_indication (handle, skb)
 *
 *    This function gets the data that is received on the control channel
 *
 */
static int irlan_provider_data_indication(void *instance, void *sap,
					  struct sk_buff *skb)
{
	struct irlan_cb *self;
	__u8 code;

	IRDA_DEBUG(4, "%s()\n", __func__ );

	self = (struct irlan_cb *) instance;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);

	IRDA_ASSERT(skb != NULL, return -1;);

	code = skb->data[0];
	switch(code) {
	case CMD_GET_PROVIDER_INFO:
		IRDA_DEBUG(4, "Got GET_PROVIDER_INFO command!\n");
		irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
		break;

	case CMD_GET_MEDIA_CHAR:
		IRDA_DEBUG(4, "Got GET_MEDIA_CHAR command!\n");
		irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
		break;
	case CMD_OPEN_DATA_CHANNEL:
		IRDA_DEBUG(4, "Got OPEN_DATA_CHANNEL command!\n");
		irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
		break;
	case CMD_FILTER_OPERATION:
		IRDA_DEBUG(4, "Got FILTER_OPERATION command!\n");
		irlan_do_provider_event(self, IRLAN_FILTER_CONFIG_CMD, skb);
		break;
	case CMD_RECONNECT_DATA_CHAN:
		IRDA_DEBUG(2, "%s(), Got RECONNECT_DATA_CHAN command\n", __func__ );
		IRDA_DEBUG(2, "%s(), NOT IMPLEMENTED\n", __func__ );
		break;
	case CMD_CLOSE_DATA_CHAN:
		IRDA_DEBUG(2, "Got CLOSE_DATA_CHAN command!\n");
		IRDA_DEBUG(2, "%s(), NOT IMPLEMENTED\n", __func__ );
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown command!\n", __func__ );
		break;
	}
	return 0;
}

/*
 * Function irlan_provider_connect_indication (handle, skb, priv)
 *
 *    Got connection from peer IrLAN client
 *
 */
static void irlan_provider_connect_indication(void *instance, void *sap,
					      struct qos_info *qos,
					      __u32 max_sdu_size,
					      __u8 max_header_size,
					      struct sk_buff *skb)
{
	struct irlan_cb *self;
	struct tsap_cb *tsap;
	__u32 saddr, daddr;

	IRDA_DEBUG(0, "%s()\n", __func__ );

	self = (struct irlan_cb *) instance;
	tsap = (struct tsap_cb *) sap;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;);
	IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;);

	daddr = irttp_get_daddr(tsap);
	saddr = irttp_get_saddr(tsap);
	self->provider.max_sdu_size = max_sdu_size;
	self->provider.max_header_size = max_header_size;

	irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL);

	/*
	 * If we are in peer mode, the client may not have got the discovery
	 * indication it needs to make progress. If the client is still in
	 * IDLE state, we must kick it.
	 */
	if ((self->provider.access_type == ACCESS_PEER) &&
	    (self->client.state == IRLAN_IDLE))
	{
		irlan_client_wakeup(self, self->saddr, self->daddr);
	}
}

/*
 * Function irlan_provider_connect_response (handle)
 *
 *    Accept incoming connection
 *
 */
void irlan_provider_connect_response(struct irlan_cb *self,
				     struct tsap_cb *tsap)
{
	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	/* Just accept */
	irttp_connect_response(tsap, IRLAN_MTU, NULL);
}

static void irlan_provider_disconnect_indication(void *instance, void *sap,
						 LM_REASON reason,
						 struct sk_buff *userdata)
{
	struct irlan_cb *self;
	struct tsap_cb *tsap;

	IRDA_DEBUG(4, "%s(), reason=%d\n", __func__ , reason);

	self = (struct irlan_cb *) instance;
	tsap = (struct tsap_cb *) sap;

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	IRDA_ASSERT(tsap != NULL, return;);
	IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);

	IRDA_ASSERT(tsap == self->provider.tsap_ctrl, return;);

	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
}

/*
 * Function irlan_parse_open_data_cmd (self, skb)
 *
 *
 *
 */
int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb)
{
	int ret;

	ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb);

	/* Open data channel */
	irlan_open_data_tsap(self);

	return ret;
}

/*
 * Function parse_command (skb)
 *
 *    Extract all parameters from received buffer, then feed them to
 *    check_params for parsing
 *
 */
int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
				 struct sk_buff *skb)
{
	__u8 *frame;
	__u8 *ptr;
	int count;
	__u16 val_len;
	int i;
	char *name;
	char *value;
	int ret = RSP_SUCCESS;

	IRDA_ASSERT(skb != NULL, return -RSP_PROTOCOL_ERROR;);

	IRDA_DEBUG(4, "%s(), skb->len=%d\n", __func__ , (int)skb->len);

	IRDA_ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;);

	if (!skb)
		return -RSP_PROTOCOL_ERROR;

	frame = skb->data;

	name = kmalloc(255, GFP_ATOMIC);
	if (!name)
		return -RSP_INSUFFICIENT_RESOURCES;
	value = kmalloc(1016, GFP_ATOMIC);
	if (!value) {
		kfree(name);
		return -RSP_INSUFFICIENT_RESOURCES;
	}

	/* How many parameters? */
	count = frame[1];

	IRDA_DEBUG(4, "Got %d parameters\n", count);

	ptr = frame+2;

	/* For all parameters */
	for (i=0; i<count;i++) {
		ret = irlan_extract_param(ptr, name, value, &val_len);
		if (ret < 0) {
			IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __func__ );
			break;
		}
		ptr+=ret;
		ret = RSP_SUCCESS;
		irlan_check_command_param(self, name, value);
	}
	/* Cleanup */
	kfree(name);
	kfree(value);

	return ret;
}

/*
 * Function irlan_provider_send_reply (self, info)
 *
 *    Send reply to query to peer IrLAN layer
 *
 */
void irlan_provider_send_reply(struct irlan_cb *self, int command,
			       int ret_code)
{
	struct sk_buff *skb;

	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);

	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
			/* Bigger param length comes from CMD_GET_MEDIA_CHAR */
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BORADCAST") +
			IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
			IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "HOSTED"),
			GFP_ATOMIC);

	if (!skb)
		return;

	/* Reserve space for TTP, LMP, and LAP header */
	skb_reserve(skb, self->provider.max_header_size);
	skb_put(skb, 2);

	switch (command) {
	case CMD_GET_PROVIDER_INFO:
		skb->data[0] = 0x00; /* Success */
		skb->data[1] = 0x02; /* 2 parameters */
		switch (self->media) {
		case MEDIA_802_3:
			irlan_insert_string_param(skb, "MEDIA", "802.3");
			break;
		case MEDIA_802_5:
			irlan_insert_string_param(skb, "MEDIA", "802.5");
			break;
		default:
			IRDA_DEBUG(2, "%s(), unknown media type!\n", __func__ );
			break;
		}
		irlan_insert_short_param(skb, "IRLAN_VER", 0x0101);
		break;

	case CMD_GET_MEDIA_CHAR:
		skb->data[0] = 0x00; /* Success */
		skb->data[1] = 0x05; /* 5 parameters */
		irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
		irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
		irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");

		switch (self->provider.access_type) {
		case ACCESS_DIRECT:
			irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
			break;
		case ACCESS_PEER:
			irlan_insert_string_param(skb, "ACCESS_TYPE", "PEER");
			break;
		case ACCESS_HOSTED:
			irlan_insert_string_param(skb, "ACCESS_TYPE", "HOSTED");
			break;
		default:
			IRDA_DEBUG(2, "%s(), Unknown access type\n", __func__ );
			break;
		}
		irlan_insert_short_param(skb, "MAX_FRAME", 0x05ee);
		break;
	case CMD_OPEN_DATA_CHANNEL:
		skb->data[0] = 0x00; /* Success */
		if (self->provider.send_arb_val) {
			skb->data[1] = 0x03; /* 3 parameters */
			irlan_insert_short_param(skb, "CON_ARB",
						 self->provider.send_arb_val);
		} else
			skb->data[1] = 0x02; /* 2 parameters */
		irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data);
		irlan_insert_string_param(skb, "RECONNECT_KEY", "LINUX RULES!");
		break;
	case CMD_FILTER_OPERATION:
		irlan_filter_request(self, skb);
		break;
	default:
		IRDA_DEBUG(2, "%s(), Unknown command!\n", __func__ );
		break;
	}

	irttp_data_request(self->provider.tsap_ctrl, skb);
}

/*
 * Function irlan_provider_register(void)
 *
 *    Register provider support so we can accept incoming connections.
 *
 */
int irlan_provider_open_ctrl_tsap(struct irlan_cb *self)
{
	struct tsap_cb *tsap;
	notify_t notify;

	IRDA_DEBUG(4, "%s()\n", __func__ );

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);

	/* Check if already open */
	if (self->provider.tsap_ctrl)
		return -1;

	/*
	 *  First register well known control TSAP
	 */
	irda_notify_init(&notify);
	notify.data_indication       = irlan_provider_data_indication;
	notify.connect_indication    = irlan_provider_connect_indication;
	notify.disconnect_indication = irlan_provider_disconnect_indication;
	notify.instance = self;
	strlcpy(notify.name, "IrLAN ctrl (p)", sizeof(notify.name));

	tsap = irttp_open_tsap(LSAP_ANY, 1, &notify);
	if (!tsap) {
		IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__ );
		return -1;
	}
	self->provider.tsap_ctrl = tsap;

	/* Register with LM-IAS */
	irlan_ias_register(self, tsap->stsap_sel);

	return 0;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4 LT	3	* Filename: irlan_provider.c
	4	* Version: 0.9
	5	* Description: IrDA LAN Access Protocol Implementation
	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Sun Aug 31 20:14:37 1997
	9	* Modified at: Sat Oct 30 12:52:10 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>
6819bc2e YH	14	*
6819bc2e YH	15	* Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
1da177e4	16	* All Rights Reserved.
6819bc2e YH	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
1da177e4 LT	21	* the License, or (at your option) any later version.
1da177e4 LT	22	*
96de0e25	23	* Neither Dag Brattli nor University of Tromsø admit liability nor
6819bc2e	24	* provide warranty for any of this software. This material is
1da177e4 LT	25	* provided "AS-IS" and at no charge.
	26	*
	27	********************************************************************/
	28
	29	#include <linux/kernel.h>
	30	#include <linux/string.h>
	31	#include <linux/errno.h>
	32	#include <linux/netdevice.h>
	33	#include <linux/etherdevice.h>
	34	#include <linux/init.h>
	35	#include <linux/random.h>
	36	#include <linux/bitops.h>
5a0e3ad6	37	#include <linux/slab.h>
1da177e4 LT	38
	39	#include <asm/system.h>
	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_eth.h>
	51	#include <net/irda/irlan_event.h>
	52	#include <net/irda/irlan_provider.h>
	53	#include <net/irda/irlan_filter.h>
	54	#include <net/irda/irlan_client.h>
	55
6819bc2e YH	56	static void irlan_provider_connect_indication(void instance, void sap,
6819bc2e YH	57	struct qos_info *qos,
1da177e4 LT	58	__u32 max_sdu_size,
	59	__u8 max_header_size,
	60	struct sk_buff *skb);
	61
	62	/*
	63	* Function irlan_provider_control_data_indication (handle, skb)
	64	*
	65	* This function gets the data that is received on the control channel
	66	*
	67	*/
6819bc2e YH	68	static int irlan_provider_data_indication(void instance, void sap,
6819bc2e YH	69	struct sk_buff *skb)
1da177e4 LT	70	{
	71	struct irlan_cb *self;
	72	__u8 code;
6819bc2e	73
0dc47877	74	IRDA_DEBUG(4, "%s()\n", __func__ );
6819bc2e	75
1da177e4 LT	76	self = (struct irlan_cb *) instance;
	77
	78	IRDA_ASSERT(self != NULL, return -1;);
	79	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	80
	81	IRDA_ASSERT(skb != NULL, return -1;);
	82
	83	code = skb->data[0];
	84	switch(code) {
	85	case CMD_GET_PROVIDER_INFO:
	86	IRDA_DEBUG(4, "Got GET_PROVIDER_INFO command!\n");
6819bc2e	87	irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
1da177e4 LT	88	break;
	89
	90	case CMD_GET_MEDIA_CHAR:
	91	IRDA_DEBUG(4, "Got GET_MEDIA_CHAR command!\n");
6819bc2e	92	irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
1da177e4 LT	93	break;
	94	case CMD_OPEN_DATA_CHANNEL:
	95	IRDA_DEBUG(4, "Got OPEN_DATA_CHANNEL command!\n");
6819bc2e	96	irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
1da177e4 LT	97	break;
	98	case CMD_FILTER_OPERATION:
	99	IRDA_DEBUG(4, "Got FILTER_OPERATION command!\n");
	100	irlan_do_provider_event(self, IRLAN_FILTER_CONFIG_CMD, skb);
	101	break;
	102	case CMD_RECONNECT_DATA_CHAN:
0dc47877 HH	103	IRDA_DEBUG(2, "%s(), Got RECONNECT_DATA_CHAN command\n", __func__ );
0dc47877 HH	104	IRDA_DEBUG(2, "%s(), NOT IMPLEMENTED\n", __func__ );
1da177e4 LT	105	break;
	106	case CMD_CLOSE_DATA_CHAN:
	107	IRDA_DEBUG(2, "Got CLOSE_DATA_CHAN command!\n");
0dc47877	108	IRDA_DEBUG(2, "%s(), NOT IMPLEMENTED\n", __func__ );
1da177e4 LT	109	break;
1da177e4 LT	110	default:
0dc47877	111	IRDA_DEBUG(2, "%s(), Unknown command!\n", __func__ );
1da177e4 LT	112	break;
	113	}
	114	return 0;
	115	}
	116
	117	/*
	118	* Function irlan_provider_connect_indication (handle, skb, priv)
	119	*
	120	* Got connection from peer IrLAN client
	121	*
	122	*/
6819bc2e	123	static void irlan_provider_connect_indication(void instance, void sap,
1da177e4	124	struct qos_info *qos,
6819bc2e	125	__u32 max_sdu_size,
1da177e4 LT	126	__u8 max_header_size,
	127	struct sk_buff *skb)
	128	{
	129	struct irlan_cb *self;
	130	struct tsap_cb *tsap;
	131	__u32 saddr, daddr;
	132
0dc47877	133	IRDA_DEBUG(0, "%s()\n", __func__ );
6819bc2e	134
1da177e4 LT	135	self = (struct irlan_cb *) instance;
1da177e4 LT	136	tsap = (struct tsap_cb *) sap;
6819bc2e	137
1da177e4 LT	138	IRDA_ASSERT(self != NULL, return;);
1da177e4 LT	139	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
6819bc2e	140
1da177e4 LT	141	IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;);
	142	IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;);
	143
	144	daddr = irttp_get_daddr(tsap);
	145	saddr = irttp_get_saddr(tsap);
	146	self->provider.max_sdu_size = max_sdu_size;
	147	self->provider.max_header_size = max_header_size;
	148
	149	irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL);
	150
6819bc2e	151	/*
1da177e4	152	* If we are in peer mode, the client may not have got the discovery
6819bc2e YH	153	* indication it needs to make progress. If the client is still in
6819bc2e YH	154	* IDLE state, we must kick it.
1da177e4	155	*/
6819bc2e YH	156	if ((self->provider.access_type == ACCESS_PEER) &&
6819bc2e YH	157	(self->client.state == IRLAN_IDLE))
1da177e4 LT	158	{
	159	irlan_client_wakeup(self, self->saddr, self->daddr);
	160	}
	161	}
	162
	163	/*
	164	* Function irlan_provider_connect_response (handle)
	165	*
	166	* Accept incoming connection
	167	*
	168	*/
	169	void irlan_provider_connect_response(struct irlan_cb *self,
	170	struct tsap_cb *tsap)
	171	{
	172	IRDA_ASSERT(self != NULL, return;);
	173	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	174
	175	/* Just accept */
	176	irttp_connect_response(tsap, IRLAN_MTU, NULL);
	177	}
	178
6819bc2e YH	179	static void irlan_provider_disconnect_indication(void instance, void sap,
	180	LM_REASON reason,
	181	struct sk_buff *userdata)
1da177e4 LT	182	{
	183	struct irlan_cb *self;
	184	struct tsap_cb *tsap;
	185
0dc47877	186	IRDA_DEBUG(4, "%s(), reason=%d\n", __func__ , reason);
6819bc2e	187
1da177e4 LT	188	self = (struct irlan_cb *) instance;
	189	tsap = (struct tsap_cb *) sap;
	190
	191	IRDA_ASSERT(self != NULL, return;);
6819bc2e	192	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
1da177e4 LT	193	IRDA_ASSERT(tsap != NULL, return;);
1da177e4 LT	194	IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
6819bc2e	195
1da177e4	196	IRDA_ASSERT(tsap == self->provider.tsap_ctrl, return;);
6819bc2e	197
1da177e4 LT	198	irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
	199	}
	200
	201	/*
	202	* Function irlan_parse_open_data_cmd (self, skb)
	203	*
6819bc2e	204	*
1da177e4 LT	205	*
	206	*/
	207	int irlan_parse_open_data_cmd(struct irlan_cb self, struct sk_buff skb)
	208	{
	209	int ret;
6819bc2e	210
1da177e4 LT	211	ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb);
	212
	213	/* Open data channel */
	214	irlan_open_data_tsap(self);
	215
	216	return ret;
	217	}
	218
	219	/*
	220	* Function parse_command (skb)
	221	*
6819bc2e	222	* Extract all parameters from received buffer, then feed them to
1da177e4 LT	223	* check_params for parsing
	224	*
	225	*/
	226	int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
6819bc2e	227	struct sk_buff *skb)
1da177e4 LT	228	{
	229	__u8 *frame;
	230	__u8 *ptr;
	231	int count;
	232	__u16 val_len;
	233	int i;
	234	char *name;
6819bc2e	235	char *value;
1da177e4	236	int ret = RSP_SUCCESS;
6819bc2e	237
1da177e4	238	IRDA_ASSERT(skb != NULL, return -RSP_PROTOCOL_ERROR;);
6819bc2e	239
0dc47877	240	IRDA_DEBUG(4, "%s(), skb->len=%d\n", __func__ , (int)skb->len);
1da177e4 LT	241
	242	IRDA_ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;);
	243	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;);
6819bc2e	244
1da177e4 LT	245	if (!skb)
	246	return -RSP_PROTOCOL_ERROR;
	247
	248	frame = skb->data;
	249
	250	name = kmalloc(255, GFP_ATOMIC);
	251	if (!name)
	252	return -RSP_INSUFFICIENT_RESOURCES;
	253	value = kmalloc(1016, GFP_ATOMIC);
	254	if (!value) {
	255	kfree(name);
	256	return -RSP_INSUFFICIENT_RESOURCES;
	257	}
	258
	259	/* How many parameters? */
	260	count = frame[1];
	261
	262	IRDA_DEBUG(4, "Got %d parameters\n", count);
6819bc2e	263
1da177e4	264	ptr = frame+2;
6819bc2e	265
1da177e4	266	/* For all parameters */
6819bc2e	267	for (i=0; i<count;i++) {
1da177e4 LT	268	ret = irlan_extract_param(ptr, name, value, &val_len);
1da177e4 LT	269	if (ret < 0) {
0dc47877	270	IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __func__ );
1da177e4 LT	271	break;
	272	}
	273	ptr+=ret;
	274	ret = RSP_SUCCESS;
	275	irlan_check_command_param(self, name, value);
	276	}
	277	/* Cleanup */
	278	kfree(name);
	279	kfree(value);
	280
	281	return ret;
	282	}
	283
	284	/*
	285	* Function irlan_provider_send_reply (self, info)
	286	*
	287	* Send reply to query to peer IrLAN layer
	288	*
	289	*/
6819bc2e	290	void irlan_provider_send_reply(struct irlan_cb *self, int command,
1da177e4 LT	291	int ret_code)
	292	{
	293	struct sk_buff *skb;
	294
0dc47877	295	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	296
	297	IRDA_ASSERT(self != NULL, return;);
	298	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
	299
1b0fee7d SO	300	skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
	301	/* Bigger param length comes from CMD_GET_MEDIA_CHAR */
	302	IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
	303	IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BORADCAST") +
	304	IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
	305	IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "HOSTED"),
	306	GFP_ATOMIC);
	307
1da177e4 LT	308	if (!skb)
	309	return;
	310
	311	/* Reserve space for TTP, LMP, and LAP header */
	312	skb_reserve(skb, self->provider.max_header_size);
	313	skb_put(skb, 2);
6819bc2e	314
1da177e4 LT	315	switch (command) {
	316	case CMD_GET_PROVIDER_INFO:
	317	skb->data[0] = 0x00; /* Success */
	318	skb->data[1] = 0x02; /* 2 parameters */
	319	switch (self->media) {
	320	case MEDIA_802_3:
	321	irlan_insert_string_param(skb, "MEDIA", "802.3");
	322	break;
	323	case MEDIA_802_5:
	324	irlan_insert_string_param(skb, "MEDIA", "802.5");
	325	break;
	326	default:
0dc47877	327	IRDA_DEBUG(2, "%s(), unknown media type!\n", __func__ );
1da177e4 LT	328	break;
	329	}
	330	irlan_insert_short_param(skb, "IRLAN_VER", 0x0101);
	331	break;
	332
	333	case CMD_GET_MEDIA_CHAR:
	334	skb->data[0] = 0x00; /* Success */
	335	skb->data[1] = 0x05; /* 5 parameters */
	336	irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
	337	irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
	338	irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
	339
	340	switch (self->provider.access_type) {
	341	case ACCESS_DIRECT:
	342	irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
	343	break;
	344	case ACCESS_PEER:
	345	irlan_insert_string_param(skb, "ACCESS_TYPE", "PEER");
	346	break;
	347	case ACCESS_HOSTED:
	348	irlan_insert_string_param(skb, "ACCESS_TYPE", "HOSTED");
	349	break;
	350	default:
0dc47877	351	IRDA_DEBUG(2, "%s(), Unknown access type\n", __func__ );
1da177e4 LT	352	break;
	353	}
	354	irlan_insert_short_param(skb, "MAX_FRAME", 0x05ee);
	355	break;
	356	case CMD_OPEN_DATA_CHANNEL:
	357	skb->data[0] = 0x00; /* Success */
	358	if (self->provider.send_arb_val) {
	359	skb->data[1] = 0x03; /* 3 parameters */
6819bc2e	360	irlan_insert_short_param(skb, "CON_ARB",
1da177e4 LT	361	self->provider.send_arb_val);
	362	} else
	363	skb->data[1] = 0x02; /* 2 parameters */
	364	irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data);
1b0fee7d	365	irlan_insert_string_param(skb, "RECONNECT_KEY", "LINUX RULES!");
1da177e4 LT	366	break;
	367	case CMD_FILTER_OPERATION:
	368	irlan_filter_request(self, skb);
	369	break;
	370	default:
0dc47877	371	IRDA_DEBUG(2, "%s(), Unknown command!\n", __func__ );
1da177e4 LT	372	break;
	373	}
	374
	375	irttp_data_request(self->provider.tsap_ctrl, skb);
	376	}
	377
	378	/*
	379	* Function irlan_provider_register(void)
	380	*
	381	* Register provider support so we can accept incoming connections.
6819bc2e	382	*
1da177e4 LT	383	*/
	384	int irlan_provider_open_ctrl_tsap(struct irlan_cb *self)
	385	{
	386	struct tsap_cb *tsap;
	387	notify_t notify;
6819bc2e	388
0dc47877	389	IRDA_DEBUG(4, "%s()\n", __func__ );
1da177e4 LT	390
	391	IRDA_ASSERT(self != NULL, return -1;);
	392	IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
	393
	394	/* Check if already open */
	395	if (self->provider.tsap_ctrl)
	396	return -1;
6819bc2e	397
1da177e4 LT	398	/*
	399	* First register well known control TSAP
	400	*/
	401	irda_notify_init(&notify);
	402	notify.data_indication = irlan_provider_data_indication;
	403	notify.connect_indication = irlan_provider_connect_indication;
	404	notify.disconnect_indication = irlan_provider_disconnect_indication;
	405	notify.instance = self;
	406	strlcpy(notify.name, "IrLAN ctrl (p)", sizeof(notify.name));
	407
	408	tsap = irttp_open_tsap(LSAP_ANY, 1, &notify);
	409	if (!tsap) {
0dc47877	410	IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__ );
1da177e4 LT	411	return -1;
	412	}
	413	self->provider.tsap_ctrl = tsap;
	414
	415	/* Register with LM-IAS */
	416	irlan_ias_register(self, tsap->stsap_sel);
	417
	418	return 0;
	419	}
	420