1/********************************************************************* 2 * 3 * Filename: irlan_client.c 4 * Version: 0.9 5 * Description: IrDA LAN Access Protocol (IrLAN) Client 6 * Status: Experimental. 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Sun Aug 31 20:14:37 1997 9 * Modified at: Tue Dec 14 15:47:02 1999 10 * Modified by: Dag Brattli <dagb@cs.uit.no> 11 * Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov> 12 * slip.c by Laurence Culhane, <loz@holmes.demon.co.uk> 13 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org> 14 * 15 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>, 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/slab.h> 32#include <linux/errno.h> 33#include <linux/init.h> 34#include <linux/netdevice.h> 35#include <linux/etherdevice.h> 36#include <linux/if_arp.h> 37#include <linux/bitops.h> 38#include <net/arp.h> 39 40#include <asm/byteorder.h> 41 42#include <net/irda/irda.h> 43#include <net/irda/irttp.h> 44#include <net/irda/irlmp.h> 45#include <net/irda/irias_object.h> 46#include <net/irda/iriap.h> 47#include <net/irda/timer.h> 48 49#include <net/irda/irlan_common.h> 50#include <net/irda/irlan_event.h> 51#include <net/irda/irlan_eth.h> 52#include <net/irda/irlan_provider.h> 53#include <net/irda/irlan_client.h> 54 55#undef CONFIG_IRLAN_GRATUITOUS_ARP 56 57static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap, 58 LM_REASON reason, 59 struct sk_buff *); 60static int irlan_client_ctrl_data_indication(void *instance, void *sap, 61 struct sk_buff *skb); 62static void irlan_client_ctrl_connect_confirm(void *instance, void *sap, 63 struct qos_info *qos, 64 __u32 max_sdu_size, 65 __u8 max_header_size, 66 struct sk_buff *); 67static void irlan_check_response_param(struct irlan_cb *self, char *param, 68 char *value, int val_len); 69static void irlan_client_open_ctrl_tsap(struct irlan_cb *self); 70 71static void irlan_client_kick_timer_expired(void *data) 72{ 73 struct irlan_cb *self = (struct irlan_cb *) data; 74 75 IRDA_ASSERT(self != NULL, return;); 76 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 77 78 /* 79 * If we are in peer mode, the client may not have got the discovery 80 * indication it needs to make progress. If the client is still in 81 * IDLE state, we must kick it to, but only if the provider is not IDLE 82 */ 83 if ((self->provider.access_type == ACCESS_PEER) && 84 (self->client.state == IRLAN_IDLE) && 85 (self->provider.state != IRLAN_IDLE)) { 86 irlan_client_wakeup(self, self->saddr, self->daddr); 87 } 88} 89 90static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout) 91{ 92 irda_start_timer(&self->client.kick_timer, timeout, (void *) self, 93 irlan_client_kick_timer_expired); 94} 95 96/* 97 * Function irlan_client_wakeup (self, saddr, daddr) 98 * 99 * Wake up client 100 * 101 */ 102void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr) 103{ 104 IRDA_ASSERT(self != NULL, return;); 105 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 106 107 /* 108 * Check if we are already awake, or if we are a provider in direct 109 * mode (in that case we must leave the client idle 110 */ 111 if ((self->client.state != IRLAN_IDLE) || 112 (self->provider.access_type == ACCESS_DIRECT)) 113 { 114 pr_debug("%s(), already awake!\n", __func__); 115 return; 116 } 117 118 /* Addresses may have changed! */ 119 self->saddr = saddr; 120 self->daddr = daddr; 121 122 if (self->disconnect_reason == LM_USER_REQUEST) { 123 pr_debug("%s(), still stopped by user\n", __func__); 124 return; 125 } 126 127 /* Open TSAPs */ 128 irlan_client_open_ctrl_tsap(self); 129 irlan_open_data_tsap(self); 130 131 irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL); 132 133 /* Start kick timer */ 134 irlan_client_start_kick_timer(self, 2*HZ); 135} 136 137/* 138 * Function irlan_discovery_indication (daddr) 139 * 140 * Remote device with IrLAN server support discovered 141 * 142 */ 143void irlan_client_discovery_indication(discinfo_t *discovery, 144 DISCOVERY_MODE mode, 145 void *priv) 146{ 147 struct irlan_cb *self; 148 __u32 saddr, daddr; 149 150 IRDA_ASSERT(discovery != NULL, return;); 151 152 /* 153 * I didn't check it, but I bet that IrLAN suffer from the same 154 * deficiency as IrComm and doesn't handle two instances 155 * simultaneously connecting to each other. 156 * Same workaround, drop passive discoveries. 157 * Jean II */ 158 if(mode == DISCOVERY_PASSIVE) 159 return; 160 161 saddr = discovery->saddr; 162 daddr = discovery->daddr; 163 164 /* Find instance */ 165 rcu_read_lock(); 166 self = irlan_get_any(); 167 if (self) { 168 IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;); 169 170 pr_debug("%s(), Found instance (%08x)!\n", __func__ , 171 daddr); 172 173 irlan_client_wakeup(self, saddr, daddr); 174 } 175IRDA_ASSERT_LABEL(out:) 176 rcu_read_unlock(); 177} 178 179/* 180 * Function irlan_client_data_indication (handle, skb) 181 * 182 * This function gets the data that is received on the control channel 183 * 184 */ 185static int irlan_client_ctrl_data_indication(void *instance, void *sap, 186 struct sk_buff *skb) 187{ 188 struct irlan_cb *self; 189 190 self = instance; 191 192 IRDA_ASSERT(self != NULL, return -1;); 193 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;); 194 IRDA_ASSERT(skb != NULL, return -1;); 195 196 irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb); 197 198 /* Ready for a new command */ 199 pr_debug("%s(), clearing tx_busy\n", __func__); 200 self->client.tx_busy = FALSE; 201 202 /* Check if we have some queued commands waiting to be sent */ 203 irlan_run_ctrl_tx_queue(self); 204 205 return 0; 206} 207 208static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap, 209 LM_REASON reason, 210 struct sk_buff *userdata) 211{ 212 struct irlan_cb *self; 213 struct tsap_cb *tsap; 214 struct sk_buff *skb; 215 216 pr_debug("%s(), reason=%d\n", __func__ , reason); 217 218 self = instance; 219 tsap = sap; 220 221 IRDA_ASSERT(self != NULL, return;); 222 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 223 IRDA_ASSERT(tsap != NULL, return;); 224 IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;); 225 226 IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;); 227 228 /* Remove frames queued on the control channel */ 229 while ((skb = skb_dequeue(&self->client.txq)) != NULL) { 230 dev_kfree_skb(skb); 231 } 232 self->client.tx_busy = FALSE; 233 234 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL); 235} 236 237/* 238 * Function irlan_client_open_tsaps (self) 239 * 240 * Initialize callbacks and open IrTTP TSAPs 241 * 242 */ 243static void irlan_client_open_ctrl_tsap(struct irlan_cb *self) 244{ 245 struct tsap_cb *tsap; 246 notify_t notify; 247 248 IRDA_ASSERT(self != NULL, return;); 249 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 250 251 /* Check if already open */ 252 if (self->client.tsap_ctrl) 253 return; 254 255 irda_notify_init(¬ify); 256 257 /* Set up callbacks */ 258 notify.data_indication = irlan_client_ctrl_data_indication; 259 notify.connect_confirm = irlan_client_ctrl_connect_confirm; 260 notify.disconnect_indication = irlan_client_ctrl_disconnect_indication; 261 notify.instance = self; 262 strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name)); 263 264 tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ¬ify); 265 if (!tsap) { 266 pr_debug("%s(), Got no tsap!\n", __func__); 267 return; 268 } 269 self->client.tsap_ctrl = tsap; 270} 271 272/* 273 * Function irlan_client_connect_confirm (handle, skb) 274 * 275 * Connection to peer IrLAN laye confirmed 276 * 277 */ 278static void irlan_client_ctrl_connect_confirm(void *instance, void *sap, 279 struct qos_info *qos, 280 __u32 max_sdu_size, 281 __u8 max_header_size, 282 struct sk_buff *skb) 283{ 284 struct irlan_cb *self; 285 286 self = instance; 287 288 IRDA_ASSERT(self != NULL, return;); 289 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 290 291 self->client.max_sdu_size = max_sdu_size; 292 self->client.max_header_size = max_header_size; 293 294 /* TODO: we could set the MTU depending on the max_sdu_size */ 295 296 irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL); 297} 298 299/* 300 * Function print_ret_code (code) 301 * 302 * Print return code of request to peer IrLAN layer. 303 * 304 */ 305static void print_ret_code(__u8 code) 306{ 307 switch(code) { 308 case 0: 309 printk(KERN_INFO "Success\n"); 310 break; 311 case 1: 312 net_warn_ratelimited("IrLAN: Insufficient resources\n"); 313 break; 314 case 2: 315 net_warn_ratelimited("IrLAN: Invalid command format\n"); 316 break; 317 case 3: 318 net_warn_ratelimited("IrLAN: Command not supported\n"); 319 break; 320 case 4: 321 net_warn_ratelimited("IrLAN: Parameter not supported\n"); 322 break; 323 case 5: 324 net_warn_ratelimited("IrLAN: Value not supported\n"); 325 break; 326 case 6: 327 net_warn_ratelimited("IrLAN: Not open\n"); 328 break; 329 case 7: 330 net_warn_ratelimited("IrLAN: Authentication required\n"); 331 break; 332 case 8: 333 net_warn_ratelimited("IrLAN: Invalid password\n"); 334 break; 335 case 9: 336 net_warn_ratelimited("IrLAN: Protocol error\n"); 337 break; 338 case 255: 339 net_warn_ratelimited("IrLAN: Asynchronous status\n"); 340 break; 341 } 342} 343 344/* 345 * Function irlan_client_parse_response (self, skb) 346 * 347 * Extract all parameters from received buffer, then feed them to 348 * check_params for parsing 349 */ 350void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb) 351{ 352 __u8 *frame; 353 __u8 *ptr; 354 int count; 355 int ret; 356 __u16 val_len; 357 int i; 358 char *name; 359 char *value; 360 361 IRDA_ASSERT(skb != NULL, return;); 362 363 pr_debug("%s() skb->len=%d\n", __func__ , (int)skb->len); 364 365 IRDA_ASSERT(self != NULL, return;); 366 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 367 368 if (!skb) { 369 net_err_ratelimited("%s(), Got NULL skb!\n", __func__); 370 return; 371 } 372 frame = skb->data; 373 374 /* 375 * Check return code and print it if not success 376 */ 377 if (frame[0]) { 378 print_ret_code(frame[0]); 379 return; 380 } 381 382 name = kmalloc(255, GFP_ATOMIC); 383 if (!name) 384 return; 385 value = kmalloc(1016, GFP_ATOMIC); 386 if (!value) { 387 kfree(name); 388 return; 389 } 390 391 /* How many parameters? */ 392 count = frame[1]; 393 394 pr_debug("%s(), got %d parameters\n", __func__ , count); 395 396 ptr = frame+2; 397 398 /* For all parameters */ 399 for (i=0; i<count;i++) { 400 ret = irlan_extract_param(ptr, name, value, &val_len); 401 if (ret < 0) { 402 pr_debug("%s(), IrLAN, Error!\n", __func__); 403 break; 404 } 405 ptr += ret; 406 irlan_check_response_param(self, name, value, val_len); 407 } 408 /* Cleanup */ 409 kfree(name); 410 kfree(value); 411} 412 413/* 414 * Function irlan_check_response_param (self, param, value, val_len) 415 * 416 * Check which parameter is received and update local variables 417 * 418 */ 419static void irlan_check_response_param(struct irlan_cb *self, char *param, 420 char *value, int val_len) 421{ 422 __u16 tmp_cpu; /* Temporary value in host order */ 423 __u8 *bytes; 424 int i; 425 426 pr_debug("%s(), parm=%s\n", __func__ , param); 427 428 IRDA_ASSERT(self != NULL, return;); 429 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 430 431 /* Media type */ 432 if (strcmp(param, "MEDIA") == 0) { 433 if (strcmp(value, "802.3") == 0) 434 self->media = MEDIA_802_3; 435 else 436 self->media = MEDIA_802_5; 437 return; 438 } 439 if (strcmp(param, "FILTER_TYPE") == 0) { 440 if (strcmp(value, "DIRECTED") == 0) 441 self->client.filter_type |= IRLAN_DIRECTED; 442 else if (strcmp(value, "FUNCTIONAL") == 0) 443 self->client.filter_type |= IRLAN_FUNCTIONAL; 444 else if (strcmp(value, "GROUP") == 0) 445 self->client.filter_type |= IRLAN_GROUP; 446 else if (strcmp(value, "MAC_FRAME") == 0) 447 self->client.filter_type |= IRLAN_MAC_FRAME; 448 else if (strcmp(value, "MULTICAST") == 0) 449 self->client.filter_type |= IRLAN_MULTICAST; 450 else if (strcmp(value, "BROADCAST") == 0) 451 self->client.filter_type |= IRLAN_BROADCAST; 452 else if (strcmp(value, "IPX_SOCKET") == 0) 453 self->client.filter_type |= IRLAN_IPX_SOCKET; 454 455 } 456 if (strcmp(param, "ACCESS_TYPE") == 0) { 457 if (strcmp(value, "DIRECT") == 0) 458 self->client.access_type = ACCESS_DIRECT; 459 else if (strcmp(value, "PEER") == 0) 460 self->client.access_type = ACCESS_PEER; 461 else if (strcmp(value, "HOSTED") == 0) 462 self->client.access_type = ACCESS_HOSTED; 463 else { 464 pr_debug("%s(), unknown access type!\n", __func__); 465 } 466 } 467 /* IRLAN version */ 468 if (strcmp(param, "IRLAN_VER") == 0) { 469 pr_debug("IrLAN version %d.%d\n", (__u8)value[0], 470 (__u8)value[1]); 471 472 self->version[0] = value[0]; 473 self->version[1] = value[1]; 474 return; 475 } 476 /* Which remote TSAP to use for data channel */ 477 if (strcmp(param, "DATA_CHAN") == 0) { 478 self->dtsap_sel_data = value[0]; 479 pr_debug("Data TSAP = %02x\n", self->dtsap_sel_data); 480 return; 481 } 482 if (strcmp(param, "CON_ARB") == 0) { 483 memcpy(&tmp_cpu, value, 2); /* Align value */ 484 le16_to_cpus(&tmp_cpu); /* Convert to host order */ 485 self->client.recv_arb_val = tmp_cpu; 486 pr_debug("%s(), receive arb val=%d\n", __func__ , 487 self->client.recv_arb_val); 488 } 489 if (strcmp(param, "MAX_FRAME") == 0) { 490 memcpy(&tmp_cpu, value, 2); /* Align value */ 491 le16_to_cpus(&tmp_cpu); /* Convert to host order */ 492 self->client.max_frame = tmp_cpu; 493 pr_debug("%s(), max frame=%d\n", __func__ , 494 self->client.max_frame); 495 } 496 497 /* RECONNECT_KEY, in case the link goes down! */ 498 if (strcmp(param, "RECONNECT_KEY") == 0) { 499 pr_debug("Got reconnect key: "); 500 /* for (i = 0; i < val_len; i++) */ 501/* printk("%02x", value[i]); */ 502 memcpy(self->client.reconnect_key, value, val_len); 503 self->client.key_len = val_len; 504 pr_debug("\n"); 505 } 506 /* FILTER_ENTRY, have we got an ethernet address? */ 507 if (strcmp(param, "FILTER_ENTRY") == 0) { 508 bytes = value; 509 pr_debug("Ethernet address = %pM\n", bytes); 510 for (i = 0; i < 6; i++) 511 self->dev->dev_addr[i] = bytes[i]; 512 } 513} 514 515/* 516 * Function irlan_client_get_value_confirm (obj_id, value) 517 * 518 * Got results from remote LM-IAS 519 * 520 */ 521void irlan_client_get_value_confirm(int result, __u16 obj_id, 522 struct ias_value *value, void *priv) 523{ 524 struct irlan_cb *self; 525 526 IRDA_ASSERT(priv != NULL, return;); 527 528 self = priv; 529 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;); 530 531 /* We probably don't need to make any more queries */ 532 iriap_close(self->client.iriap); 533 self->client.iriap = NULL; 534 535 /* Check if request succeeded */ 536 if (result != IAS_SUCCESS) { 537 pr_debug("%s(), got NULL value!\n", __func__); 538 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, 539 NULL); 540 return; 541 } 542 543 switch (value->type) { 544 case IAS_INTEGER: 545 self->dtsap_sel_ctrl = value->t.integer; 546 547 if (value->t.integer != -1) { 548 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL, 549 NULL); 550 return; 551 } 552 irias_delete_value(value); 553 break; 554 default: 555 pr_debug("%s(), unknown type!\n", __func__); 556 break; 557 } 558 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL); 559} 560