417 lines
11 KiB
C
417 lines
11 KiB
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/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 = 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;
|
|
|
|
IRDA_DEBUG(0, "%s()\n", __func__ );
|
|
|
|
self = instance;
|
|
tsap = 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;);
|
|
|
|
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 = instance;
|
|
tsap = 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", "BROADCAST") +
|
|
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(¬ify);
|
|
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, ¬ify);
|
|
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;
|
|
}
|
|
|