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