Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 576 insertions, 0 deletions

diff --git a/net/irda/irlan/irlan_client.c b/net/irda/irlan/irlan_client.c
new file mode 100644
index 000000000000..f8e6cb0db04b
--- /dev/null
+++ b/net/irda/irlan/irlan_client.c
@@ -0,0 +1,576 @@
+/*********************************************************************
+ *                
+ * Filename:      irlan_client.c
+ * Version:       0.9
+ * Description:   IrDA LAN Access Protocol (IrLAN) Client
+ * Status:        Experimental.
+ * Author:        Dag Brattli <dagb@cs.uit.no>
+ * Created at:    Sun Aug 31 20:14:37 1997
+ * Modified at:   Tue Dec 14 15:47:02 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/init.h>
+#include <linux/netdevice.h>
+#include <linux/etherdevice.h>
+#include <linux/if_arp.h>
+#include <linux/bitops.h>
+#include <net/arp.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_event.h>
+#include <net/irda/irlan_eth.h>
+#include <net/irda/irlan_provider.h>
+#include <net/irda/irlan_client.h>
+
+#undef CONFIG_IRLAN_GRATUITOUS_ARP
+
+static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap, 
+                                                    LM_REASON reason, 
+                                                    struct sk_buff *);
+static int irlan_client_ctrl_data_indication(void *instance, void *sap, 
+                                             struct sk_buff *skb);
+static void irlan_client_ctrl_connect_confirm(void *instance, void *sap, 
+                                              struct qos_info *qos, 
+                                              __u32 max_sdu_size,
+                                              __u8 max_header_size,
+                                              struct sk_buff *);
+static void irlan_check_response_param(struct irlan_cb *self, char *param, 
+                                       char *value, int val_len);
+static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
+
+static void irlan_client_kick_timer_expired(void *data)
+{
+        struct irlan_cb *self = (struct irlan_cb *) data;
+        
+        IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
+
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+        
+        /*  
+         * 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 to, but only if the provider is not IDLE
+         */
+        if ((self->provider.access_type == ACCESS_PEER) && 
+            (self->client.state == IRLAN_IDLE) &&
+            (self->provider.state != IRLAN_IDLE)) {
+                irlan_client_wakeup(self, self->saddr, self->daddr);
+        }
+}
+
+static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
+{
+        IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
+        
+        irda_start_timer(&self->client.kick_timer, timeout, (void *) self, 
+                         irlan_client_kick_timer_expired);
+}
+
+/*
+ * Function irlan_client_wakeup (self, saddr, daddr)
+ *
+ *    Wake up client
+ *
+ */
+void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr)
+{
+        IRDA_DEBUG(1, "%s()\n", __FUNCTION__ );
+
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+        /* 
+         * Check if we are already awake, or if we are a provider in direct
+         * mode (in that case we must leave the client idle
+         */
+        if ((self->client.state != IRLAN_IDLE) || 
+            (self->provider.access_type == ACCESS_DIRECT))
+        {
+                        IRDA_DEBUG(0, "%s(), already awake!\n", __FUNCTION__ );
+                        return;
+        }
+
+        /* Addresses may have changed! */
+        self->saddr = saddr;
+        self->daddr = daddr;
+
+        if (self->disconnect_reason == LM_USER_REQUEST) {
+                        IRDA_DEBUG(0, "%s(), still stopped by user\n", __FUNCTION__ );
+                        return;
+        }
+
+        /* Open TSAPs */
+        irlan_client_open_ctrl_tsap(self);
+        irlan_open_data_tsap(self);
+
+        irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);
+        
+        /* Start kick timer */
+        irlan_client_start_kick_timer(self, 2*HZ);
+}
+
+/*
+ * Function irlan_discovery_indication (daddr)
+ *
+ *    Remote device with IrLAN server support discovered
+ *
+ */
+void irlan_client_discovery_indication(discinfo_t *discovery,
+                                       DISCOVERY_MODE mode,
+                                       void *priv) 
+{
+        struct irlan_cb *self;
+        __u32 saddr, daddr;
+        
+        IRDA_DEBUG(1, "%s()\n", __FUNCTION__ );
+
+        IRDA_ASSERT(discovery != NULL, return;);
+
+        /*
+         * I didn't check it, but I bet that IrLAN suffer from the same
+         * deficiency as IrComm and doesn't handle two instances
+         * simultaneously connecting to each other.
+         * Same workaround, drop passive discoveries.
+         * Jean II */
+        if(mode == DISCOVERY_PASSIVE)
+                return;
+
+        saddr = discovery->saddr;
+        daddr = discovery->daddr;
+
+        /* Find instance */
+        rcu_read_lock();
+        self = irlan_get_any();
+        if (self) {
+                IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+                IRDA_DEBUG(1, "%s(), Found instance (%08x)!\n", __FUNCTION__ ,
+                      daddr);
+                
+                irlan_client_wakeup(self, saddr, daddr);
+        }
+        rcu_read_unlock();
+}
+        
+/*
+ * Function irlan_client_data_indication (handle, skb)
+ *
+ *    This function gets the data that is received on the control channel
+ *
+ */
+static int irlan_client_ctrl_data_indication(void *instance, void *sap, 
+                                             struct sk_buff *skb)
+{
+        struct irlan_cb *self;
+        
+        IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
+        
+        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;);
+        
+        irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb); 
+
+        /* Ready for a new command */   
+        IRDA_DEBUG(2, "%s(), clearing tx_busy\n", __FUNCTION__ );
+        self->client.tx_busy = FALSE;
+
+        /* Check if we have some queued commands waiting to be sent */
+        irlan_run_ctrl_tx_queue(self);
+
+        return 0;
+}
+
+static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap, 
+                                                    LM_REASON reason, 
+                                                    struct sk_buff *userdata) 
+{
+        struct irlan_cb *self;
+        struct tsap_cb *tsap;
+        struct sk_buff *skb;
+
+        IRDA_DEBUG(4, "%s(), reason=%d\n", __FUNCTION__ , 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->client.tsap_ctrl, return;);
+
+        /* Remove frames queued on the control channel */
+        while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
+                dev_kfree_skb(skb);
+        }
+        self->client.tx_busy = FALSE;
+
+        irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
+}
+
+/*
+ * Function irlan_client_open_tsaps (self)
+ *
+ *    Initialize callbacks and open IrTTP TSAPs
+ *
+ */
+static void irlan_client_open_ctrl_tsap(struct irlan_cb *self)
+{
+        struct tsap_cb *tsap;
+        notify_t notify;
+
+        IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
+
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+        /* Check if already open */
+        if (self->client.tsap_ctrl)
+                return;
+
+        irda_notify_init(&notify);
+
+        /* Set up callbacks */
+        notify.data_indication       = irlan_client_ctrl_data_indication;
+        notify.connect_confirm       = irlan_client_ctrl_connect_confirm;
+        notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
+        notify.instance = self;
+        strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));
+        
+        tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, &notify);
+        if (!tsap) {
+                IRDA_DEBUG(2, "%s(), Got no tsap!\n", __FUNCTION__ );
+                return;
+        }
+        self->client.tsap_ctrl = tsap;
+}
+
+/*
+ * Function irlan_client_connect_confirm (handle, skb)
+ *
+ *    Connection to peer IrLAN laye confirmed
+ *
+ */
+static void irlan_client_ctrl_connect_confirm(void *instance, void *sap, 
+                                              struct qos_info *qos, 
+                                              __u32 max_sdu_size,
+                                              __u8 max_header_size,
+                                              struct sk_buff *skb) 
+{
+        struct irlan_cb *self;
+
+        IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
+
+        self = (struct irlan_cb *) instance;
+
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+        self->client.max_sdu_size = max_sdu_size;
+        self->client.max_header_size = max_header_size;
+
+        /* TODO: we could set the MTU depending on the max_sdu_size */
+
+        irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL);
+}
+
+/*
+ * Function print_ret_code (code)
+ *
+ *    Print return code of request to peer IrLAN layer.
+ *
+ */
+static void print_ret_code(__u8 code) 
+{
+        switch(code) {
+        case 0:
+                printk(KERN_INFO "Success\n");
+                break;
+        case 1:
+                IRDA_WARNING("IrLAN: Insufficient resources\n");
+                break;
+        case 2:
+                IRDA_WARNING("IrLAN: Invalid command format\n");
+                break;
+        case 3:
+                IRDA_WARNING("IrLAN: Command not supported\n");
+                break;
+        case 4:
+                IRDA_WARNING("IrLAN: Parameter not supported\n");
+                break;
+        case 5:
+                IRDA_WARNING("IrLAN: Value not supported\n");
+                break;
+        case 6:
+                IRDA_WARNING("IrLAN: Not open\n");
+                break;
+        case 7:
+                IRDA_WARNING("IrLAN: Authentication required\n");
+                break;
+        case 8:
+                IRDA_WARNING("IrLAN: Invalid password\n");
+                break;
+        case 9:
+                IRDA_WARNING("IrLAN: Protocol error\n");
+                break;
+        case 255:
+                IRDA_WARNING("IrLAN: Asynchronous status\n");
+                break;
+        }
+}
+
+/*
+ * Function irlan_client_parse_response (self, skb)
+ *
+ *    Extract all parameters from received buffer, then feed them to 
+ *    check_params for parsing
+ */
+void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb)
+{
+        __u8 *frame;
+        __u8 *ptr;
+        int count;
+        int ret;
+        __u16 val_len;
+        int i;
+        char *name;
+        char *value;
+
+        IRDA_ASSERT(skb != NULL, return;);      
+        
+        IRDA_DEBUG(4, "%s() skb->len=%d\n", __FUNCTION__ , (int) skb->len);
+        
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+        
+        if (!skb) {
+                IRDA_ERROR("%s(), Got NULL skb!\n", __FUNCTION__);
+                return;
+        }
+        frame = skb->data;
+        
+        /* 
+         *  Check return code and print it if not success 
+         */
+        if (frame[0]) {
+                print_ret_code(frame[0]);
+                return;
+        }
+        
+        name = kmalloc(255, GFP_ATOMIC);
+        if (!name)
+                return;
+        value = kmalloc(1016, GFP_ATOMIC);
+        if (!value) {
+                kfree(name);
+                return;
+        }
+
+        /* How many parameters? */
+        count = frame[1];
+
+        IRDA_DEBUG(4, "%s(), got %d parameters\n", __FUNCTION__ , 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", __FUNCTION__ );
+                        break;
+                }
+                ptr += ret;
+                irlan_check_response_param(self, name, value, val_len);
+        }
+        /* Cleanup */
+        kfree(name);
+        kfree(value);
+}
+
+/*
+ * Function irlan_check_response_param (self, param, value, val_len)
+ *
+ *     Check which parameter is received and update local variables
+ *
+ */
+static void irlan_check_response_param(struct irlan_cb *self, char *param, 
+                                       char *value, int val_len) 
+{
+        __u16 tmp_cpu; /* Temporary value in host order */
+        __u8 *bytes;
+        int i;
+
+        IRDA_DEBUG(4, "%s(), parm=%s\n", __FUNCTION__ , param);
+
+        IRDA_ASSERT(self != NULL, return;);
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+        /* Media type */
+        if (strcmp(param, "MEDIA") == 0) {
+                if (strcmp(value, "802.3") == 0)
+                        self->media = MEDIA_802_3;
+                else
+                        self->media = MEDIA_802_5;
+                return;
+        }
+        if (strcmp(param, "FILTER_TYPE") == 0) {
+                if (strcmp(value, "DIRECTED") == 0)
+                        self->client.filter_type |= IRLAN_DIRECTED;
+                else if (strcmp(value, "FUNCTIONAL") == 0)
+                        self->client.filter_type |= IRLAN_FUNCTIONAL;
+                else if (strcmp(value, "GROUP") == 0)
+                        self->client.filter_type |= IRLAN_GROUP;
+                else if (strcmp(value, "MAC_FRAME") == 0)
+                        self->client.filter_type |= IRLAN_MAC_FRAME;
+                else if (strcmp(value, "MULTICAST") == 0)
+                        self->client.filter_type |= IRLAN_MULTICAST;
+                else if (strcmp(value, "BROADCAST") == 0)
+                        self->client.filter_type |= IRLAN_BROADCAST;
+                else if (strcmp(value, "IPX_SOCKET") == 0)
+                        self->client.filter_type |= IRLAN_IPX_SOCKET;
+                
+        }
+        if (strcmp(param, "ACCESS_TYPE") == 0) {
+                if (strcmp(value, "DIRECT") == 0)
+                        self->client.access_type = ACCESS_DIRECT;
+                else if (strcmp(value, "PEER") == 0)
+                        self->client.access_type = ACCESS_PEER;
+                else if (strcmp(value, "HOSTED") == 0)
+                        self->client.access_type = ACCESS_HOSTED;
+                else {
+                        IRDA_DEBUG(2, "%s(), unknown access type!\n", __FUNCTION__ );
+                }
+        }
+        /* IRLAN version */
+        if (strcmp(param, "IRLAN_VER") == 0) {
+                IRDA_DEBUG(4, "IrLAN version %d.%d\n", (__u8) value[0], 
+                      (__u8) value[1]);
+
+                self->version[0] = value[0];
+                self->version[1] = value[1];
+                return;
+        }
+        /* Which remote TSAP to use for data channel */
+        if (strcmp(param, "DATA_CHAN") == 0) {
+                self->dtsap_sel_data = value[0];
+                IRDA_DEBUG(4, "Data TSAP = %02x\n", self->dtsap_sel_data);
+                return;
+        }
+        if (strcmp(param, "CON_ARB") == 0) {
+                memcpy(&tmp_cpu, value, 2); /* Align value */
+                le16_to_cpus(&tmp_cpu);     /* Convert to host order */
+                self->client.recv_arb_val = tmp_cpu;
+                IRDA_DEBUG(2, "%s(), receive arb val=%d\n", __FUNCTION__ , 
+                           self->client.recv_arb_val);
+        }
+        if (strcmp(param, "MAX_FRAME") == 0) {
+                memcpy(&tmp_cpu, value, 2); /* Align value */
+                le16_to_cpus(&tmp_cpu);     /* Convert to host order */
+                self->client.max_frame = tmp_cpu;
+                IRDA_DEBUG(4, "%s(), max frame=%d\n", __FUNCTION__ , 
+                           self->client.max_frame);
+        }
+         
+        /* RECONNECT_KEY, in case the link goes down! */
+        if (strcmp(param, "RECONNECT_KEY") == 0) {
+                IRDA_DEBUG(4, "Got reconnect key: ");
+                /* for (i = 0; i < val_len; i++) */
+/*                      printk("%02x", value[i]); */
+                memcpy(self->client.reconnect_key, value, val_len);
+                self->client.key_len = val_len;
+                IRDA_DEBUG(4, "\n");
+        }
+        /* FILTER_ENTRY, have we got an ethernet address? */
+        if (strcmp(param, "FILTER_ENTRY") == 0) {
+                bytes = value;
+                IRDA_DEBUG(4, "Ethernet address = %02x:%02x:%02x:%02x:%02x:%02x\n",
+                      bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], 
+                      bytes[5]);
+                for (i = 0; i < 6; i++) 
+                        self->dev->dev_addr[i] = bytes[i];
+        }
+}
+
+/*
+ * Function irlan_client_get_value_confirm (obj_id, value)
+ *
+ *    Got results from remote LM-IAS
+ *
+ */
+void irlan_client_get_value_confirm(int result, __u16 obj_id, 
+                                    struct ias_value *value, void *priv) 
+{
+        struct irlan_cb *self;
+        
+        IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
+
+        IRDA_ASSERT(priv != NULL, return;);
+
+        self = (struct irlan_cb *) priv;
+        IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
+
+        /* We probably don't need to make any more queries */
+        iriap_close(self->client.iriap);
+        self->client.iriap = NULL;
+
+        /* Check if request succeeded */
+        if (result != IAS_SUCCESS) {
+                IRDA_DEBUG(2, "%s(), got NULL value!\n", __FUNCTION__ );
+                irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, 
+                                      NULL);
+                return;
+        }
+
+        switch (value->type) {
+        case IAS_INTEGER:
+                self->dtsap_sel_ctrl = value->t.integer;
+
+                if (value->t.integer != -1) {
+                        irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL,
+                                              NULL);
+                        return;
+                }
+                irias_delete_value(value);
+                break;
+        default:
+                IRDA_DEBUG(2, "%s(), unknown type!\n", __FUNCTION__ );
+                break;
+        }
+        irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL);
+}