patch-2.2.6 linux/net/irda/irlmp.c
Next file: linux/net/irda/irlmp_event.c
Previous file: linux/net/irda/irlap_frame.c
Back to the patch index
Back to the overall index
- Lines: 1476
- Date:
Thu Apr 15 05:42:42 1999
- Orig file:
v2.2.5/linux/net/irda/irlmp.c
- Orig date:
Wed Mar 10 15:29:52 1999
diff -u --recursive --new-file v2.2.5/linux/net/irda/irlmp.c linux/net/irda/irlmp.c
@@ -1,12 +1,12 @@
/*********************************************************************
*
* Filename: irlmp.c
- * Version: 0.8
+ * Version: 0.9
* Description: IrDA Link Management Protocol (LMP) layer
- * Status: Experimental.
+ * Status: Stable.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Sun Aug 17 20:54:32 1997
- * Modified at: Sat Feb 20 01:28:39 1999
+ * Modified at: Wed Apr 7 17:31:48 1999
* Modified by: Dag Brattli <dagb@cs.uit.no>
*
* Copyright (c) 1998 Dag Brattli <dagb@cs.uit.no>,
@@ -30,6 +30,9 @@
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/init.h>
+#include <linux/kmod.h>
+#include <linux/random.h>
+#include <linux/irda.h>
#include <net/irda/irda.h>
#include <net/irda/irmod.h>
@@ -39,14 +42,13 @@
#include <net/irda/iriap.h>
#include <net/irda/irlmp.h>
#include <net/irda/irlmp_frame.h>
-#include <linux/kmod.h>
/* Master structure */
struct irlmp_cb *irlmp = NULL;
/* These can be altered by the sysctl interface */
-int sysctl_discovery = 0;
-int sysctl_discovery_slots = 6;
+int sysctl_discovery = 0;
+int sysctl_discovery_slots = 6;
char sysctl_devname[65];
char *lmp_reasons[] = {
@@ -61,8 +63,7 @@
__u8 *irlmp_hint_to_service( __u8 *hint);
#ifdef CONFIG_PROC_FS
-int irlmp_proc_read( char *buf, char **start, off_t offset, int len,
- int unused);
+int irlmp_proc_read(char *buf, char **start, off_t offst, int len, int unused);
#endif
/*
@@ -83,19 +84,21 @@
irlmp->magic = LMP_MAGIC;
- irlmp->registry = hashbin_new( HB_LOCAL);
- irlmp->links = hashbin_new( HB_LOCAL);
- irlmp->unconnected_lsaps = hashbin_new( HB_GLOBAL);
+ irlmp->clients = hashbin_new(HB_GLOBAL);
+ irlmp->services = hashbin_new(HB_GLOBAL);
+ irlmp->links = hashbin_new(HB_GLOBAL);
+ irlmp->unconnected_lsaps = hashbin_new(HB_GLOBAL);
+ irlmp->cachelog = hashbin_new(HB_GLOBAL);
irlmp->free_lsap_sel = 0x10; /* Servers use 0x00-0x0f */
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
irlmp->cache.valid = FALSE;
#endif
- strcpy( sysctl_devname, "Linux");
+ strcpy(sysctl_devname, "Linux");
/* Do discovery every 3 seconds */
- init_timer( &irlmp->discovery_timer);
- irlmp_start_discovery_timer( irlmp, 600);
+ init_timer(&irlmp->discovery_timer);
+ irlmp_start_discovery_timer(irlmp, 600);
return 0;
}
@@ -109,18 +112,19 @@
void irlmp_cleanup(void)
{
/* Check for main structure */
- ASSERT( irlmp != NULL, return;);
- ASSERT( irlmp->magic == LMP_MAGIC, return;);
+ ASSERT(irlmp != NULL, return;);
+ ASSERT(irlmp->magic == LMP_MAGIC, return;);
- del_timer( &irlmp->discovery_timer);
+ del_timer(&irlmp->discovery_timer);
- /* FIXME, we need a special function to deallocate LAPs */
- hashbin_delete( irlmp->links, (FREE_FUNC) kfree);
- hashbin_delete( irlmp->unconnected_lsaps, (FREE_FUNC) kfree);
- hashbin_delete( irlmp->registry, (FREE_FUNC) kfree);
+ hashbin_delete(irlmp->links, (FREE_FUNC) kfree);
+ hashbin_delete(irlmp->unconnected_lsaps, (FREE_FUNC) kfree);
+ hashbin_delete(irlmp->clients, (FREE_FUNC) kfree);
+ hashbin_delete(irlmp->services, (FREE_FUNC) kfree);
+ hashbin_delete(irlmp->cachelog, (FREE_FUNC) kfree);
/* De-allocate main structure */
- kfree( irlmp);
+ kfree(irlmp);
irlmp = NULL;
}
@@ -130,20 +134,20 @@
* Register with IrLMP and create a local LSAP,
* returns handle to LSAP.
*/
-struct lsap_cb *irlmp_open_lsap( __u8 slsap_sel, struct notify_t *notify)
+struct lsap_cb *irlmp_open_lsap(__u8 slsap_sel, struct notify_t *notify)
{
struct lsap_cb *self;
- ASSERT( notify != NULL, return NULL;);
- ASSERT( irlmp != NULL, return NULL;);
- ASSERT( irlmp->magic == LMP_MAGIC, return NULL;);
+ ASSERT(notify != NULL, return NULL;);
+ ASSERT(irlmp != NULL, return NULL;);
+ ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
- DEBUG( 4, __FUNCTION__ "(), slsap_sel=%02x\n", slsap_sel);
+ DEBUG(4, __FUNCTION__ "(), slsap_sel=%02x\n", slsap_sel);
/*
* Does the client care which Source LSAP selector it gets?
*/
- if ( slsap_sel == LSAP_ANY) {
+ if (slsap_sel == LSAP_ANY) {
/*
* Find unused LSAP
*/
@@ -155,41 +159,39 @@
* Client wants specific LSAP, so check if it's already
* in use
*/
- if ( irlmp_slsap_inuse( slsap_sel)) {
+ if (irlmp_slsap_inuse(slsap_sel)) {
return NULL;
}
- if ( slsap_sel > irlmp->free_lsap_sel)
- irlmp->free_lsap_sel = slsap_sel+1;
}
/*
* Allocate new instance of a LSAP connection
*/
- self = kmalloc( sizeof(struct lsap_cb), GFP_ATOMIC);
- if ( self == NULL) {
+ self = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
+ if (self == NULL) {
printk( KERN_ERR "IrLMP: Can't allocate memory for "
"LSAP control block!\n");
return NULL;
}
- memset( self, 0, sizeof(struct lsap_cb));
+ memset(self, 0, sizeof(struct lsap_cb));
self->magic = LMP_LSAP_MAGIC;
self->slsap_sel = slsap_sel;
self->dlsap_sel = LSAP_ANY;
self->connected = FALSE;
- init_timer( &self->watchdog_timer);
+ init_timer(&self->watchdog_timer);
- ASSERT( notify->instance != NULL, return NULL;);
+ ASSERT(notify->instance != NULL, return NULL;);
self->notify = *notify;
- irlmp_next_lsap_state( self, LSAP_DISCONNECTED);
+ irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
/*
* Insert into queue of unconnected LSAPs
*/
- hashbin_insert( irlmp->unconnected_lsaps, (QUEUE *) self,
- self->slsap_sel, NULL);
+ hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) self, (int) self,
+ NULL);
return self;
}
@@ -197,65 +199,62 @@
/*
* Function irlmp_close_lsap (self)
*
- * Remove an instance of a LSAP
+ * Remove an instance of LSAP
*/
-static void __irlmp_close_lsap( struct lsap_cb *self)
+static void __irlmp_close_lsap(struct lsap_cb *self)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(4, __FUNCTION__ "()\n");
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
/*
* Set some of the variables to preset values
*/
self->magic = ~LMP_LSAP_MAGIC;
- del_timer( &self->watchdog_timer); /* Important! */
+ del_timer(&self->watchdog_timer); /* Important! */
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
- ASSERT( irlmp != NULL, return;);
+ ASSERT(irlmp != NULL, return;);
irlmp->cache.valid = FALSE;
#endif
- kfree( self);
+ kfree(self);
}
/*
* Function irlmp_close_lsap (self)
*
- *
+ * Close and remove LSAP
*
*/
-void irlmp_close_lsap( struct lsap_cb *self)
+void irlmp_close_lsap(struct lsap_cb *self)
{
struct lap_cb *lap;
- struct lsap_cb *lsap;
+ struct lsap_cb *lsap = NULL;
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
-
- lap = self->lap;
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
/*
* Find out if we should remove this LSAP from a link or from the
* list of unconnected lsaps (not associated with a link)
*/
- if ( lap == NULL) {
- lsap = hashbin_remove( irlmp->unconnected_lsaps,
- self->slsap_sel, NULL);
- } else {
- ASSERT( lap != NULL, return;);
- ASSERT( lap->magic == LMP_LAP_MAGIC, return;);
-
- lsap = hashbin_remove( lap->lsaps, self->slsap_sel, NULL);
+ lap = self->lap;
+ if (lap) {
+ ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
+ lsap = hashbin_remove(lap->lsaps, (int) self, NULL);
+ }
+ /* Check if we found the LSAP! If not then try the unconnected lsaps */
+ if (!lsap) {
+ lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self,
+ NULL);
}
- if ( lsap == NULL) {
- DEBUG( 1, __FUNCTION__
+ if (!lsap) {
+ DEBUG(0, __FUNCTION__
"(), Looks like somebody has removed me already!\n");
return;
}
- ASSERT( lsap == self, return;);
-
- __irlmp_close_lsap( self);
+ __irlmp_close_lsap(self);
}
/*
@@ -265,50 +264,47 @@
* instances of the IrLAP layer, each connected to different IrDA ports
*
*/
-void irlmp_register_irlap( struct irlap_cb *irlap, __u32 saddr,
- struct notify_t *notify)
+void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr,
+ struct notify_t *notify)
{
struct lap_cb *lap;
- DEBUG( 4, __FUNCTION__ "(), Registered IrLAP, saddr = %08x\n",
- saddr);
+ DEBUG(4, __FUNCTION__ "(), Registered IrLAP, saddr = %08x\n", saddr);
- ASSERT( irlmp != NULL, return;);
- ASSERT( irlmp->magic == LMP_MAGIC, return;);
- ASSERT( notify != NULL, return;);
+ ASSERT(irlmp != NULL, return;);
+ ASSERT(irlmp->magic == LMP_MAGIC, return;);
+ ASSERT(notify != NULL, return;);
/*
* Allocate new instance of a LSAP connection
*/
- lap = kmalloc( sizeof(struct lap_cb), GFP_KERNEL);
- if ( lap == NULL) {
- printk( KERN_ERR "IrLMP: Can't allocate memory for "
- "LAP control block!\n");
+ lap = kmalloc(sizeof(struct lap_cb), GFP_KERNEL);
+ if (lap == NULL) {
+ DEBUG(3, __FUNCTION__ "(), unable to kmalloc\n");
return;
}
- memset( lap, 0, sizeof(struct lap_cb));
+ memset(lap, 0, sizeof(struct lap_cb));
lap->irlap = irlap;
lap->magic = LMP_LAP_MAGIC;
lap->saddr = saddr;
lap->daddr = DEV_ADDR_ANY;
- lap->lsaps = hashbin_new( HB_GLOBAL);
- lap->cachelog = hashbin_new( HB_LOCAL);
+ lap->lsaps = hashbin_new(HB_GLOBAL);
- irlmp_next_lap_state( lap, LAP_STANDBY);
+ irlmp_next_lap_state(lap, LAP_STANDBY);
init_timer(&lap->idle_timer);
/*
* Insert into queue of unconnected LSAPs
*/
- hashbin_insert( irlmp->links, (QUEUE *) lap, lap->saddr, NULL);
+ hashbin_insert(irlmp->links, (QUEUE *) lap, lap->saddr, NULL);
/*
* We set only this variable so IrLAP can tell us on which link the
* different events happened on
*/
- irda_notify_init( notify);
+ irda_notify_init(notify);
notify->instance = lap;
}
@@ -318,71 +314,24 @@
* IrLAP layer has been removed!
*
*/
-void irlmp_unregister_irlap(__u32 saddr)
+void irlmp_unregister_link(__u32 saddr)
{
- struct lap_cb *self;
+ struct lap_cb *link;
DEBUG(4, __FUNCTION__ "()\n");
- self = hashbin_remove(irlmp->links, saddr, NULL);
- if (self) {
- ASSERT(self->magic == LMP_LAP_MAGIC, return;);
-
- del_timer(&self->idle_timer);
-
- self->magic = 0;
- kfree(self);
- } else {
- DEBUG(1, __FUNCTION__ "(), Didn't find LAP layer!\n");
- }
-}
-
-void dump_discoveries( hashbin_t *log)
-{
- DISCOVERY *d;
-
- ASSERT( log != NULL, return;);
-
- d = (DISCOVERY *) hashbin_get_first( log);
- while( d != NULL) {
- DEBUG( 1, "Discovery:\n");
- DEBUG( 1, " daddr=%08x\n", d->daddr);
- DEBUG( 1, " name=%s\n", d->info);
-
- d = (DISCOVERY *) hashbin_get_next( log);
- }
-}
-
-static struct lap_cb *irlmp_find_link( __u32 daddr)
-{
- struct lap_cb *lap;
- unsigned long flags;
+ link = hashbin_remove(irlmp->links, saddr, NULL);
+ if (link) {
+ ASSERT(link->magic == LMP_LAP_MAGIC, return;);
- DEBUG( 1, __FUNCTION__
- "(), client didn't supply saddr, so try to look it up!\n");
+ /* Remove all discoveries discovered at this link */
+ irlmp_expire_discoveries(irlmp->cachelog, link->saddr, TRUE);
- /*
- * Find out which link to connect on, and make sure nothing strange
- * happens while we traverse the list
- */
- save_flags( flags);
- cli();
+ del_timer(&link->idle_timer);
- lap = (struct lap_cb *) hashbin_get_first( irlmp->links);
- while ( lap != NULL) {
- ASSERT( lap->magic == LMP_LAP_MAGIC, return NULL;);
- /* dump_discoveries( lap->cachelog); */
-
- if ( hashbin_find( lap->cachelog, daddr, NULL)) {
- DEBUG( 4, __FUNCTION__
- "() found link to connect on!\n");
- return lap;
- }
- lap = (struct lap_cb *) hashbin_get_next( irlmp->links);
+ link->magic = 0;
+ kfree(link);
}
- restore_flags(flags);
-
- return NULL;
}
/*
@@ -398,36 +347,35 @@
struct sk_buff *skb = NULL;
struct lap_cb *lap;
struct lsap_cb *lsap;
+ discovery_t *discovery;
ASSERT( self != NULL, return -1;);
ASSERT( self->magic == LMP_LSAP_MAGIC, return -1;);
- DEBUG( 4, __FUNCTION__
- "(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
- self->slsap_sel, dlsap_sel, saddr, daddr);
+ DEBUG(2, __FUNCTION__
+ "(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
+ self->slsap_sel, dlsap_sel, saddr, daddr);
- if ( self->connected) {
- DEBUG( 1, __FUNCTION__ "(), Error: already connected!!\n");
-
+ if ( self->connected)
return -EISCONN;
- }
+
+ /* Client must supply destination device address */
+ if (!daddr)
+ return -EINVAL;
/* Any userdata? */
- if ( userdata == NULL) {
- skb = dev_alloc_skb( 64);
- if (skb == NULL) {
- DEBUG( 1, __FUNCTION__
- "(), Could not allocate sk_buff of length %d\n",
- 64);
- return -1;
- }
- skb_reserve( skb, LMP_CONTROL_HEADER+LAP_HEADER);
+ if (userdata == NULL) {
+ skb = dev_alloc_skb(64);
+ if (!skb)
+ return -ENOMEM;
+
+ skb_reserve(skb, LMP_CONTROL_HEADER+LAP_HEADER);
} else
skb = userdata;
/* Make room for MUX control header ( 3 bytes) */
- ASSERT( skb_headroom( skb) >= LMP_CONTROL_HEADER, return -1;);
- skb_push( skb, LMP_CONTROL_HEADER);
+ ASSERT(skb_headroom(skb) >= LMP_CONTROL_HEADER, return -1;);
+ skb_push(skb, LMP_CONTROL_HEADER);
self->dlsap_sel = dlsap_sel;
self->tmp_skb = skb;
@@ -440,44 +388,48 @@
* discovery log and check if any of the links has discovered a
* device with the given daddr
*/
- if ( saddr)
- lap = hashbin_find( irlmp->links, saddr, NULL);
- else
- lap = irlmp_find_link( daddr);
-
- if ( lap == NULL) {
- DEBUG( 1, __FUNCTION__ "(), Unable to find a usable link!\n");
-
+ if (!saddr) {
+ discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
+ if (discovery)
+ saddr = discovery->saddr;
+ }
+ lap = hashbin_find(irlmp->links, saddr, NULL);
+ if (lap == NULL) {
+ DEBUG(1, __FUNCTION__ "(), Unable to find a usable link!\n");
return -EHOSTUNREACH;
}
+
+ if (lap->daddr == DEV_ADDR_ANY)
+ lap->daddr = daddr;
+ else if (lap->daddr != daddr) {
+ DEBUG(0, __FUNCTION__ "(), sorry, but link is busy!\n");
+ return -EBUSY;
+ }
+
self->lap = lap;
/*
* Remove LSAP from list of unconnected LSAPs and insert it into the
- * list of connected LSAPs for the particular link */
- lsap = hashbin_remove( irlmp->unconnected_lsaps, self->slsap_sel,
- NULL);
-
- ASSERT( lsap != NULL, return -1;);
- ASSERT( lsap->magic == LMP_LSAP_MAGIC, return -1;);
- ASSERT( lsap->lap != NULL, return -1;);
- ASSERT( lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
+ * list of connected LSAPs for the particular link
+ */
+ lsap = hashbin_remove(irlmp->unconnected_lsaps, (int) self, NULL);
- hashbin_insert( self->lap->lsaps, (QUEUE *) self, self->slsap_sel,
- NULL);
+ ASSERT(lsap != NULL, return -1;);
+ ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
+ ASSERT(lsap->lap != NULL, return -1;);
+ ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
- self->connected = TRUE;
+ hashbin_insert(self->lap->lsaps, (QUEUE *) self, (int) self, NULL);
+ self->connected = TRUE;
+
/*
* User supplied qos specifications?
*/
if (qos)
self->qos = *qos;
- DEBUG( 4, "*** Connecting SLSAP=%02x, DLSAP= %02x\n",
- self->slsap_sel, self->dlsap_sel);
-
- irlmp_do_lsap_event( self, LM_CONNECT_REQUEST, skb);
+ irlmp_do_lsap_event(self, LM_CONNECT_REQUEST, skb);
return 0;
}
@@ -488,26 +440,26 @@
* Incomming connection
*
*/
-void irlmp_connect_indication( struct lsap_cb *self, struct sk_buff *skb)
+void irlmp_connect_indication(struct lsap_cb *self, struct sk_buff *skb)
{
int max_seg_size;
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(3, __FUNCTION__ "()\n");
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
- ASSERT( skb != NULL, return;);
- ASSERT( self->lap != NULL, return;);
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(skb != NULL, return;);
+ ASSERT(self->lap != NULL, return;);
self->qos = *self->lap->qos;
max_seg_size = self->lap->qos->data_size.value;
- DEBUG( 4, __FUNCTION__ "(), max_seg_size=%d\n", max_seg_size);
+ DEBUG(4, __FUNCTION__ "(), max_seg_size=%d\n", max_seg_size);
/* Hide LMP_CONTROL_HEADER header from layer above */
- skb_pull( skb, LMP_CONTROL_HEADER);
+ skb_pull(skb, LMP_CONTROL_HEADER);
- if ( self->notify.connect_indication)
+ if (self->notify.connect_indication)
self->notify.connect_indication(self->notify.instance, self,
&self->qos, max_seg_size, skb);
}
@@ -520,7 +472,7 @@
*/
void irlmp_connect_response( struct lsap_cb *self, struct sk_buff *userdata)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(3, __FUNCTION__ "()\n");
ASSERT( self != NULL, return;);
ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
@@ -543,11 +495,11 @@
*
* LSAP connection confirmed peer device!
*/
-void irlmp_connect_confirm( struct lsap_cb *self, struct sk_buff *skb)
+void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
{
int max_seg_size;
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(3, __FUNCTION__ "()\n");
ASSERT( skb != NULL, return;);
ASSERT( self != NULL, return;);
@@ -569,12 +521,52 @@
}
/*
+ * Function irlmp_dup (orig, instance)
+ *
+ * Duplicate LSAP, can be used by servers to confirm a connection on a
+ * new LSAP so it can keep listening on the old one.
+ *
+ */
+struct lsap_cb *irlmp_dup(struct lsap_cb *orig, void *instance)
+{
+ struct lsap_cb *new;
+
+ DEBUG(1, __FUNCTION__ "()\n");
+
+ /* Only allowed to duplicate unconnected LSAP's */
+ if (!hashbin_find(irlmp->unconnected_lsaps, (int) orig, NULL)) {
+ DEBUG(0, __FUNCTION__ "(), unable to find LSAP\n");
+ return NULL;
+ }
+ new = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
+ if (!new) {
+ DEBUG(0, __FUNCTION__ "(), unable to kmalloc\n");
+ return NULL;
+ }
+ /* Dup */
+ memcpy(new, orig, sizeof(struct lsap_cb));
+ new->notify.instance = instance;
+
+ init_timer(&new->watchdog_timer);
+
+ hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) new, (int) new,
+ NULL);
+
+ /* Make sure that we invalidate the cache */
+#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
+ irlmp->cache.valid = FALSE;
+#endif /* CONFIG_IRDA_CACHE_LAST_LSAP */
+
+ return new;
+}
+
+/*
* Function irlmp_disconnect_request (handle, userdata)
*
* The service user is requesting disconnection, this will not remove the
* LSAP, but only mark it as disconnected
*/
-void irlmp_disconnect_request( struct lsap_cb *self, struct sk_buff *userdata)
+void irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
{
struct lsap_cb *lsap;
@@ -608,14 +600,14 @@
ASSERT( self->lap->magic == LMP_LAP_MAGIC, return;);
ASSERT( self->lap->lsaps != NULL, return;);
- lsap = hashbin_remove( self->lap->lsaps, self->slsap_sel, NULL);
+ lsap = hashbin_remove(self->lap->lsaps, (int) self, NULL);
ASSERT( lsap != NULL, return;);
ASSERT( lsap->magic == LMP_LSAP_MAGIC, return;);
ASSERT( lsap == self, return;);
- hashbin_insert( irlmp->unconnected_lsaps, (QUEUE *) self,
- self->slsap_sel, NULL);
+ hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) self, (int) self,
+ NULL);
/* Reset some values */
self->connected = FALSE;
@@ -651,12 +643,12 @@
ASSERT( self->lap != NULL, return;);
ASSERT( self->lap->lsaps != NULL, return;);
- lsap = hashbin_remove( self->lap->lsaps, self->slsap_sel, NULL);
+ lsap = hashbin_remove( self->lap->lsaps, (int) self, NULL);
ASSERT( lsap != NULL, return;);
ASSERT( lsap == self, return;);
- hashbin_insert( irlmp->unconnected_lsaps, (QUEUE *) lsap,
- lsap->slsap_sel, NULL);
+ hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) lsap, (int) lsap,
+ NULL);
self->lap = NULL;
@@ -670,33 +662,24 @@
}
/*
- * Function irlmp_discovery_request (nslots)
+ * Function irlmp_do_discovery (nslots)
*
- * Do a discovery of devices in front of the computer
+ * Do some discovery on all links
*
*/
-void irlmp_discovery_request( int nslots)
+void irlmp_do_discovery(int nslots)
{
struct lap_cb *lap;
- DEBUG( 4, __FUNCTION__ "(), nslots=%d\n", nslots);
-
- ASSERT( irlmp != NULL, return;);
-
- if ( !sysctl_discovery)
- return;
-
- if ((nslots != 1)&&(nslots != 6)&&(nslots != 8)&&(nslots != 16)) {
- DEBUG( 1, __FUNCTION__ "(), invalid number of slots value!\n");
+ /* Make sure value is sane */
+ if ((nslots != 1) && (nslots != 6) && (nslots != 8)&&(nslots != 16)) {
+ printk(KERN_WARNING __FUNCTION__
+ "(), invalid value for number of slots!\n");
nslots = sysctl_discovery_slots = 8;
}
- /*
- * Construct new discovery info to be used by IrLAP,
- * TODO: no need to do this every time!
- */
- irlmp->discovery_cmd.hint[0] = irlmp->hint[0];
- irlmp->discovery_cmd.hint[1] = irlmp->hint[1];
+ /* Construct new discovery info to be used by IrLAP, */
+ irlmp->discovery_cmd.hints.word = irlmp->hints.word;
/*
* Set character set for device name (we use ASCII), and
@@ -704,134 +687,161 @@
* end
*/
irlmp->discovery_cmd.charset = CS_ASCII;
-
- strncpy( irlmp->discovery_cmd.info, sysctl_devname, 31);
- irlmp->discovery_cmd.info_len = strlen( irlmp->discovery_cmd.info);
+ strncpy(irlmp->discovery_cmd.info, sysctl_devname, 31);
+ irlmp->discovery_cmd.info_len = strlen(irlmp->discovery_cmd.info);
irlmp->discovery_cmd.nslots = nslots;
/*
* Try to send discovery packets on all links
*/
- lap = ( struct lap_cb *) hashbin_get_first( irlmp->links);
- while ( lap != NULL) {
- ASSERT( lap->magic == LMP_LAP_MAGIC, return;);
-
- DEBUG( 4, __FUNCTION__ "() sending request!\n");
- irlmp_do_lap_event( lap, LM_LAP_DISCOVERY_REQUEST, NULL);
+ lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
+ while (lap != NULL) {
+ ASSERT(lap->magic == LMP_LAP_MAGIC, return;);
- lap = ( struct lap_cb *) hashbin_get_next( irlmp->links);
+ if (lap->lap_state == LAP_STANDBY) {
+ /* Expire discoveries discovered on this link */
+ irlmp_expire_discoveries(irlmp->cachelog, lap->saddr,
+ FALSE);
+
+ /* Try to discover */
+ irlmp_do_lap_event(lap, LM_LAP_DISCOVERY_REQUEST,
+ NULL);
+ }
+ lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
}
}
/*
+ * Function irlmp_discovery_request (nslots)
+ *
+ * Do a discovery of devices in front of the computer
+ *
+ */
+void irlmp_discovery_request(int nslots)
+{
+
+ DEBUG(4, __FUNCTION__ "(), nslots=%d\n", nslots);
+
+ /*
+ * If discovery is already running, then just return the current
+ * discovery log
+ */
+ if (sysctl_discovery) {
+ DEBUG(2, __FUNCTION__ "() discovery already running, so we"
+ " just return the old discovery log!\n");
+ irlmp_discovery_confirm(irlmp->cachelog);
+ } else
+ irlmp_do_discovery(nslots);
+}
+
+#if 0
+/*
* Function irlmp_check_services (discovery)
*
*
*
*/
-void irlmp_check_services( DISCOVERY *discovery)
+void irlmp_check_services(discovery_t *discovery)
{
- struct irlmp_registration *entry;
+ struct irlmp_client *client;
struct irmanager_event event;
- __u8 *service;
+ __u8 *service_log;
+ __u8 service;
int i = 0;
DEBUG(1, "IrDA Discovered: %s\n", discovery->info);
DEBUG(1, " Services: ");
- service = irlmp_hint_to_service( discovery->hint);
- if (service != NULL) {
- /*
- * Check all services on the device
- */
- while ( service[i] != S_END) {
- DEBUG( 4, "service=%02x\n", service[i]);
- entry = hashbin_find( irlmp->registry,
- service[i], NULL);
- if ( entry && entry->discovery_callback) {
- DEBUG( 4, "discovery_callback!\n");
- entry->discovery_callback( discovery);
- } else {
- /*
- * Found no clients for dealing with this
- * service, so ask the user space irmanager
- * to try to load the right module for us
- */
-
- event.event = EVENT_DEVICE_DISCOVERED;
- event.service = service[i];
- event.daddr = discovery->daddr;
- sprintf( event.info, "%s",
- discovery->info);
- irmanager_notify( &event);
- }
- i++; /* Next service */
+ service_log = irlmp_hint_to_service(discovery->hints.byte);
+ if (!service_log)
+ return;
+
+ /*
+ * Check all services on the device
+ */
+ while ((service = service_log[i++]) != S_END) {
+ DEBUG( 4, "service=%02x\n", service);
+ client = hashbin_find(irlmp->registry, service, NULL);
+ if (entry && entry->discovery_callback) {
+ DEBUG( 4, "discovery_callback!\n");
+
+ entry->discovery_callback(discovery);
+ } else {
+ /* Don't notify about the ANY service */
+ if (service == S_ANY)
+ continue;
+ /*
+ * Found no clients for dealing with this service,
+ * so ask the user space irmanager to try to load
+ * the right module for us
+ */
+ event.event = EVENT_DEVICE_DISCOVERED;
+ event.service = service;
+ event.daddr = discovery->daddr;
+ sprintf(event.info, "%s", discovery->info);
+ irmanager_notify(&event);
}
- kfree( service);
}
+ kfree(service_log);
}
-
+#endif
/*
- * Function irlmp_discovery_confirm ( self, log)
+ * Function irlmp_notify_client (log)
+ *
+ * Notify all about discovered devices
*
- * Some device(s) answered to our discovery request! Check to see which
- * device it is, and give indication to the client(s)
- *
*/
-void irlmp_discovery_confirm( struct lap_cb *self, hashbin_t *log)
+void irlmp_notify_client(irlmp_client_t *client, hashbin_t *log)
{
- DISCOVERY *discovery;
+ discovery_t *discovery;
+
+ DEBUG(3, __FUNCTION__ "()\n");
- DEBUG( 4, __FUNCTION__ "()\n");
+ /* Check if client wants the whole log */
+ if (client->callback2)
+ client->callback2(log);
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LAP_MAGIC, return;);
-
- /*
- * Now, check all discovered devices (if any)
+ /*
+ * Now, check all discovered devices (if any), and notify client
+ * only about the services that the client is interested in
*/
- discovery = ( DISCOVERY *) hashbin_get_first( log);
- while ( discovery != NULL) {
- self->daddr = discovery->daddr;
-
- DEBUG( 4, "discovery->daddr = 0x%08x\n", discovery->daddr);
+ discovery = (discovery_t *) hashbin_get_first(log);
+ while (discovery != NULL) {
+ DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr);
- irlmp_check_services( discovery);
-
- discovery = ( DISCOVERY *) hashbin_get_next( log);
+ if (client->hint_mask & discovery->hints.word) {
+ if (client->callback1)
+ client->callback1(discovery);
+ }
+ discovery = (discovery_t *) hashbin_get_next(log);
}
}
/*
- * Function irlmp_discovery_indication (discovery)
- *
- * A remote device is discovering us!
+ * Function irlmp_discovery_confirm ( self, log)
*
+ * Some device(s) answered to our discovery request! Check to see which
+ * device it is, and give indication to the client(s)
+ *
*/
-void irlmp_discovery_indication( struct lap_cb *self, DISCOVERY *discovery)
+void irlmp_discovery_confirm(hashbin_t *log)
{
- /* struct irda_event event; */
-
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LAP_MAGIC, return;);
- ASSERT( discovery != NULL, return;);
-
- DEBUG( 4, __FUNCTION__ "()\n");
-
- DEBUG( 4, "discovery->daddr = 0x%08x\n", discovery->daddr);
- self->daddr = discovery->daddr;
-
- ASSERT( self->cachelog != NULL, return;);
-
- /*
- * Insert this discovery device into the discovery_log if its
- * not there already
- */
- if ( !hashbin_find( self->cachelog, discovery->daddr, NULL))
- hashbin_insert( self->cachelog, (QUEUE *) discovery,
- discovery->daddr, NULL);
-
- irlmp_check_services( discovery);
+ irlmp_client_t *client;
+
+ DEBUG(3, __FUNCTION__ "()\n");
+
+ ASSERT(log != NULL, return;);
+
+ if (!hashbin_get_size(log))
+ return;
+
+ client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
+ while (client != NULL) {
+ /* Check if we should notify client */
+ irlmp_notify_client(client, log);
+
+ client = (irlmp_client_t *) hashbin_get_next(irlmp->clients);
+ }
}
/*
@@ -840,14 +850,13 @@
* Used by IrLAP to get the disocvery info it needs when answering
* discovery requests by other devices.
*/
-DISCOVERY *irlmp_get_discovery_response()
+discovery_t *irlmp_get_discovery_response()
{
- DEBUG( 4, "irlmp_get_discovery_response()\n");
+ DEBUG(4, __FUNCTION__ "()\n");
- ASSERT( irlmp != NULL, return NULL;);
+ ASSERT(irlmp != NULL, return NULL;);
- irlmp->discovery_rsp.hint[0] = irlmp->hint[0];
- irlmp->discovery_rsp.hint[1] = irlmp->hint[1];
+ irlmp->discovery_rsp.hints.word = irlmp->hints.word;
/*
* Set character set for device name (we use ASCII), and
@@ -856,8 +865,8 @@
*/
irlmp->discovery_rsp.charset = CS_ASCII;
- strncpy( irlmp->discovery_rsp.info, sysctl_devname, 31);
- irlmp->discovery_rsp.info_len = strlen( irlmp->discovery_rsp.info) + 2;
+ strncpy(irlmp->discovery_rsp.info, sysctl_devname, 31);
+ irlmp->discovery_rsp.info_len = strlen(irlmp->discovery_rsp.info) + 2;
return &irlmp->discovery_rsp;
}
@@ -870,17 +879,17 @@
*/
void irlmp_data_request( struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(4, __FUNCTION__ "()\n");
- ASSERT( skb != NULL, return;);
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(skb != NULL, return;);
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
/* Make room for MUX header */
- ASSERT( skb_headroom( skb) >= LMP_HEADER, return;);
- skb_push( skb, LMP_HEADER);
+ ASSERT(skb_headroom( skb) >= LMP_HEADER, return;);
+ skb_push(skb, LMP_HEADER);
- irlmp_do_lsap_event( self, LM_DATA_REQUEST, skb);
+ irlmp_do_lsap_event(self, LM_DATA_REQUEST, skb);
}
/*
@@ -889,18 +898,18 @@
* Got data from LAP layer so pass it up to upper layer
*
*/
-void irlmp_data_indication( struct lsap_cb *self, struct sk_buff *skb)
+void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ DEBUG(4, __FUNCTION__ "()\n");
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
- ASSERT( skb != NULL, return;);
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(skb != NULL, return;);
/* Hide LMP header from layer above */
- skb_pull( skb, LMP_HEADER);
+ skb_pull(skb, LMP_HEADER);
- if ( self->notify.data_indication)
+ if (self->notify.data_indication)
self->notify.data_indication(self->notify.instance, self, skb);
}
@@ -940,9 +949,8 @@
/* Hide LMP header from layer above */
skb_pull( skb, LMP_HEADER);
- if ( self->notify.udata_indication)
- self->notify.udata_indication( self->notify.instance, self,
- skb);
+ if (self->notify.udata_indication)
+ self->notify.udata_indication(self->notify.instance, self, skb);
}
/*
@@ -1043,145 +1051,228 @@
}
DEBUG(1, "\n");
+ /* So that client can be notified about any discovery */
+ service[i++] = S_ANY;
+
service[i] = S_END;
return service;
}
/*
- * Function irlmp_service_to_hint (service, hint)
+ * Function irlmp_service_to_hint (service)
*
- *
+ * Converts a service type, to a hint bit
*
+ * Returns: a 16 bit hint value, with the service bit set
*/
-void irlmp_service_to_hint( int service, __u8 *hint)
+__u16 irlmp_service_to_hint(int service)
{
+ __u16_host_order hint;
+
+ hint.word = 0;
+
switch (service) {
case S_PNP:
- hint[0] |= HINT_PNP;
+ hint.byte[0] |= HINT_PNP;
break;
case S_PDA:
- hint[0] |= HINT_PDA;
+ hint.byte[0] |= HINT_PDA;
break;
case S_COMPUTER:
- hint[0] |= HINT_COMPUTER;
+ hint.byte[0] |= HINT_COMPUTER;
break;
case S_PRINTER:
- hint[0] |= HINT_PRINTER;
+ hint.byte[0] |= HINT_PRINTER;
break;
case S_MODEM:
- hint[0] |= HINT_PRINTER;
+ hint.byte[0] |= HINT_PRINTER;
break;
case S_LAN:
- hint[0] |= HINT_LAN;
+ hint.byte[0] |= HINT_LAN;
break;
case S_COMM:
- hint[0] |= HINT_EXTENSION;
- hint[1] |= HINT_COMM;
+ hint.byte[0] |= HINT_EXTENSION;
+ hint.byte[1] |= HINT_COMM;
break;
case S_OBEX:
- hint[0] |= HINT_EXTENSION;
- hint[1] |= HINT_OBEX;
+ hint.byte[0] |= HINT_EXTENSION;
+ hint.byte[1] |= HINT_OBEX;
+ break;
+ case S_ANY:
+ hint.word = 0xffff;
break;
default:
DEBUG( 1, __FUNCTION__ "(), Unknown service!\n");
break;
}
+ return hint.word;
}
/*
- * Function irlmp_register (service, type, callback)
+ * Function irlmp_register_service (service)
*
- * Register a local client or server with IrLMP
+ * Register local service with IrLMP
*
*/
-void irlmp_register_layer( int service, int type, int do_discovery,
- DISCOVERY_CALLBACK callback)
+__u32 irlmp_register_service(__u16 hints)
{
- struct irlmp_registration *entry;
+ irlmp_service_t *service;
+ __u32 handle;
- sysctl_discovery |= do_discovery;
+ DEBUG(4, __FUNCTION__ "(), hints = %04x\n", hints);
- if ( type & SERVER)
- irlmp_service_to_hint( service, irlmp->hint);
+ /* Get a unique handle for this service */
+ get_random_bytes(&handle, sizeof(handle));
+ while (hashbin_find(irlmp->services, handle, NULL) || !handle)
+ get_random_bytes(&handle, sizeof(handle));
- /* Check if this service has been registred before */
- entry = hashbin_find( irlmp->registry, service, NULL);
- if ( entry != NULL) {
- /* Update type in entry */
- entry->type |= type;
+ irlmp->hints.word |= hints;
- /* Update callback only if client, since servers don't
- * use callbacks, and we don't want to overwrite a
- * previous registred client callback
- */
- if ( type & CLIENT)
- entry->discovery_callback = callback;
- return;
+ /* Make a new registration */
+ service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
+ if (!service) {
+ DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
+ return 0;
}
+ service->hints = hints;
+ hashbin_insert(irlmp->services, (QUEUE*) service, handle, NULL);
+
+ return handle;
+}
+
+/*
+ * Function irlmp_unregister_service (handle)
+ *
+ * Unregister service with IrLMP.
+ *
+ * Returns: 0 on success, -1 on error
+ */
+int irlmp_unregister_service(__u32 handle)
+{
+ irlmp_service_t *service;
+
+ DEBUG(4, __FUNCTION__ "()\n");
+
+ if (!handle)
+ return -1;
+
+ service = hashbin_find(irlmp->services, handle, NULL);
+ if (!service) {
+ DEBUG(1, __FUNCTION__ "(), Unknown service!\n");
+ return -1;
+ }
+
+ service = hashbin_remove(irlmp->services, handle, NULL);
+ if (service)
+ kfree(service);
+
+ /* Remove old hint bits */
+ irlmp->hints.word = 0;
+
+ /* Refresh current hint bits */
+ service = (irlmp_service_t *) hashbin_get_first(irlmp->services);
+ while (service) {
+ irlmp->hints.word |= service->hints;
+
+ service = (irlmp_service_t *)hashbin_get_next(irlmp->services);
+ }
+ return 0;
+}
+
+/*
+ * Function irlmp_register_client (hint_mask, callback1, callback2)
+ *
+ * Register a local client with IrLMP
+ *
+ * Returns: handle > 0 on success, 0 on error
+ */
+__u32 irlmp_register_client(__u16 hint_mask, DISCOVERY_CALLBACK1 callback1,
+ DISCOVERY_CALLBACK2 callback2)
+{
+ irlmp_client_t *client;
+ __u32 handle;
+
+ /* Get a unique handle for this client */
+ get_random_bytes(&handle, sizeof(handle));
+ while (hashbin_find(irlmp->clients, handle, NULL) || !handle)
+ get_random_bytes(&handle, sizeof(handle));
/* Make a new registration */
- entry = kmalloc( sizeof( struct irlmp_registration), GFP_ATOMIC);
- if ( !entry) {
+ client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
+ if (!client) {
DEBUG( 1, __FUNCTION__ "(), Unable to kmalloc!\n");
- return;
+
+ return 0;
}
- entry->service = service;
- entry->type = type;
- entry->discovery_callback = callback;
+ /* Register the details */
+ client->hint_mask = hint_mask;
+ client->callback1 = callback1;
+ client->callback2 = callback2;
- hashbin_insert( irlmp->registry, (QUEUE*) entry, entry->service, NULL);
+ hashbin_insert(irlmp->clients, (QUEUE *) client, handle, NULL);
+
+ return handle;
}
/*
- * Function irlmp_unregister (serivice)
+ * Function irlmp_update_client (handle, hint_mask, callback1, callback2)
*
- *
+ * Updates specified client (handle) with possibly new hint_mask and
+ * callback
*
+ * Returns: 0 on success, -1 on error
*/
-void irlmp_unregister_layer( int service, int type)
+int irlmp_update_client(__u32 handle, __u16 hint_mask,
+ DISCOVERY_CALLBACK1 callback1,
+ DISCOVERY_CALLBACK2 callback2)
{
- struct irlmp_registration *entry;
-
- DEBUG( 4, __FUNCTION__ "()\n");
-
- entry = hashbin_find( irlmp->registry, service, NULL);
- if ( entry != NULL) {
- DEBUG( 4, "Found entry to change or remove!\n");
- /* Remove this type from the service registration */
- entry->type &= ~type;
- }
+ irlmp_client_t *client;
- if ( !entry) {
- DEBUG( 1, __FUNCTION__ "Unable to find entry to unregister!\n");
- return;
- }
+ if (!handle)
+ return -1;
- /*
- * Remove entry if there is no more client and server support
- * left in entry
- */
- if ( !entry->type) {
- DEBUG( 4, __FUNCTION__ "(), removing entry!\n");
- entry = hashbin_remove( irlmp->registry, service, NULL);
- if ( entry != NULL)
- kfree( entry);
+ client = hashbin_find(irlmp->clients, handle, NULL);
+ if (!client) {
+ DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
+ return -1;
}
- /* Remove old hint bits */
- irlmp->hint[0] = 0;
- irlmp->hint[1] = 0;
+ client->hint_mask = hint_mask;
+ client->callback1 = callback1;
+ client->callback2 = callback2;
+
+ return 0;
+}
- /* Refresh current hint bits */
- entry = (struct irlmp_registration *) hashbin_get_first( irlmp->registry);
- while( entry != NULL) {
- if ( entry->type & SERVER)
- irlmp_service_to_hint( entry->service,
- irlmp->hint);
- entry = (struct irlmp_registration *)
- hashbin_get_next( irlmp->registry);
- }
+/*
+ * Function irlmp_unregister_client (handle)
+ *
+ * Returns: 0 on success, -1 on error
+ *
+ */
+int irlmp_unregister_client(__u32 handle)
+{
+ struct irlmp_client *client;
+
+ DEBUG(4, __FUNCTION__ "()\n");
+
+ if (!handle)
+ return -1;
+
+ client = hashbin_find(irlmp->clients, handle, NULL);
+ if (!client) {
+ DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
+ return -1;
+ }
+
+ DEBUG( 4, __FUNCTION__ "(), removing client!\n");
+ client = hashbin_remove( irlmp->clients, handle, NULL);
+ if (client)
+ kfree(client);
+
+ return 0;
}
/*
@@ -1200,20 +1291,24 @@
DEBUG( 4, __FUNCTION__ "()\n");
+ /* Valid values are between 0 and 127 */
+ if (slsap_sel > 127)
+ return TRUE;
+
/*
* Check if slsap is already in use. To do this we have to loop over
* every IrLAP connection and check every LSAP assosiated with each
* the connection.
*/
- lap = ( struct lap_cb *) hashbin_get_first( irlmp->links);
- while ( lap != NULL) {
- ASSERT( lap->magic == LMP_LAP_MAGIC, return TRUE;);
-
- self = (struct lsap_cb *) hashbin_get_first( lap->lsaps);
- while ( self != NULL) {
- ASSERT( self->magic == LMP_LSAP_MAGIC, return TRUE;);
+ lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
+ while (lap != NULL) {
+ ASSERT(lap->magic == LMP_LAP_MAGIC, return TRUE;);
+
+ self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
+ while (self != NULL) {
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return TRUE;);
- if (( self->slsap_sel == slsap_sel))/* && */
+ if ((self->slsap_sel == slsap_sel))/* && */
/* ( self->dlsap_sel == LSAP_ANY)) */
{
DEBUG( 4, "Source LSAP selector=%02x in use\n",
@@ -1236,14 +1331,28 @@
__u8 irlmp_find_free_slsap(void)
{
__u8 lsap_sel;
+ int wrapped = 0;
- ASSERT( irlmp != NULL, return -1;);
- ASSERT( irlmp->magic == LMP_MAGIC, return -1;);
+ ASSERT(irlmp != NULL, return -1;);
+ ASSERT(irlmp->magic == LMP_MAGIC, return -1;);
lsap_sel = irlmp->free_lsap_sel++;
-
- DEBUG( 4, __FUNCTION__ "(), next free lsap_sel=%02x\n", lsap_sel);
-
+
+ /* Check if the new free lsap is really free */
+ while (irlmp_slsap_inuse(irlmp->free_lsap_sel)) {
+ irlmp->free_lsap_sel++;
+
+ /* Check if we need to wraparound */
+ if (irlmp->free_lsap_sel > 127) {
+ irlmp->free_lsap_sel = 10;
+
+ /* Make sure we terminate the loop */
+ if (wrapped++)
+ return 0;
+ }
+ }
+ DEBUG(4, __FUNCTION__ "(), next free lsap_sel=%02x\n", lsap_sel);
+
return lsap_sel;
}
@@ -1289,7 +1398,7 @@
__u32 irlmp_get_saddr(struct lsap_cb *self)
{
- DEBUG(0, __FUNCTION__ "()\n");
+ DEBUG(3, __FUNCTION__ "()\n");
ASSERT(self != NULL, return 0;);
ASSERT(self->lap != NULL, return 0;);
@@ -1299,7 +1408,7 @@
__u32 irlmp_get_daddr(struct lsap_cb *self)
{
- DEBUG(0, __FUNCTION__ "()\n");
+ DEBUG(3, __FUNCTION__ "()\n");
ASSERT(self != NULL, return 0;);
ASSERT(self->lap != NULL, return 0;);
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)