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