net/irda/irlan/irlan_provider.c

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