iriap.c revision 90c7881ecee1f08e0a49172cf61371cf2509ee4a
1/********************************************************************* 2 * 3 * Filename: iriap.c 4 * Version: 0.8 5 * Description: Information Access Protocol (IAP) 6 * Status: Experimental. 7 * Author: Dag Brattli <dagb@cs.uit.no> 8 * Created at: Thu Aug 21 00:02:07 1997 9 * Modified at: Sat Dec 25 16:42:42 1999 10 * Modified by: Dag Brattli <dagb@cs.uit.no> 11 * 12 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>, 13 * All Rights Reserved. 14 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> 15 * 16 * This program is free software; you can redistribute it and/or 17 * modify it under the terms of the GNU General Public License as 18 * published by the Free Software Foundation; either version 2 of 19 * the License, or (at your option) any later version. 20 * 21 * Neither Dag Brattli nor University of Tromsø admit liability nor 22 * provide warranty for any of this software. This material is 23 * provided "AS-IS" and at no charge. 24 * 25 ********************************************************************/ 26 27#include <linux/module.h> 28#include <linux/types.h> 29#include <linux/skbuff.h> 30#include <linux/fs.h> 31#include <linux/string.h> 32#include <linux/init.h> 33#include <linux/seq_file.h> 34#include <linux/slab.h> 35 36#include <asm/byteorder.h> 37#include <asm/unaligned.h> 38 39#include <net/irda/irda.h> 40#include <net/irda/irttp.h> 41#include <net/irda/irlmp.h> 42#include <net/irda/irias_object.h> 43#include <net/irda/iriap_event.h> 44#include <net/irda/iriap.h> 45 46#ifdef CONFIG_IRDA_DEBUG 47/* FIXME: This one should go in irlmp.c */ 48static const char *const ias_charset_types[] = { 49 "CS_ASCII", 50 "CS_ISO_8859_1", 51 "CS_ISO_8859_2", 52 "CS_ISO_8859_3", 53 "CS_ISO_8859_4", 54 "CS_ISO_8859_5", 55 "CS_ISO_8859_6", 56 "CS_ISO_8859_7", 57 "CS_ISO_8859_8", 58 "CS_ISO_8859_9", 59 "CS_UNICODE" 60}; 61#endif /* CONFIG_IRDA_DEBUG */ 62 63static hashbin_t *iriap = NULL; 64static void *service_handle; 65 66static void __iriap_close(struct iriap_cb *self); 67static int iriap_register_lsap(struct iriap_cb *self, __u8 slsap_sel, int mode); 68static void iriap_disconnect_indication(void *instance, void *sap, 69 LM_REASON reason, struct sk_buff *skb); 70static void iriap_connect_indication(void *instance, void *sap, 71 struct qos_info *qos, __u32 max_sdu_size, 72 __u8 max_header_size, 73 struct sk_buff *skb); 74static void iriap_connect_confirm(void *instance, void *sap, 75 struct qos_info *qos, 76 __u32 max_sdu_size, __u8 max_header_size, 77 struct sk_buff *skb); 78static int iriap_data_indication(void *instance, void *sap, 79 struct sk_buff *skb); 80 81static void iriap_watchdog_timer_expired(void *data); 82 83static inline void iriap_start_watchdog_timer(struct iriap_cb *self, 84 int timeout) 85{ 86 irda_start_timer(&self->watchdog_timer, timeout, self, 87 iriap_watchdog_timer_expired); 88} 89 90static struct lock_class_key irias_objects_key; 91 92/* 93 * Function iriap_init (void) 94 * 95 * Initializes the IrIAP layer, called by the module initialization code 96 * in irmod.c 97 */ 98int __init iriap_init(void) 99{ 100 struct ias_object *obj; 101 struct iriap_cb *server; 102 __u8 oct_seq[6]; 103 __u16 hints; 104 105 /* Allocate master array */ 106 iriap = hashbin_new(HB_LOCK); 107 if (!iriap) 108 return -ENOMEM; 109 110 /* Object repository - defined in irias_object.c */ 111 irias_objects = hashbin_new(HB_LOCK); 112 if (!irias_objects) { 113 IRDA_WARNING("%s: Can't allocate irias_objects hashbin!\n", 114 __func__); 115 hashbin_delete(iriap, NULL); 116 return -ENOMEM; 117 } 118 119 lockdep_set_class_and_name(&irias_objects->hb_spinlock, &irias_objects_key, 120 "irias_objects"); 121 122 /* 123 * Register some default services for IrLMP 124 */ 125 hints = irlmp_service_to_hint(S_COMPUTER); 126 service_handle = irlmp_register_service(hints); 127 128 /* Register the Device object with LM-IAS */ 129 obj = irias_new_object("Device", IAS_DEVICE_ID); 130 irias_add_string_attrib(obj, "DeviceName", "Linux", IAS_KERNEL_ATTR); 131 132 oct_seq[0] = 0x01; /* Version 1 */ 133 oct_seq[1] = 0x00; /* IAS support bits */ 134 oct_seq[2] = 0x00; /* LM-MUX support bits */ 135#ifdef CONFIG_IRDA_ULTRA 136 oct_seq[2] |= 0x04; /* Connectionless Data support */ 137#endif 138 irias_add_octseq_attrib(obj, "IrLMPSupport", oct_seq, 3, 139 IAS_KERNEL_ATTR); 140 irias_insert_object(obj); 141 142 /* 143 * Register server support with IrLMP so we can accept incoming 144 * connections 145 */ 146 server = iriap_open(LSAP_IAS, IAS_SERVER, NULL, NULL); 147 if (!server) { 148 IRDA_DEBUG(0, "%s(), unable to open server\n", __func__); 149 return -1; 150 } 151 iriap_register_lsap(server, LSAP_IAS, IAS_SERVER); 152 153 return 0; 154} 155 156/* 157 * Function iriap_cleanup (void) 158 * 159 * Initializes the IrIAP layer, called by the module cleanup code in 160 * irmod.c 161 */ 162void iriap_cleanup(void) 163{ 164 irlmp_unregister_service(service_handle); 165 166 hashbin_delete(iriap, (FREE_FUNC) __iriap_close); 167 hashbin_delete(irias_objects, (FREE_FUNC) __irias_delete_object); 168} 169 170/* 171 * Function iriap_open (void) 172 * 173 * Opens an instance of the IrIAP layer, and registers with IrLMP 174 */ 175struct iriap_cb *iriap_open(__u8 slsap_sel, int mode, void *priv, 176 CONFIRM_CALLBACK callback) 177{ 178 struct iriap_cb *self; 179 180 IRDA_DEBUG(2, "%s()\n", __func__); 181 182 self = kzalloc(sizeof(*self), GFP_ATOMIC); 183 if (!self) { 184 IRDA_WARNING("%s: Unable to kmalloc!\n", __func__); 185 return NULL; 186 } 187 188 /* 189 * Initialize instance 190 */ 191 192 self->magic = IAS_MAGIC; 193 self->mode = mode; 194 if (mode == IAS_CLIENT) 195 iriap_register_lsap(self, slsap_sel, mode); 196 197 self->confirm = callback; 198 self->priv = priv; 199 200 /* iriap_getvaluebyclass_request() will construct packets before 201 * we connect, so this must have a sane value... Jean II */ 202 self->max_header_size = LMP_MAX_HEADER; 203 204 init_timer(&self->watchdog_timer); 205 206 hashbin_insert(iriap, (irda_queue_t *) self, (long) self, NULL); 207 208 /* Initialize state machines */ 209 iriap_next_client_state(self, S_DISCONNECT); 210 iriap_next_call_state(self, S_MAKE_CALL); 211 iriap_next_server_state(self, R_DISCONNECT); 212 iriap_next_r_connect_state(self, R_WAITING); 213 214 return self; 215} 216EXPORT_SYMBOL(iriap_open); 217 218/* 219 * Function __iriap_close (self) 220 * 221 * Removes (deallocates) the IrIAP instance 222 * 223 */ 224static void __iriap_close(struct iriap_cb *self) 225{ 226 IRDA_DEBUG(4, "%s()\n", __func__); 227 228 IRDA_ASSERT(self != NULL, return;); 229 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 230 231 del_timer(&self->watchdog_timer); 232 233 if (self->request_skb) 234 dev_kfree_skb(self->request_skb); 235 236 self->magic = 0; 237 238 kfree(self); 239} 240 241/* 242 * Function iriap_close (void) 243 * 244 * Closes IrIAP and deregisters with IrLMP 245 */ 246void iriap_close(struct iriap_cb *self) 247{ 248 struct iriap_cb *entry; 249 250 IRDA_DEBUG(2, "%s()\n", __func__); 251 252 IRDA_ASSERT(self != NULL, return;); 253 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 254 255 if (self->lsap) { 256 irlmp_close_lsap(self->lsap); 257 self->lsap = NULL; 258 } 259 260 entry = (struct iriap_cb *) hashbin_remove(iriap, (long) self, NULL); 261 IRDA_ASSERT(entry == self, return;); 262 263 __iriap_close(self); 264} 265EXPORT_SYMBOL(iriap_close); 266 267static int iriap_register_lsap(struct iriap_cb *self, __u8 slsap_sel, int mode) 268{ 269 notify_t notify; 270 271 IRDA_DEBUG(2, "%s()\n", __func__); 272 273 irda_notify_init(¬ify); 274 notify.connect_confirm = iriap_connect_confirm; 275 notify.connect_indication = iriap_connect_indication; 276 notify.disconnect_indication = iriap_disconnect_indication; 277 notify.data_indication = iriap_data_indication; 278 notify.instance = self; 279 if (mode == IAS_CLIENT) 280 strcpy(notify.name, "IrIAS cli"); 281 else 282 strcpy(notify.name, "IrIAS srv"); 283 284 self->lsap = irlmp_open_lsap(slsap_sel, ¬ify, 0); 285 if (self->lsap == NULL) { 286 IRDA_ERROR("%s: Unable to allocated LSAP!\n", __func__); 287 return -1; 288 } 289 self->slsap_sel = self->lsap->slsap_sel; 290 291 return 0; 292} 293 294/* 295 * Function iriap_disconnect_indication (handle, reason) 296 * 297 * Got disconnect, so clean up everything associated with this connection 298 * 299 */ 300static void iriap_disconnect_indication(void *instance, void *sap, 301 LM_REASON reason, 302 struct sk_buff *skb) 303{ 304 struct iriap_cb *self; 305 306 IRDA_DEBUG(4, "%s(), reason=%s\n", __func__, irlmp_reasons[reason]); 307 308 self = instance; 309 310 IRDA_ASSERT(self != NULL, return;); 311 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 312 313 IRDA_ASSERT(iriap != NULL, return;); 314 315 del_timer(&self->watchdog_timer); 316 317 /* Not needed */ 318 if (skb) 319 dev_kfree_skb(skb); 320 321 if (self->mode == IAS_CLIENT) { 322 IRDA_DEBUG(4, "%s(), disconnect as client\n", __func__); 323 324 325 iriap_do_client_event(self, IAP_LM_DISCONNECT_INDICATION, 326 NULL); 327 /* 328 * Inform service user that the request failed by sending 329 * it a NULL value. Warning, the client might close us, so 330 * remember no to use self anymore after calling confirm 331 */ 332 if (self->confirm) 333 self->confirm(IAS_DISCONNECT, 0, NULL, self->priv); 334 } else { 335 IRDA_DEBUG(4, "%s(), disconnect as server\n", __func__); 336 iriap_do_server_event(self, IAP_LM_DISCONNECT_INDICATION, 337 NULL); 338 iriap_close(self); 339 } 340} 341 342/* 343 * Function iriap_disconnect_request (handle) 344 */ 345static void iriap_disconnect_request(struct iriap_cb *self) 346{ 347 struct sk_buff *tx_skb; 348 349 IRDA_DEBUG(4, "%s()\n", __func__); 350 351 IRDA_ASSERT(self != NULL, return;); 352 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 353 354 tx_skb = alloc_skb(LMP_MAX_HEADER, GFP_ATOMIC); 355 if (tx_skb == NULL) { 356 IRDA_DEBUG(0, 357 "%s(), Could not allocate an sk_buff of length %d\n", 358 __func__, LMP_MAX_HEADER); 359 return; 360 } 361 362 /* 363 * Reserve space for MUX control and LAP header 364 */ 365 skb_reserve(tx_skb, LMP_MAX_HEADER); 366 367 irlmp_disconnect_request(self->lsap, tx_skb); 368} 369 370/* 371 * Function iriap_getvaluebyclass (addr, name, attr) 372 * 373 * Retrieve all values from attribute in all objects with given class 374 * name 375 */ 376int iriap_getvaluebyclass_request(struct iriap_cb *self, 377 __u32 saddr, __u32 daddr, 378 char *name, char *attr) 379{ 380 struct sk_buff *tx_skb; 381 int name_len, attr_len, skb_len; 382 __u8 *frame; 383 384 IRDA_ASSERT(self != NULL, return -1;); 385 IRDA_ASSERT(self->magic == IAS_MAGIC, return -1;); 386 387 /* Client must supply the destination device address */ 388 if (!daddr) 389 return -1; 390 391 self->daddr = daddr; 392 self->saddr = saddr; 393 394 /* 395 * Save operation, so we know what the later indication is about 396 */ 397 self->operation = GET_VALUE_BY_CLASS; 398 399 /* Give ourselves 10 secs to finish this operation */ 400 iriap_start_watchdog_timer(self, 10*HZ); 401 402 name_len = strlen(name); /* Up to IAS_MAX_CLASSNAME = 60 */ 403 attr_len = strlen(attr); /* Up to IAS_MAX_ATTRIBNAME = 60 */ 404 405 skb_len = self->max_header_size+2+name_len+1+attr_len+4; 406 tx_skb = alloc_skb(skb_len, GFP_ATOMIC); 407 if (!tx_skb) 408 return -ENOMEM; 409 410 /* Reserve space for MUX and LAP header */ 411 skb_reserve(tx_skb, self->max_header_size); 412 skb_put(tx_skb, 3+name_len+attr_len); 413 frame = tx_skb->data; 414 415 /* Build frame */ 416 frame[0] = IAP_LST | GET_VALUE_BY_CLASS; 417 frame[1] = name_len; /* Insert length of name */ 418 memcpy(frame+2, name, name_len); /* Insert name */ 419 frame[2+name_len] = attr_len; /* Insert length of attr */ 420 memcpy(frame+3+name_len, attr, attr_len); /* Insert attr */ 421 422 iriap_do_client_event(self, IAP_CALL_REQUEST_GVBC, tx_skb); 423 424 /* Drop reference count - see state_s_disconnect(). */ 425 dev_kfree_skb(tx_skb); 426 427 return 0; 428} 429EXPORT_SYMBOL(iriap_getvaluebyclass_request); 430 431/* 432 * Function iriap_getvaluebyclass_confirm (self, skb) 433 * 434 * Got result from GetValueByClass command. Parse it and return result 435 * to service user. 436 * 437 */ 438static void iriap_getvaluebyclass_confirm(struct iriap_cb *self, 439 struct sk_buff *skb) 440{ 441 struct ias_value *value; 442 int charset; 443 __u32 value_len; 444 __u32 tmp_cpu32; 445 __u16 obj_id; 446 __u16 len; 447 __u8 type; 448 __u8 *fp; 449 int n; 450 451 IRDA_ASSERT(self != NULL, return;); 452 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 453 IRDA_ASSERT(skb != NULL, return;); 454 455 /* Initialize variables */ 456 fp = skb->data; 457 n = 2; 458 459 /* Get length, MSB first */ 460 len = get_unaligned_be16(fp + n); 461 n += 2; 462 463 IRDA_DEBUG(4, "%s(), len=%d\n", __func__, len); 464 465 /* Get object ID, MSB first */ 466 obj_id = get_unaligned_be16(fp + n); 467 n += 2; 468 469 type = fp[n++]; 470 IRDA_DEBUG(4, "%s(), Value type = %d\n", __func__, type); 471 472 switch (type) { 473 case IAS_INTEGER: 474 memcpy(&tmp_cpu32, fp+n, 4); n += 4; 475 be32_to_cpus(&tmp_cpu32); 476 value = irias_new_integer_value(tmp_cpu32); 477 478 /* Legal values restricted to 0x01-0x6f, page 15 irttp */ 479 IRDA_DEBUG(4, "%s(), lsap=%d\n", __func__, value->t.integer); 480 break; 481 case IAS_STRING: 482 charset = fp[n++]; 483 484 switch (charset) { 485 case CS_ASCII: 486 break; 487/* case CS_ISO_8859_1: */ 488/* case CS_ISO_8859_2: */ 489/* case CS_ISO_8859_3: */ 490/* case CS_ISO_8859_4: */ 491/* case CS_ISO_8859_5: */ 492/* case CS_ISO_8859_6: */ 493/* case CS_ISO_8859_7: */ 494/* case CS_ISO_8859_8: */ 495/* case CS_ISO_8859_9: */ 496/* case CS_UNICODE: */ 497 default: 498 IRDA_DEBUG(0, "%s(), charset [%d] %s, not supported\n", 499 __func__, charset, 500 charset < ARRAY_SIZE(ias_charset_types) ? 501 ias_charset_types[charset] : 502 "(unknown)"); 503 504 /* Aborting, close connection! */ 505 iriap_disconnect_request(self); 506 return; 507 /* break; */ 508 } 509 value_len = fp[n++]; 510 IRDA_DEBUG(4, "%s(), strlen=%d\n", __func__, value_len); 511 512 /* Make sure the string is null-terminated */ 513 if (n + value_len < skb->len) 514 fp[n + value_len] = 0x00; 515 IRDA_DEBUG(4, "Got string %s\n", fp+n); 516 517 /* Will truncate to IAS_MAX_STRING bytes */ 518 value = irias_new_string_value(fp+n); 519 break; 520 case IAS_OCT_SEQ: 521 value_len = get_unaligned_be16(fp + n); 522 n += 2; 523 524 /* Will truncate to IAS_MAX_OCTET_STRING bytes */ 525 value = irias_new_octseq_value(fp+n, value_len); 526 break; 527 default: 528 value = irias_new_missing_value(); 529 break; 530 } 531 532 /* Finished, close connection! */ 533 iriap_disconnect_request(self); 534 535 /* Warning, the client might close us, so remember no to use self 536 * anymore after calling confirm 537 */ 538 if (self->confirm) 539 self->confirm(IAS_SUCCESS, obj_id, value, self->priv); 540 else { 541 IRDA_DEBUG(0, "%s(), missing handler!\n", __func__); 542 irias_delete_value(value); 543 } 544} 545 546/* 547 * Function iriap_getvaluebyclass_response () 548 * 549 * Send answer back to remote LM-IAS 550 * 551 */ 552static void iriap_getvaluebyclass_response(struct iriap_cb *self, 553 __u16 obj_id, 554 __u8 ret_code, 555 struct ias_value *value) 556{ 557 struct sk_buff *tx_skb; 558 int n; 559 __be32 tmp_be32; 560 __be16 tmp_be16; 561 __u8 *fp; 562 563 IRDA_DEBUG(4, "%s()\n", __func__); 564 565 IRDA_ASSERT(self != NULL, return;); 566 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 567 IRDA_ASSERT(value != NULL, return;); 568 IRDA_ASSERT(value->len <= 1024, return;); 569 570 /* Initialize variables */ 571 n = 0; 572 573 /* 574 * We must adjust the size of the response after the length of the 575 * value. We add 32 bytes because of the 6 bytes for the frame and 576 * max 5 bytes for the value coding. 577 */ 578 tx_skb = alloc_skb(value->len + self->max_header_size + 32, 579 GFP_ATOMIC); 580 if (!tx_skb) 581 return; 582 583 /* Reserve space for MUX and LAP header */ 584 skb_reserve(tx_skb, self->max_header_size); 585 skb_put(tx_skb, 6); 586 587 fp = tx_skb->data; 588 589 /* Build frame */ 590 fp[n++] = GET_VALUE_BY_CLASS | IAP_LST; 591 fp[n++] = ret_code; 592 593 /* Insert list length (MSB first) */ 594 tmp_be16 = htons(0x0001); 595 memcpy(fp+n, &tmp_be16, 2); n += 2; 596 597 /* Insert object identifier ( MSB first) */ 598 tmp_be16 = cpu_to_be16(obj_id); 599 memcpy(fp+n, &tmp_be16, 2); n += 2; 600 601 switch (value->type) { 602 case IAS_STRING: 603 skb_put(tx_skb, 3 + value->len); 604 fp[n++] = value->type; 605 fp[n++] = 0; /* ASCII */ 606 fp[n++] = (__u8) value->len; 607 memcpy(fp+n, value->t.string, value->len); n+=value->len; 608 break; 609 case IAS_INTEGER: 610 skb_put(tx_skb, 5); 611 fp[n++] = value->type; 612 613 tmp_be32 = cpu_to_be32(value->t.integer); 614 memcpy(fp+n, &tmp_be32, 4); n += 4; 615 break; 616 case IAS_OCT_SEQ: 617 skb_put(tx_skb, 3 + value->len); 618 fp[n++] = value->type; 619 620 tmp_be16 = cpu_to_be16(value->len); 621 memcpy(fp+n, &tmp_be16, 2); n += 2; 622 memcpy(fp+n, value->t.oct_seq, value->len); n+=value->len; 623 break; 624 case IAS_MISSING: 625 IRDA_DEBUG( 3, "%s: sending IAS_MISSING\n", __func__); 626 skb_put(tx_skb, 1); 627 fp[n++] = value->type; 628 break; 629 default: 630 IRDA_DEBUG(0, "%s(), type not implemented!\n", __func__); 631 break; 632 } 633 iriap_do_r_connect_event(self, IAP_CALL_RESPONSE, tx_skb); 634 635 /* Drop reference count - see state_r_execute(). */ 636 dev_kfree_skb(tx_skb); 637} 638 639/* 640 * Function iriap_getvaluebyclass_indication (self, skb) 641 * 642 * getvaluebyclass is requested from peer LM-IAS 643 * 644 */ 645static void iriap_getvaluebyclass_indication(struct iriap_cb *self, 646 struct sk_buff *skb) 647{ 648 struct ias_object *obj; 649 struct ias_attrib *attrib; 650 int name_len; 651 int attr_len; 652 char name[IAS_MAX_CLASSNAME + 1]; /* 60 bytes */ 653 char attr[IAS_MAX_ATTRIBNAME + 1]; /* 60 bytes */ 654 __u8 *fp; 655 int n; 656 657 IRDA_DEBUG(4, "%s()\n", __func__); 658 659 IRDA_ASSERT(self != NULL, return;); 660 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 661 IRDA_ASSERT(skb != NULL, return;); 662 663 fp = skb->data; 664 n = 1; 665 666 name_len = fp[n++]; 667 668 IRDA_ASSERT(name_len < IAS_MAX_CLASSNAME + 1, return;); 669 670 memcpy(name, fp+n, name_len); n+=name_len; 671 name[name_len] = '\0'; 672 673 attr_len = fp[n++]; 674 675 IRDA_ASSERT(attr_len < IAS_MAX_ATTRIBNAME + 1, return;); 676 677 memcpy(attr, fp+n, attr_len); n+=attr_len; 678 attr[attr_len] = '\0'; 679 680 IRDA_DEBUG(4, "LM-IAS: Looking up %s: %s\n", name, attr); 681 obj = irias_find_object(name); 682 683 if (obj == NULL) { 684 IRDA_DEBUG(2, "LM-IAS: Object %s not found\n", name); 685 iriap_getvaluebyclass_response(self, 0x1235, IAS_CLASS_UNKNOWN, 686 &irias_missing); 687 return; 688 } 689 IRDA_DEBUG(4, "LM-IAS: found %s, id=%d\n", obj->name, obj->id); 690 691 attrib = irias_find_attrib(obj, attr); 692 if (attrib == NULL) { 693 IRDA_DEBUG(2, "LM-IAS: Attribute %s not found\n", attr); 694 iriap_getvaluebyclass_response(self, obj->id, 695 IAS_ATTRIB_UNKNOWN, 696 &irias_missing); 697 return; 698 } 699 700 /* We have a match; send the value. */ 701 iriap_getvaluebyclass_response(self, obj->id, IAS_SUCCESS, 702 attrib->value); 703} 704 705/* 706 * Function iriap_send_ack (void) 707 * 708 * Currently not used 709 * 710 */ 711void iriap_send_ack(struct iriap_cb *self) 712{ 713 struct sk_buff *tx_skb; 714 __u8 *frame; 715 716 IRDA_DEBUG(2, "%s()\n", __func__); 717 718 IRDA_ASSERT(self != NULL, return;); 719 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 720 721 tx_skb = alloc_skb(LMP_MAX_HEADER + 1, GFP_ATOMIC); 722 if (!tx_skb) 723 return; 724 725 /* Reserve space for MUX and LAP header */ 726 skb_reserve(tx_skb, self->max_header_size); 727 skb_put(tx_skb, 1); 728 frame = tx_skb->data; 729 730 /* Build frame */ 731 frame[0] = IAP_LST | IAP_ACK | self->operation; 732 733 irlmp_data_request(self->lsap, tx_skb); 734} 735 736void iriap_connect_request(struct iriap_cb *self) 737{ 738 int ret; 739 740 IRDA_ASSERT(self != NULL, return;); 741 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 742 743 ret = irlmp_connect_request(self->lsap, LSAP_IAS, 744 self->saddr, self->daddr, 745 NULL, NULL); 746 if (ret < 0) { 747 IRDA_DEBUG(0, "%s(), connect failed!\n", __func__); 748 self->confirm(IAS_DISCONNECT, 0, NULL, self->priv); 749 } 750} 751 752/* 753 * Function iriap_connect_confirm (handle, skb) 754 * 755 * LSAP connection confirmed! 756 * 757 */ 758static void iriap_connect_confirm(void *instance, void *sap, 759 struct qos_info *qos, __u32 max_seg_size, 760 __u8 max_header_size, 761 struct sk_buff *skb) 762{ 763 struct iriap_cb *self; 764 765 self = instance; 766 767 IRDA_ASSERT(self != NULL, return;); 768 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 769 IRDA_ASSERT(skb != NULL, return;); 770 771 self->max_data_size = max_seg_size; 772 self->max_header_size = max_header_size; 773 774 del_timer(&self->watchdog_timer); 775 776 iriap_do_client_event(self, IAP_LM_CONNECT_CONFIRM, skb); 777 778 /* Drop reference count - see state_s_make_call(). */ 779 dev_kfree_skb(skb); 780} 781 782/* 783 * Function iriap_connect_indication ( handle, skb) 784 * 785 * Remote LM-IAS is requesting connection 786 * 787 */ 788static void iriap_connect_indication(void *instance, void *sap, 789 struct qos_info *qos, __u32 max_seg_size, 790 __u8 max_header_size, 791 struct sk_buff *skb) 792{ 793 struct iriap_cb *self, *new; 794 795 IRDA_DEBUG(1, "%s()\n", __func__); 796 797 self = instance; 798 799 IRDA_ASSERT(skb != NULL, return;); 800 IRDA_ASSERT(self != NULL, goto out;); 801 IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;); 802 803 /* Start new server */ 804 new = iriap_open(LSAP_IAS, IAS_SERVER, NULL, NULL); 805 if (!new) { 806 IRDA_DEBUG(0, "%s(), open failed\n", __func__); 807 goto out; 808 } 809 810 /* Now attach up the new "socket" */ 811 new->lsap = irlmp_dup(self->lsap, new); 812 if (!new->lsap) { 813 IRDA_DEBUG(0, "%s(), dup failed!\n", __func__); 814 goto out; 815 } 816 817 new->max_data_size = max_seg_size; 818 new->max_header_size = max_header_size; 819 820 /* Clean up the original one to keep it in listen state */ 821 irlmp_listen(self->lsap); 822 823 iriap_do_server_event(new, IAP_LM_CONNECT_INDICATION, skb); 824 825out: 826 /* Drop reference count - see state_r_disconnect(). */ 827 dev_kfree_skb(skb); 828} 829 830/* 831 * Function iriap_data_indication (handle, skb) 832 * 833 * Receives data from connection identified by handle from IrLMP 834 * 835 */ 836static int iriap_data_indication(void *instance, void *sap, 837 struct sk_buff *skb) 838{ 839 struct iriap_cb *self; 840 __u8 *frame; 841 __u8 opcode; 842 843 IRDA_DEBUG(3, "%s()\n", __func__); 844 845 self = instance; 846 847 IRDA_ASSERT(skb != NULL, return 0;); 848 IRDA_ASSERT(self != NULL, goto out;); 849 IRDA_ASSERT(self->magic == IAS_MAGIC, goto out;); 850 851 frame = skb->data; 852 853 if (self->mode == IAS_SERVER) { 854 /* Call server */ 855 IRDA_DEBUG(4, "%s(), Calling server!\n", __func__); 856 iriap_do_r_connect_event(self, IAP_RECV_F_LST, skb); 857 goto out; 858 } 859 opcode = frame[0]; 860 if (~opcode & IAP_LST) { 861 IRDA_WARNING("%s:, IrIAS multiframe commands or " 862 "results is not implemented yet!\n", 863 __func__); 864 goto out; 865 } 866 867 /* Check for ack frames since they don't contain any data */ 868 if (opcode & IAP_ACK) { 869 IRDA_DEBUG(0, "%s() Got ack frame!\n", __func__); 870 goto out; 871 } 872 873 opcode &= ~IAP_LST; /* Mask away LST bit */ 874 875 switch (opcode) { 876 case GET_INFO_BASE: 877 IRDA_DEBUG(0, "IrLMP GetInfoBaseDetails not implemented!\n"); 878 break; 879 case GET_VALUE_BY_CLASS: 880 iriap_do_call_event(self, IAP_RECV_F_LST, NULL); 881 882 switch (frame[1]) { 883 case IAS_SUCCESS: 884 iriap_getvaluebyclass_confirm(self, skb); 885 break; 886 case IAS_CLASS_UNKNOWN: 887 IRDA_DEBUG(1, "%s(), No such class!\n", __func__); 888 /* Finished, close connection! */ 889 iriap_disconnect_request(self); 890 891 /* 892 * Warning, the client might close us, so remember 893 * no to use self anymore after calling confirm 894 */ 895 if (self->confirm) 896 self->confirm(IAS_CLASS_UNKNOWN, 0, NULL, 897 self->priv); 898 break; 899 case IAS_ATTRIB_UNKNOWN: 900 IRDA_DEBUG(1, "%s(), No such attribute!\n", __func__); 901 /* Finished, close connection! */ 902 iriap_disconnect_request(self); 903 904 /* 905 * Warning, the client might close us, so remember 906 * no to use self anymore after calling confirm 907 */ 908 if (self->confirm) 909 self->confirm(IAS_ATTRIB_UNKNOWN, 0, NULL, 910 self->priv); 911 break; 912 } 913 break; 914 default: 915 IRDA_DEBUG(0, "%s(), Unknown op-code: %02x\n", __func__, 916 opcode); 917 break; 918 } 919 920out: 921 /* Cleanup - sub-calls will have done skb_get() as needed. */ 922 dev_kfree_skb(skb); 923 return 0; 924} 925 926/* 927 * Function iriap_call_indication (self, skb) 928 * 929 * Received call to server from peer LM-IAS 930 * 931 */ 932void iriap_call_indication(struct iriap_cb *self, struct sk_buff *skb) 933{ 934 __u8 *fp; 935 __u8 opcode; 936 937 IRDA_DEBUG(4, "%s()\n", __func__); 938 939 IRDA_ASSERT(self != NULL, return;); 940 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 941 IRDA_ASSERT(skb != NULL, return;); 942 943 fp = skb->data; 944 945 opcode = fp[0]; 946 if (~opcode & 0x80) { 947 IRDA_WARNING("%s: IrIAS multiframe commands or results " 948 "is not implemented yet!\n", __func__); 949 return; 950 } 951 opcode &= 0x7f; /* Mask away LST bit */ 952 953 switch (opcode) { 954 case GET_INFO_BASE: 955 IRDA_WARNING("%s: GetInfoBaseDetails not implemented yet!\n", 956 __func__); 957 break; 958 case GET_VALUE_BY_CLASS: 959 iriap_getvaluebyclass_indication(self, skb); 960 break; 961 } 962 /* skb will be cleaned up in iriap_data_indication */ 963} 964 965/* 966 * Function iriap_watchdog_timer_expired (data) 967 * 968 * Query has taken too long time, so abort 969 * 970 */ 971static void iriap_watchdog_timer_expired(void *data) 972{ 973 struct iriap_cb *self = (struct iriap_cb *) data; 974 975 IRDA_ASSERT(self != NULL, return;); 976 IRDA_ASSERT(self->magic == IAS_MAGIC, return;); 977 978 /* iriap_close(self); */ 979} 980 981#ifdef CONFIG_PROC_FS 982 983static const char *const ias_value_types[] = { 984 "IAS_MISSING", 985 "IAS_INTEGER", 986 "IAS_OCT_SEQ", 987 "IAS_STRING" 988}; 989 990static inline struct ias_object *irias_seq_idx(loff_t pos) 991{ 992 struct ias_object *obj; 993 994 for (obj = (struct ias_object *) hashbin_get_first(irias_objects); 995 obj; obj = (struct ias_object *) hashbin_get_next(irias_objects)) { 996 if (pos-- == 0) 997 break; 998 } 999 1000 return obj; 1001} 1002 1003static void *irias_seq_start(struct seq_file *seq, loff_t *pos) 1004{ 1005 spin_lock_irq(&irias_objects->hb_spinlock); 1006 1007 return *pos ? irias_seq_idx(*pos - 1) : SEQ_START_TOKEN; 1008} 1009 1010static void *irias_seq_next(struct seq_file *seq, void *v, loff_t *pos) 1011{ 1012 ++*pos; 1013 1014 return (v == SEQ_START_TOKEN) 1015 ? (void *) hashbin_get_first(irias_objects) 1016 : (void *) hashbin_get_next(irias_objects); 1017} 1018 1019static void irias_seq_stop(struct seq_file *seq, void *v) 1020{ 1021 spin_unlock_irq(&irias_objects->hb_spinlock); 1022} 1023 1024static int irias_seq_show(struct seq_file *seq, void *v) 1025{ 1026 if (v == SEQ_START_TOKEN) 1027 seq_puts(seq, "LM-IAS Objects:\n"); 1028 else { 1029 struct ias_object *obj = v; 1030 struct ias_attrib *attrib; 1031 1032 IRDA_ASSERT(obj->magic == IAS_OBJECT_MAGIC, return -EINVAL;); 1033 1034 seq_printf(seq, "name: %s, id=%d\n", 1035 obj->name, obj->id); 1036 1037 /* Careful for priority inversions here ! 1038 * All other uses of attrib spinlock are independent of 1039 * the object spinlock, so we are safe. Jean II */ 1040 spin_lock(&obj->attribs->hb_spinlock); 1041 1042 /* List all attributes for this object */ 1043 for (attrib = (struct ias_attrib *) hashbin_get_first(obj->attribs); 1044 attrib != NULL; 1045 attrib = (struct ias_attrib *) hashbin_get_next(obj->attribs)) { 1046 1047 IRDA_ASSERT(attrib->magic == IAS_ATTRIB_MAGIC, 1048 goto outloop; ); 1049 1050 seq_printf(seq, " - Attribute name: \"%s\", ", 1051 attrib->name); 1052 seq_printf(seq, "value[%s]: ", 1053 ias_value_types[attrib->value->type]); 1054 1055 switch (attrib->value->type) { 1056 case IAS_INTEGER: 1057 seq_printf(seq, "%d\n", 1058 attrib->value->t.integer); 1059 break; 1060 case IAS_STRING: 1061 seq_printf(seq, "\"%s\"\n", 1062 attrib->value->t.string); 1063 break; 1064 case IAS_OCT_SEQ: 1065 seq_printf(seq, "octet sequence (%d bytes)\n", 1066 attrib->value->len); 1067 break; 1068 case IAS_MISSING: 1069 seq_puts(seq, "missing\n"); 1070 break; 1071 default: 1072 seq_printf(seq, "type %d?\n", 1073 attrib->value->type); 1074 } 1075 seq_putc(seq, '\n'); 1076 1077 } 1078 IRDA_ASSERT_LABEL(outloop:) 1079 spin_unlock(&obj->attribs->hb_spinlock); 1080 } 1081 1082 return 0; 1083} 1084 1085static const struct seq_operations irias_seq_ops = { 1086 .start = irias_seq_start, 1087 .next = irias_seq_next, 1088 .stop = irias_seq_stop, 1089 .show = irias_seq_show, 1090}; 1091 1092static int irias_seq_open(struct inode *inode, struct file *file) 1093{ 1094 IRDA_ASSERT( irias_objects != NULL, return -EINVAL;); 1095 1096 return seq_open(file, &irias_seq_ops); 1097} 1098 1099const struct file_operations irias_seq_fops = { 1100 .owner = THIS_MODULE, 1101 .open = irias_seq_open, 1102 .read = seq_read, 1103 .llseek = seq_lseek, 1104 .release = seq_release, 1105}; 1106 1107#endif /* PROC_FS */ 1108