patch-2.2.15 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: 1317
- Date:
Fri Apr 21 12:47:16 2000
- Orig file:
v2.2.14/net/irda/irlmp.c
- Orig date:
Sat Aug 14 02:26:52 1999
diff -u --new-file --recursive --exclude-from ../../exclude v2.2.14/net/irda/irlmp.c linux/net/irda/irlmp.c
@@ -1,15 +1,15 @@
/*********************************************************************
*
* Filename: irlmp.c
- * Version: 0.9
+ * Version: 1.0
* Description: IrDA Link Management Protocol (LMP) layer
* Status: Stable.
* Author: Dag Brattli <dagb@cs.uit.no>
* Created at: Sun Aug 17 20:54:32 1997
- * Modified at: Mon May 31 21:49:41 1999
+ * Modified at: Sun Jan 9 07:43:35 2000
* Modified by: Dag Brattli <dagb@cs.uit.no>
*
- * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
+ * Copyright (c) 1998-2000 Dag Brattli <dagb@cs.uit.no>,
* All Rights Reserved.
*
* This program is free software; you can redistribute it and/or
@@ -32,7 +32,6 @@
#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>
@@ -47,8 +46,9 @@
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_timeout = 3; /* 3 seconds by default */
+int sysctl_discovery_slots = 6; /* 6 slots by default */
char sysctl_devname[65];
char *lmp_reasons[] = {
@@ -61,7 +61,7 @@
"ERROR, NOT USED",
};
-__u8 *irlmp_hint_to_service( __u8 *hint);
+__u8 *irlmp_hint_to_service(__u8 *hint);
#ifdef CONFIG_PROC_FS
int irlmp_proc_read(char *buf, char **start, off_t offst, int len, int unused);
#endif
@@ -69,20 +69,19 @@
/*
* Function irlmp_init (void)
*
- * Create (allocate) the main IrLMP structure and the pointer array
- * which will contain pointers to each instance of a LSAP.
+ * Create (allocate) the main IrLMP structure
+ *
*/
-__initfunc(int irlmp_init(void))
+int __init irlmp_init(void)
{
/* Initialize the irlmp structure. */
- if ( irlmp == NULL) {
- irlmp = kmalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
- if ( irlmp == NULL)
- return -ENOMEM;
- }
- memset( irlmp, 0, sizeof(struct irlmp_cb));
+ irlmp = kmalloc( sizeof(struct irlmp_cb), GFP_KERNEL);
+ if (irlmp == NULL)
+ return -ENOMEM;
+ memset(irlmp, 0, sizeof(struct irlmp_cb));
irlmp->magic = LMP_MAGIC;
+ spin_lock_init(&irlmp->lock);
irlmp->clients = hashbin_new(HB_GLOBAL);
irlmp->services = hashbin_new(HB_GLOBAL);
@@ -90,7 +89,7 @@
irlmp->unconnected_lsaps = hashbin_new(HB_GLOBAL);
irlmp->cachelog = hashbin_new(HB_GLOBAL);
- irlmp->free_lsap_sel = 0x10; /* Servers use 0x00-0x0f */
+ irlmp->free_lsap_sel = 0x10; /* Reserved 0x00-0x0f */
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
irlmp->cache.valid = FALSE;
#endif
@@ -98,7 +97,7 @@
/* Do discovery every 3 seconds */
init_timer(&irlmp->discovery_timer);
- irlmp_start_discovery_timer(irlmp, 600);
+ irlmp_start_discovery_timer(irlmp, sysctl_discovery_timeout*HZ);
return 0;
}
@@ -134,7 +133,7 @@
* 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, notify_t *notify, __u8 pid)
{
struct lsap_cb *self;
@@ -142,42 +141,33 @@
ASSERT(irlmp != NULL, return NULL;);
ASSERT(irlmp->magic == LMP_MAGIC, return NULL;);
- DEBUG(4, __FUNCTION__ "(), slsap_sel=%02x\n", slsap_sel);
-
- /*
- * Does the client care which Source LSAP selector it gets?
- */
+ /* Does the client care which Source LSAP selector it gets? */
if (slsap_sel == LSAP_ANY) {
- /*
- * Find unused LSAP
- */
slsap_sel = irlmp_find_free_slsap();
- if ( slsap_sel == 0)
+ if (!slsap_sel)
return NULL;
- } else {
- /*
- * Client wants specific LSAP, so check if it's already
- * in use
- */
- if (irlmp_slsap_inuse(slsap_sel)) {
- return NULL;
- }
- }
+ } else if (irlmp_slsap_inuse(slsap_sel))
+ return NULL;
- /*
- * Allocate new instance of a LSAP connection
- */
+ /* Allocate new instance of a LSAP connection */
self = kmalloc(sizeof(struct lsap_cb), GFP_ATOMIC);
if (self == NULL) {
- printk( KERN_ERR "IrLMP: Can't allocate memory for "
- "LSAP control block!\n");
+ ERROR(__FUNCTION__ "(), can't allocate memory");
return NULL;
}
memset(self, 0, sizeof(struct lsap_cb));
self->magic = LMP_LSAP_MAGIC;
self->slsap_sel = slsap_sel;
- self->dlsap_sel = LSAP_ANY;
+
+ /* Fix connectionless LSAP's */
+ if (slsap_sel == LSAP_CONNLESS) {
+#ifdef CONFIG_IRDA_ULTRA
+ self->dlsap_sel = LSAP_CONNLESS;
+ self->pid = pid;
+#endif /* CONFIG_IRDA_ULTRA */
+ } else
+ self->dlsap_sel = LSAP_ANY;
self->connected = FALSE;
init_timer(&self->watchdog_timer);
@@ -187,10 +177,8 @@
irlmp_next_lsap_state(self, LSAP_DISCONNECTED);
- /*
- * Insert into queue of unconnected LSAPs
- */
- hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) self, (int) self,
+ /* Insert into queue of unconnected LSAPs */
+ hashbin_insert(irlmp->unconnected_lsaps, (queue_t *) self, (int) self,
NULL);
return self;
@@ -203,7 +191,7 @@
*/
static void __irlmp_close_lsap(struct lsap_cb *self)
{
- DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
ASSERT(self != NULL, return;);
ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
@@ -211,9 +199,12 @@
/*
* Set some of the variables to preset values
*/
- self->magic = ~LMP_LSAP_MAGIC;
+ self->magic = 0;
del_timer(&self->watchdog_timer); /* Important! */
+ if (self->conn_skb)
+ dev_kfree_skb(self->conn_skb);
+
#ifdef CONFIG_IRDA_CACHE_LAST_LSAP
ASSERT(irlmp != NULL, return;);
irlmp->cache.valid = FALSE;
@@ -250,8 +241,8 @@
NULL);
}
if (!lsap) {
- DEBUG(0, __FUNCTION__
- "(), Looks like somebody has removed me already!\n");
+ IRDA_DEBUG(0, __FUNCTION__
+ "(), Looks like somebody has removed me already!\n");
return;
}
__irlmp_close_lsap(self);
@@ -264,13 +255,10 @@
* instances of the IrLAP layer, each connected to different IrDA ports
*
*/
-void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr,
- struct notify_t *notify)
+void irlmp_register_link(struct irlap_cb *irlap, __u32 saddr, notify_t *notify)
{
struct lap_cb *lap;
- DEBUG(4, __FUNCTION__ "(), Registered IrLAP, saddr = %08x\n", saddr);
-
ASSERT(irlmp != NULL, return;);
ASSERT(irlmp->magic == LMP_MAGIC, return;);
ASSERT(notify != NULL, return;);
@@ -280,7 +268,7 @@
*/
lap = kmalloc(sizeof(struct lap_cb), GFP_KERNEL);
if (lap == NULL) {
- DEBUG(3, __FUNCTION__ "(), unable to kmalloc\n");
+ ERROR(__FUNCTION__ "(), unable to kmalloc\n");
return;
}
memset(lap, 0, sizeof(struct lap_cb));
@@ -298,7 +286,7 @@
/*
* Insert into queue of unconnected LSAPs
*/
- hashbin_insert(irlmp->links, (QUEUE *) lap, lap->saddr, NULL);
+ hashbin_insert(irlmp->links, (queue_t *) lap, lap->saddr, NULL);
/*
* We set only this variable so IrLAP can tell us on which link the
@@ -318,7 +306,7 @@
{
struct lap_cb *link;
- DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
link = hashbin_remove(irlmp->links, saddr, NULL);
if (link) {
@@ -349,20 +337,20 @@
struct lsap_cb *lsap;
discovery_t *discovery;
- ASSERT( self != NULL, return -1;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return -1;);
+ ASSERT(self != NULL, return -EBADR;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return -EBADR;);
- DEBUG(2, __FUNCTION__
+ IRDA_DEBUG(2, __FUNCTION__
"(), slsap_sel=%02x, dlsap_sel=%02x, saddr=%08x, daddr=%08x\n",
self->slsap_sel, dlsap_sel, saddr, daddr);
- if ( self->connected)
+ 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);
@@ -378,7 +366,6 @@
skb_push(skb, LMP_CONTROL_HEADER);
self->dlsap_sel = dlsap_sel;
- self->tmp_skb = skb;
/*
* Find the link to where we should try to connect since there may
@@ -389,20 +376,29 @@
* device with the given daddr
*/
if (!saddr) {
- discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
- if (discovery)
+ if (daddr != DEV_ADDR_ANY)
+ discovery = hashbin_find(irlmp->cachelog, daddr, NULL);
+ else {
+ IRDA_DEBUG(2, __FUNCTION__ "(), no daddr\n");
+ discovery = (discovery_t *)
+ hashbin_get_first(irlmp->cachelog);
+ }
+
+ if (discovery) {
saddr = discovery->saddr;
+ daddr = discovery->daddr;
+ }
}
lap = hashbin_find(irlmp->links, saddr, NULL);
if (lap == NULL) {
- DEBUG(1, __FUNCTION__ "(), Unable to find a usable link!\n");
+ IRDA_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");
+ IRDA_DEBUG(0, __FUNCTION__ "(), sorry, but link is busy!\n");
return -EBUSY;
}
@@ -419,7 +415,7 @@
ASSERT(lsap->lap != NULL, return -1;);
ASSERT(lsap->lap->magic == LMP_LAP_MAGIC, return -1;);
- hashbin_insert(self->lap->lsaps, (QUEUE *) self, (int) self, NULL);
+ hashbin_insert(self->lap->lsaps, (queue_t *) self, (int) self, NULL);
self->connected = TRUE;
@@ -451,23 +447,18 @@
ASSERT(skb != NULL, return;);
ASSERT(self->lap != NULL, return;);
- DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
- self->slsap_sel, self->dlsap_sel);
-
+ IRDA_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
+ self->slsap_sel, self->dlsap_sel);
+
self->qos = *self->lap->qos;
max_seg_size = self->lap->qos->data_size.value-LMP_HEADER;
- DEBUG(2, __FUNCTION__ "(), max_seg_size=%d\n", max_seg_size);
-
- lap_header_size = irlap_get_header_size(self->lap->irlap);
-
+ lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
max_header_size = LMP_HEADER + lap_header_size;
- DEBUG(2, __FUNCTION__ "(), max_header_size=%d\n", max_header_size);
-
/* Hide LMP_CONTROL_HEADER header from layer above */
skb_pull(skb, LMP_CONTROL_HEADER);
-
+
if (self->notify.connect_indication)
self->notify.connect_indication(self->notify.instance, self,
&self->qos, max_seg_size,
@@ -480,22 +471,40 @@
* Service user is accepting connection
*
*/
-void irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
+int irlmp_connect_response(struct lsap_cb *self, struct sk_buff *userdata)
{
- ASSERT(self != NULL, return;);
- ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
- ASSERT(userdata != NULL, return;);
-
- self->connected = TRUE;
+ struct sk_buff *skb;
- DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
- self->slsap_sel, self->dlsap_sel);
+ ASSERT(self != NULL, return -1;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
- /* Make room for MUX control header ( 3 bytes) */
- ASSERT(skb_headroom(userdata) >= LMP_CONTROL_HEADER, return;);
- skb_push(userdata, LMP_CONTROL_HEADER);
+ /* Any userdata supplied? */
+ if (!userdata) {
+ skb = dev_alloc_skb(64);
+ if (!skb)
+ return -ENOMEM;
+
+ /* Reserve space for MUX_CONTROL and LAP header */
+ skb_reserve(skb, LMP_MAX_HEADER);
+ } else {
+ skb = userdata;
+ /*
+ * Check that the client has reserved enough space for
+ * headers
+ */
+ ASSERT(skb_headroom(skb) >= LMP_CONTROL_HEADER, return -1;);
+ }
+
+ self->connected = TRUE;
+
+ IRDA_DEBUG(2, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
+ self->slsap_sel, self->dlsap_sel);
- irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, userdata);
+ /* Make room for MUX control header (3 bytes) */
+ skb_push(skb, LMP_CONTROL_HEADER);
+ irlmp_do_lsap_event(self, LM_CONNECT_RESPONSE, skb);
+
+ return 0;
}
/*
@@ -505,34 +514,32 @@
*/
void irlmp_connect_confirm(struct lsap_cb *self, struct sk_buff *skb)
{
- int max_seg_size;
int max_header_size;
int lap_header_size;
+ int max_seg_size;
- DEBUG(3, __FUNCTION__ "()\n");
+ IRDA_DEBUG(3, __FUNCTION__ "()\n");
ASSERT(skb != NULL, return;);
ASSERT(self != NULL, return;);
- ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
-
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
ASSERT(self->lap != NULL, return;);
- self->qos = *self->lap->qos;
- max_seg_size = self->lap->qos->data_size.value-LMP_HEADER;
- DEBUG(2, __FUNCTION__ "(), max_seg_size=%d\n", max_seg_size);
+ self->qos = *self->lap->qos;
- lap_header_size = irlap_get_header_size(self->lap->irlap);
-
+ max_seg_size = self->lap->qos->data_size.value-LMP_HEADER;
+ lap_header_size = IRLAP_GET_HEADER_SIZE(self->lap->irlap);
max_header_size = LMP_HEADER + lap_header_size;
- DEBUG(2, __FUNCTION__ "(), max_header_size=%d\n", max_header_size);
+ IRDA_DEBUG(2, __FUNCTION__ "(), max_header_size=%d\n",
+ max_header_size);
/* Hide LMP_CONTROL_HEADER header from layer above */
skb_pull(skb, LMP_CONTROL_HEADER);
if (self->notify.connect_confirm) {
self->notify.connect_confirm(self->notify.instance, self,
- &self->qos, max_seg_size,
+ &self->qos, max_seg_size,
max_header_size, skb);
}
}
@@ -548,16 +555,16 @@
{
struct lsap_cb *new;
- DEBUG(1, __FUNCTION__ "()\n");
+ IRDA_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");
+ IRDA_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");
+ IRDA_DEBUG(0, __FUNCTION__ "(), unable to kmalloc\n");
return NULL;
}
/* Dup */
@@ -566,7 +573,7 @@
init_timer(&new->watchdog_timer);
- hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) new, (int) new,
+ hashbin_insert(irlmp->unconnected_lsaps, (queue_t *) new, (int) new,
NULL);
/* Make sure that we invalidate the cache */
@@ -583,53 +590,53 @@
* 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)
+int irlmp_disconnect_request(struct lsap_cb *self, struct sk_buff *userdata)
{
struct lsap_cb *lsap;
- DEBUG( 4, __FUNCTION__ "()\n");
-
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(self != NULL, return -1;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
/* Already disconnected? */
- if ( !self->connected) {
- DEBUG( 1, __FUNCTION__ "(), already disconnected!\n");
- return;
+ if (!self->connected) {
+ WARNING(__FUNCTION__ "(), already disconnected!\n");
+ return -1;
}
- ASSERT( userdata != NULL, return;);
- ASSERT( self->connected == TRUE, return;);
+ ASSERT(userdata != NULL, return -1;);
+ ASSERT(self->connected == TRUE, return -1;);
- skb_push( userdata, LMP_CONTROL_HEADER);
+ skb_push(userdata, LMP_CONTROL_HEADER);
/*
* Do the event before the other stuff since we must know
* which lap layer that the frame should be transmitted on
*/
- irlmp_do_lsap_event( self, LM_DISCONNECT_REQUEST, userdata);
+ irlmp_do_lsap_event(self, LM_DISCONNECT_REQUEST, userdata);
/*
* Remove LSAP from list of connected LSAPs for the particular link
* and insert it into the list of unconnected LSAPs
*/
- ASSERT( self->lap != NULL, return;);
- ASSERT( self->lap->magic == LMP_LAP_MAGIC, return;);
- ASSERT( self->lap->lsaps != NULL, return;);
+ ASSERT(self->lap != NULL, return -1;);
+ ASSERT(self->lap->magic == LMP_LAP_MAGIC, return -1;);
+ ASSERT(self->lap->lsaps != NULL, return -1;);
lsap = hashbin_remove(self->lap->lsaps, (int) self, NULL);
- ASSERT( lsap != NULL, return;);
- ASSERT( lsap->magic == LMP_LSAP_MAGIC, return;);
- ASSERT( lsap == self, return;);
+ ASSERT(lsap != NULL, return -1;);
+ ASSERT(lsap->magic == LMP_LSAP_MAGIC, return -1;);
+ ASSERT(lsap == self, return -1;);
- hashbin_insert(irlmp->unconnected_lsaps, (QUEUE *) self, (int) self,
+ hashbin_insert(irlmp->unconnected_lsaps, (queue_t *) self, (int) self,
NULL);
/* Reset some values */
self->connected = FALSE;
self->dlsap_sel = LSAP_ANY;
self->lap = NULL;
+
+ return 0;
}
/*
@@ -642,14 +649,13 @@
{
struct lsap_cb *lsap;
- DEBUG( 1, __FUNCTION__ "(), reason=%s\n", lmp_reasons[reason]);
-
- ASSERT( self != NULL, return;);
- ASSERT( self->magic == LMP_LSAP_MAGIC, return;);
- ASSERT( self->connected == TRUE, return;);
+ IRDA_DEBUG(1, __FUNCTION__ "(), reason=%s\n", lmp_reasons[reason]);
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(self->connected == TRUE, return;);
- DEBUG( 3, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
- self->slsap_sel, self->dlsap_sel);
+ IRDA_DEBUG(3, __FUNCTION__ "(), slsap_sel=%02x, dlsap_sel=%02x\n",
+ self->slsap_sel, self->dlsap_sel);
self->connected = FALSE;
self->dlsap_sel = LSAP_ANY;
@@ -661,14 +667,14 @@
/*
* Remove association between this LSAP and the link it used
*/
- ASSERT( self->lap != NULL, return;);
- ASSERT( self->lap->lsaps != NULL, return;);
+ ASSERT(self->lap != NULL, return;);
+ ASSERT(self->lap->lsaps != NULL, return;);
- lsap = hashbin_remove( self->lap->lsaps, (int) self, 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, (int) lsap,
+ ASSERT(lsap != NULL, return;);
+ ASSERT(lsap == self, return;);
+ hashbin_insert(irlmp->unconnected_lsaps, (queue_t *) lsap, (int) lsap,
NULL);
self->lap = NULL;
@@ -676,9 +682,12 @@
/*
* Inform service user
*/
- if ( self->notify.disconnect_indication) {
- self->notify.disconnect_indication( self->notify.instance,
- self, reason, userdata);
+ if (self->notify.disconnect_indication)
+ self->notify.disconnect_indication(self->notify.instance,
+ self, reason, userdata);
+ else {
+ IRDA_DEBUG(0, __FUNCTION__ "(), no handler\n");
+ dev_kfree_skb(userdata);
}
}
@@ -692,9 +701,9 @@
{
struct lap_cb *lap;
- /* Make sure value is sane */
- if ((nslots != 1) && (nslots != 6) && (nslots != 8)&&(nslots != 16)) {
- printk(KERN_WARNING __FUNCTION__
+ /* Make sure the value is sane */
+ if ((nslots != 1) && (nslots != 6) && (nslots != 8) && (nslots != 16)){
+ WARNING(__FUNCTION__
"(), invalid value for number of slots!\n");
nslots = sysctl_discovery_slots = 8;
}
@@ -708,8 +717,9 @@
* 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.nickname, sysctl_devname,
+ NICKNAME_MAX_LEN);
+ irlmp->discovery_cmd.name_len = strlen(irlmp->discovery_cmd.nickname);
irlmp->discovery_cmd.nslots = nslots;
/*
@@ -740,21 +750,18 @@
*/
void irlmp_discovery_request(int nslots)
{
- DEBUG(4, __FUNCTION__ "(), nslots=%d\n", nslots);
-
/* Check if user wants to override the default */
if (nslots == DISCOVERY_DEFAULT_SLOTS)
nslots = sysctl_discovery_slots;
+ /* Return current cached discovery log */
+ irlmp_discovery_confirm(irlmp->cachelog);
+
/*
- * If discovery is already running, then just return the current
- * discovery log
+ * Start a single discovery operation if discovery is not already
+ * running
*/
- if (sysctl_discovery) {
- DEBUG(2, __FUNCTION__ "() discovery already running, so we"
- " just return the old discovery log!\n");
- irlmp_discovery_confirm(irlmp->cachelog);
- } else
+ if (!sysctl_discovery)
irlmp_do_discovery(nslots);
}
@@ -773,8 +780,8 @@
__u8 service;
int i = 0;
- DEBUG(1, "IrDA Discovered: %s\n", discovery->info);
- DEBUG(1, " Services: ");
+ IRDA_DEBUG(1, "IrDA Discovered: %s\n", discovery->info);
+ IRDA_DEBUG(1, " Services: ");
service_log = irlmp_hint_to_service(discovery->hints.byte);
if (!service_log)
@@ -784,10 +791,10 @@
* Check all services on the device
*/
while ((service = service_log[i++]) != S_END) {
- DEBUG( 4, "service=%02x\n", service);
+ IRDA_DEBUG( 4, "service=%02x\n", service);
client = hashbin_find(irlmp->registry, service, NULL);
if (entry && entry->discovery_callback) {
- DEBUG( 4, "discovery_callback!\n");
+ IRDA_DEBUG( 4, "discovery_callback!\n");
entry->discovery_callback(discovery);
} else {
@@ -819,7 +826,7 @@
{
discovery_t *discovery;
- DEBUG(3, __FUNCTION__ "()\n");
+ IRDA_DEBUG(3, __FUNCTION__ "()\n");
/* Check if client wants the whole log */
if (client->callback2)
@@ -831,9 +838,13 @@
*/
discovery = (discovery_t *) hashbin_get_first(log);
while (discovery != NULL) {
- DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr);
+ IRDA_DEBUG(3, "discovery->daddr = 0x%08x\n", discovery->daddr);
- if (client->hint_mask & discovery->hints.word) {
+ /*
+ * Any common hint bits? Remember to mask away the extension
+ * bits ;-)
+ */
+ if (client->hint_mask & discovery->hints.word & 0x7f7f) {
if (client->callback1)
client->callback1(discovery);
}
@@ -852,11 +863,11 @@
{
irlmp_client_t *client;
- DEBUG(3, __FUNCTION__ "()\n");
+ IRDA_DEBUG(3, __FUNCTION__ "()\n");
ASSERT(log != NULL, return;);
- if (!hashbin_get_size(log))
+ if (!(HASHBIN_GET_SIZE(log)))
return;
client = (irlmp_client_t *) hashbin_get_first(irlmp->clients);
@@ -876,7 +887,7 @@
*/
discovery_t *irlmp_get_discovery_response()
{
- DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
ASSERT(irlmp != NULL, return NULL;);
@@ -889,8 +900,9 @@
*/
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.nickname, sysctl_devname,
+ NICKNAME_MAX_LEN);
+ irlmp->discovery_rsp.name_len = strlen(irlmp->discovery_rsp.nickname);
return &irlmp->discovery_rsp;
}
@@ -901,17 +913,16 @@
* Send some data to peer device
*
*/
-void irlmp_data_request(struct lsap_cb *self, struct sk_buff *skb)
+int irlmp_data_request(struct lsap_cb *self, struct sk_buff *skb)
{
- ASSERT(skb != NULL, return;);
- ASSERT(self != NULL, return;);
- ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(self != NULL, return -1;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return -1;);
/* Make room for MUX header */
- ASSERT(skb_headroom( skb) >= LMP_HEADER, return;);
+ ASSERT(skb_headroom(skb) >= LMP_HEADER, return -1;);
skb_push(skb, LMP_HEADER);
-
- irlmp_do_lsap_event(self, LM_DATA_REQUEST, skb);
+
+ return irlmp_do_lsap_event(self, LM_DATA_REQUEST, skb);
}
/*
@@ -920,13 +931,15 @@
* Got data from LAP layer so pass it up to upper layer
*
*/
-inline void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
+void irlmp_data_indication(struct lsap_cb *self, struct sk_buff *skb)
{
/* Hide LMP header from layer above */
skb_pull(skb, LMP_HEADER);
if (self->notify.data_indication)
self->notify.data_indication(self->notify.instance, self, skb);
+ else
+ dev_kfree_skb(skb);
}
/*
@@ -935,17 +948,17 @@
*
*
*/
-inline void irlmp_udata_request( struct lsap_cb *self, struct sk_buff *skb)
+int irlmp_udata_request(struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
- ASSERT( skb != NULL, return;);
+ ASSERT(skb != NULL, return -1;);
/* Make room for MUX header */
- ASSERT( skb_headroom( skb) >= LMP_HEADER, return;);
- skb_push( skb, LMP_HEADER);
+ ASSERT(skb_headroom(skb) >= LMP_HEADER, return -1;);
+ skb_push(skb, LMP_HEADER);
- irlmp_do_lsap_event( self, LM_UDATA_REQUEST, skb);
+ return irlmp_do_lsap_event(self, LM_UDATA_REQUEST, skb);
}
/*
@@ -954,51 +967,104 @@
* Send unreliable data (but still within the connection)
*
*/
-void irlmp_udata_indication( struct lsap_cb *self, struct sk_buff *skb)
+void irlmp_udata_indication(struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 4, __FUNCTION__ "()\n");
+ IRDA_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.udata_indication)
- self->notify.udata_indication(self->notify.instance, self, skb);
+ self->notify.udata_indication(self->notify.instance, self,
+ skb);
+ else
+ dev_kfree_skb(skb);
}
/*
- * Function irlmp_connection_less_data_request (skb)
+ * Function irlmp_connless_data_request (self, skb)
*
- * Send out of connection UI frames
+ *
*
*/
-void irlmp_connectionless_data_request( struct sk_buff *skb)
+#ifdef CONFIG_IRDA_ULTRA
+int irlmp_connless_data_request(struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 1, __FUNCTION__ "(), Sorry not implemented\n");
+ struct sk_buff *clone_skb;
+ struct lap_cb *lap;
+
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
+
+ ASSERT(skb != NULL, return -1;);
+
+ /* Make room for MUX and PID header */
+ ASSERT(skb_headroom(skb) >= LMP_HEADER+LMP_PID_HEADER, return -1;);
+
+ /* Insert protocol identifier */
+ skb_push(skb, LMP_PID_HEADER);
+ skb->data[0] = self->pid;
+
+ /* Connectionless sockets must use 0x70 */
+ skb_push(skb, LMP_HEADER);
+ skb->data[0] = skb->data[1] = LSAP_CONNLESS;
+
+ /* Try to send Connectionless packets out on all links */
+ lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
+ while (lap != NULL) {
+ ASSERT(lap->magic == LMP_LAP_MAGIC, return -1;);
+
+ clone_skb = skb_clone(skb, GFP_ATOMIC);
+ if (!clone_skb)
+ return -ENOMEM;
+
+ irlap_unitdata_request(lap->irlap, clone_skb);
+
+ lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
+ }
+ dev_kfree_skb(skb);
+
+ return 0;
}
+#endif /* CONFIG_IRDA_ULTRA */
/*
- * Function irlmp_connection_less_data_indication (skb)
+ * Function irlmp_connless_data_indication (self, skb)
*
- *
+ * Receive unreliable data outside any connection. Mostly used by Ultra
*
*/
-void irlmp_connectionless_data_indication( struct sk_buff *skb)
+#ifdef CONFIG_IRDA_ULTRA
+void irlmp_connless_data_indication(struct lsap_cb *self, struct sk_buff *skb)
{
- DEBUG( 1, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
+
+ ASSERT(self != NULL, return;);
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return;);
+ ASSERT(skb != NULL, return;);
+
+ /* Hide LMP and PID header from layer above */
+ skb_pull(skb, LMP_HEADER+LMP_PID_HEADER);
+
+ if (self->notify.udata_indication)
+ self->notify.udata_indication(self->notify.instance, self,
+ skb);
+ else
+ dev_kfree_skb(skb);
}
+#endif /* CONFIG_IRDA_ULTRA */
void irlmp_status_request(void)
{
- DEBUG( 1, "irlmp_status_request(), Not implemented\n");
+ IRDA_DEBUG(0, __FUNCTION__ "(), Not implemented\n");
}
void irlmp_status_indication(LINK_STATUS link, LOCK_STATUS lock)
{
- DEBUG( 4, "irlmp_status_indication(), Not implemented\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), Not implemented\n");
}
/*
@@ -1016,32 +1082,33 @@
* Allocate array to store services in. 16 entries should be safe
* since we currently only support 2 hint bytes
*/
- service = kmalloc( 16, GFP_ATOMIC);
- if ( !service) {
- DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
+ service = kmalloc(16, GFP_ATOMIC);
+ if (!service) {
+ IRDA_DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
return NULL;
}
- if ( !hint[0]) {
- DEBUG(1, "<None>\n");
+ if (!hint[0]) {
+ IRDA_DEBUG(1, "<None>\n");
+ kfree(service);
return NULL;
}
- if ( hint[0] & HINT_PNP)
- DEBUG(1, "PnP Compatible ");
- if ( hint[0] & HINT_PDA)
- DEBUG(1, "PDA/Palmtop ");
- if ( hint[0] & HINT_COMPUTER)
- DEBUG(1, "Computer ");
- if ( hint[0] & HINT_PRINTER) {
- DEBUG(1, "Printer ");
+ if (hint[0] & HINT_PNP)
+ IRDA_DEBUG(1, "PnP Compatible ");
+ if (hint[0] & HINT_PDA)
+ IRDA_DEBUG(1, "PDA/Palmtop ");
+ if (hint[0] & HINT_COMPUTER)
+ IRDA_DEBUG(1, "Computer ");
+ if (hint[0] & HINT_PRINTER) {
+ IRDA_DEBUG(1, "Printer ");
service[i++] = S_PRINTER;
}
- if ( hint[0] & HINT_MODEM)
- DEBUG(1, "Modem ");
- if ( hint[0] & HINT_FAX)
- DEBUG(1, "Fax ");
- if ( hint[0] & HINT_LAN) {
- DEBUG(1, "LAN Access ");
+ if (hint[0] & HINT_MODEM)
+ IRDA_DEBUG(1, "Modem ");
+ if (hint[0] & HINT_FAX)
+ IRDA_DEBUG(1, "Fax ");
+ if (hint[0] & HINT_LAN) {
+ IRDA_DEBUG(1, "LAN Access ");
service[i++] = S_LAN;
}
/*
@@ -1049,23 +1116,23 @@
* there, but this is not really required by the standard.
* (IrLMP p. 29)
*/
- if ( hint[0] & HINT_EXTENSION) {
- if ( hint[1] & HINT_TELEPHONY) {
- DEBUG(1, "Telephony ");
+ if (hint[0] & HINT_EXTENSION) {
+ if (hint[1] & HINT_TELEPHONY) {
+ IRDA_DEBUG(1, "Telephony ");
service[i++] = S_TELEPHONY;
- } if ( hint[1] & HINT_FILE_SERVER)
- DEBUG(1, "File Server ");
+ } if (hint[1] & HINT_FILE_SERVER)
+ IRDA_DEBUG(1, "File Server ");
- if ( hint[1] & HINT_COMM) {
- DEBUG(1, "IrCOMM ");
+ if (hint[1] & HINT_COMM) {
+ IRDA_DEBUG(1, "IrCOMM ");
service[i++] = S_COMM;
}
- if ( hint[1] & HINT_OBEX) {
- DEBUG(1, "IrOBEX ");
+ if (hint[1] & HINT_OBEX) {
+ IRDA_DEBUG(1, "IrOBEX ");
service[i++] = S_OBEX;
}
}
- DEBUG(1, "\n");
+ IRDA_DEBUG(1, "\n");
/* So that client can be notified about any discovery */
service[i++] = S_ANY;
@@ -1115,11 +1182,15 @@
hint.byte[0] |= HINT_EXTENSION;
hint.byte[1] |= HINT_OBEX;
break;
+ case S_TELEPHONY:
+ hint.byte[0] |= HINT_EXTENSION;
+ hint.byte[1] |= HINT_TELEPHONY;
+ break;
case S_ANY:
hint.word = 0xffff;
break;
default:
- DEBUG( 1, __FUNCTION__ "(), Unknown service!\n");
+ IRDA_DEBUG( 1, __FUNCTION__ "(), Unknown service!\n");
break;
}
return hint.word;
@@ -1136,7 +1207,7 @@
irlmp_service_t *service;
__u32 handle;
- DEBUG(4, __FUNCTION__ "(), hints = %04x\n", hints);
+ IRDA_DEBUG(4, __FUNCTION__ "(), hints = %04x\n", hints);
/* Get a unique handle for this service */
get_random_bytes(&handle, sizeof(handle));
@@ -1148,11 +1219,11 @@
/* Make a new registration */
service = kmalloc(sizeof(irlmp_service_t), GFP_ATOMIC);
if (!service) {
- DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), Unable to kmalloc!\n");
return 0;
}
service->hints = hints;
- hashbin_insert(irlmp->services, (QUEUE*) service, handle, NULL);
+ hashbin_insert(irlmp->services, (queue_t *) service, handle, NULL);
return handle;
}
@@ -1168,14 +1239,14 @@
{
irlmp_service_t *service;
- DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
if (!handle)
return -1;
service = hashbin_find(irlmp->services, handle, NULL);
if (!service) {
- DEBUG(1, __FUNCTION__ "(), Unknown service!\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), Unknown service!\n");
return -1;
}
@@ -1217,7 +1288,7 @@
/* Make a new registration */
client = kmalloc(sizeof(irlmp_client_t), GFP_ATOMIC);
if (!client) {
- DEBUG( 1, __FUNCTION__ "(), Unable to kmalloc!\n");
+ IRDA_DEBUG( 1, __FUNCTION__ "(), Unable to kmalloc!\n");
return 0;
}
@@ -1227,7 +1298,7 @@
client->callback1 = callback1;
client->callback2 = callback2;
- hashbin_insert(irlmp->clients, (QUEUE *) client, handle, NULL);
+ hashbin_insert(irlmp->clients, (queue_t *) client, handle, NULL);
return handle;
}
@@ -1251,7 +1322,7 @@
client = hashbin_find(irlmp->clients, handle, NULL);
if (!client) {
- DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
return -1;
}
@@ -1272,18 +1343,18 @@
{
struct irlmp_client *client;
- DEBUG(4, __FUNCTION__ "()\n");
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
if (!handle)
return -1;
client = hashbin_find(irlmp->clients, handle, NULL);
if (!client) {
- DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), Unknown client!\n");
return -1;
}
- DEBUG( 4, __FUNCTION__ "(), removing client!\n");
+ IRDA_DEBUG( 4, __FUNCTION__ "(), removing client!\n");
client = hashbin_remove( irlmp->clients, handle, NULL);
if (client)
kfree(client);
@@ -1296,19 +1367,25 @@
*
* Check if the given source LSAP selector is in use
*/
-int irlmp_slsap_inuse( __u8 slsap_sel)
+int irlmp_slsap_inuse(__u8 slsap_sel)
{
struct lsap_cb *self;
struct lap_cb *lap;
- ASSERT( irlmp != NULL, return TRUE;);
- ASSERT( irlmp->magic == LMP_MAGIC, return TRUE;);
- ASSERT( slsap_sel != LSAP_ANY, return TRUE;);
-
- DEBUG( 4, __FUNCTION__ "()\n");
+ ASSERT(irlmp != NULL, return TRUE;);
+ ASSERT(irlmp->magic == LMP_MAGIC, return TRUE;);
+ ASSERT(slsap_sel != LSAP_ANY, return TRUE;);
+
+ IRDA_DEBUG(4, __FUNCTION__ "()\n");
+
+#ifdef CONFIG_IRDA_ULTRA
+ /* Accept all bindings to the connectionless LSAP */
+ if (slsap_sel == LSAP_CONNLESS)
+ return FALSE;
+#endif /* CONFIG_IRDA_ULTRA */
/* Valid values are between 0 and 127 */
- if (slsap_sel > 127)
+ if (slsap_sel > LSAP_MAX)
return TRUE;
/*
@@ -1324,16 +1401,14 @@
while (self != NULL) {
ASSERT(self->magic == LMP_LSAP_MAGIC, return TRUE;);
- if ((self->slsap_sel == slsap_sel))/* && */
-/* ( self->dlsap_sel == LSAP_ANY)) */
- {
- DEBUG( 4, "Source LSAP selector=%02x in use\n",
- self->slsap_sel);
+ if ((self->slsap_sel == slsap_sel)) {
+ IRDA_DEBUG(4, "Source LSAP selector=%02x in use\n",
+ self->slsap_sel);
return TRUE;
}
- self = (struct lsap_cb*) hashbin_get_next( lap->lsaps);
+ self = (struct lsap_cb*) hashbin_get_next(lap->lsaps);
}
- lap = (struct lap_cb *) hashbin_get_next( irlmp->links);
+ lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
}
return FALSE;
}
@@ -1358,8 +1433,8 @@
while (irlmp_slsap_inuse(irlmp->free_lsap_sel)) {
irlmp->free_lsap_sel++;
- /* Check if we need to wraparound */
- if (irlmp->free_lsap_sel > 127) {
+ /* Check if we need to wraparound (0x70-0x7f are reserved) */
+ if (irlmp->free_lsap_sel > LSAP_MAX) {
irlmp->free_lsap_sel = 10;
/* Make sure we terminate the loop */
@@ -1367,7 +1442,7 @@
return 0;
}
}
- DEBUG(4, __FUNCTION__ "(), next free lsap_sel=%02x\n", lsap_sel);
+ IRDA_DEBUG(4, __FUNCTION__ "(), next free lsap_sel=%02x\n", lsap_sel);
return lsap_sel;
}
@@ -1385,26 +1460,26 @@
switch (lap_reason) {
case LAP_DISC_INDICATION: /* Received a disconnect request from peer */
- DEBUG( 1, __FUNCTION__ "(), LAP_DISC_INDICATION\n");
+ IRDA_DEBUG( 1, __FUNCTION__ "(), LAP_DISC_INDICATION\n");
reason = LM_USER_REQUEST;
break;
case LAP_NO_RESPONSE: /* To many retransmits without response */
- DEBUG( 1, __FUNCTION__ "(), LAP_NO_RESPONSE\n");
+ IRDA_DEBUG( 1, __FUNCTION__ "(), LAP_NO_RESPONSE\n");
reason = LM_LAP_DISCONNECT;
break;
case LAP_RESET_INDICATION:
- DEBUG( 1, __FUNCTION__ "(), LAP_RESET_INDICATION\n");
+ IRDA_DEBUG( 1, __FUNCTION__ "(), LAP_RESET_INDICATION\n");
reason = LM_LAP_RESET;
break;
case LAP_FOUND_NONE:
case LAP_MEDIA_BUSY:
case LAP_PRIMARY_CONFLICT:
- DEBUG( 1, __FUNCTION__ "(), LAP_FOUND_NONE, LAP_MEDIA_BUSY or LAP_PRIMARY_CONFLICT\n");
+ IRDA_DEBUG(1, __FUNCTION__ "(), LAP_FOUND_NONE, LAP_MEDIA_BUSY or LAP_PRIMARY_CONFLICT\n");
reason = LM_CONNECT_FAILURE;
break;
default:
- DEBUG( 1, __FUNCTION__
- "(), Unknow IrLAP disconnect reason %d!\n", lap_reason);
+ IRDA_DEBUG(1, __FUNCTION__
+ "(), Unknow IrLAP disconnect reason %d!\n", lap_reason);
reason = LM_LAP_DISCONNECT;
break;
}
@@ -1414,8 +1489,6 @@
__u32 irlmp_get_saddr(struct lsap_cb *self)
{
- DEBUG(3, __FUNCTION__ "()\n");
-
ASSERT(self != NULL, return 0;);
ASSERT(self->lap != NULL, return 0;);
@@ -1424,8 +1497,6 @@
__u32 irlmp_get_daddr(struct lsap_cb *self)
{
- DEBUG(3, __FUNCTION__ "()\n");
-
ASSERT(self != NULL, return 0;);
ASSERT(self->lap != NULL, return 0;);
@@ -1455,21 +1526,21 @@
len += sprintf( buf+len, "Unconnected LSAPs:\n");
self = (struct lsap_cb *) hashbin_get_first( irlmp->unconnected_lsaps);
- while ( self != NULL) {
- ASSERT( self->magic == LMP_LSAP_MAGIC, return 0;);
- len += sprintf( buf+len, "lsap state: %s, ",
- irlsap_state[ self->lsap_state]);
- len += sprintf( buf+len,
- "slsap_sel: %#02x, dlsap_sel: %#02x, ",
- self->slsap_sel, self->dlsap_sel);
- len += sprintf( buf+len, "(%s)", self->notify.name);
- len += sprintf( buf+len, "\n");
+ while (self != NULL) {
+ ASSERT(self->magic == LMP_LSAP_MAGIC, return 0;);
+ len += sprintf(buf+len, "lsap state: %s, ",
+ irlsap_state[ self->lsap_state]);
+ len += sprintf(buf+len,
+ "slsap_sel: %#02x, dlsap_sel: %#02x, ",
+ self->slsap_sel, self->dlsap_sel);
+ len += sprintf(buf+len, "(%s)", self->notify.name);
+ len += sprintf(buf+len, "\n");
- self = ( struct lsap_cb *) hashbin_get_next(
+ self = (struct lsap_cb *) hashbin_get_next(
irlmp->unconnected_lsaps);
}
- len += sprintf( buf+len, "\nRegistred Link Layers:\n");
+ len += sprintf(buf+len, "\nRegistred Link Layers:\n");
lap = (struct lap_cb *) hashbin_get_first(irlmp->links);
while (lap != NULL) {
@@ -1478,10 +1549,11 @@
len += sprintf(buf+len, "saddr: %#08x, daddr: %#08x, ",
lap->saddr, lap->daddr);
+ len += sprintf(buf+len, "refcount: %d", lap->refcount);
len += sprintf(buf+len, "\n");
- len += sprintf( buf+len, "\nConnected LSAPs:\n");
- self = (struct lsap_cb *) hashbin_get_first( lap->lsaps);
+ len += sprintf(buf+len, "\nConnected LSAPs:\n");
+ self = (struct lsap_cb *) hashbin_get_first(lap->lsaps);
while (self != NULL) {
ASSERT(self->magic == LMP_LSAP_MAGIC, return 0;);
len += sprintf(buf+len, "lsap state: %s, ",
@@ -1499,9 +1571,8 @@
lap = (struct lap_cb *) hashbin_get_next(irlmp->links);
}
-
- restore_flags( flags);
-
+ restore_flags(flags);
+
return len;
}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)