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