1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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/system.h>
41#include <asm/byteorder.h>
42
43#include <net/irda/irda.h>
44#include <net/irda/irttp.h>
45#include <net/irda/irlmp.h>
46#include <net/irda/irias_object.h>
47#include <net/irda/iriap.h>
48#include <net/irda/timer.h>
49
50#include <net/irda/irlan_common.h>
51#include <net/irda/irlan_event.h>
52#include <net/irda/irlan_eth.h>
53#include <net/irda/irlan_provider.h>
54#include <net/irda/irlan_client.h>
55
56#undef CONFIG_IRLAN_GRATUITOUS_ARP
57
58static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
59 LM_REASON reason,
60 struct sk_buff *);
61static int irlan_client_ctrl_data_indication(void *instance, void *sap,
62 struct sk_buff *skb);
63static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
64 struct qos_info *qos,
65 __u32 max_sdu_size,
66 __u8 max_header_size,
67 struct sk_buff *);
68static void irlan_check_response_param(struct irlan_cb *self, char *param,
69 char *value, int val_len);
70static void irlan_client_open_ctrl_tsap(struct irlan_cb *self);
71
72static void irlan_client_kick_timer_expired(void *data)
73{
74 struct irlan_cb *self = (struct irlan_cb *) data;
75
76 IRDA_DEBUG(2, "%s()\n", __func__ );
77
78 IRDA_ASSERT(self != NULL, return;);
79 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
80
81
82
83
84
85
86 if ((self->provider.access_type == ACCESS_PEER) &&
87 (self->client.state == IRLAN_IDLE) &&
88 (self->provider.state != IRLAN_IDLE)) {
89 irlan_client_wakeup(self, self->saddr, self->daddr);
90 }
91}
92
93static void irlan_client_start_kick_timer(struct irlan_cb *self, int timeout)
94{
95 IRDA_DEBUG(4, "%s()\n", __func__ );
96
97 irda_start_timer(&self->client.kick_timer, timeout, (void *) self,
98 irlan_client_kick_timer_expired);
99}
100
101
102
103
104
105
106
107void irlan_client_wakeup(struct irlan_cb *self, __u32 saddr, __u32 daddr)
108{
109 IRDA_DEBUG(1, "%s()\n", __func__ );
110
111 IRDA_ASSERT(self != NULL, return;);
112 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
113
114
115
116
117
118 if ((self->client.state != IRLAN_IDLE) ||
119 (self->provider.access_type == ACCESS_DIRECT))
120 {
121 IRDA_DEBUG(0, "%s(), already awake!\n", __func__ );
122 return;
123 }
124
125
126 self->saddr = saddr;
127 self->daddr = daddr;
128
129 if (self->disconnect_reason == LM_USER_REQUEST) {
130 IRDA_DEBUG(0, "%s(), still stopped by user\n", __func__ );
131 return;
132 }
133
134
135 irlan_client_open_ctrl_tsap(self);
136 irlan_open_data_tsap(self);
137
138 irlan_do_client_event(self, IRLAN_DISCOVERY_INDICATION, NULL);
139
140
141 irlan_client_start_kick_timer(self, 2*HZ);
142}
143
144
145
146
147
148
149
150void irlan_client_discovery_indication(discinfo_t *discovery,
151 DISCOVERY_MODE mode,
152 void *priv)
153{
154 struct irlan_cb *self;
155 __u32 saddr, daddr;
156
157 IRDA_DEBUG(1, "%s()\n", __func__ );
158
159 IRDA_ASSERT(discovery != NULL, return;);
160
161
162
163
164
165
166
167 if(mode == DISCOVERY_PASSIVE)
168 return;
169
170 saddr = discovery->saddr;
171 daddr = discovery->daddr;
172
173
174 rcu_read_lock();
175 self = irlan_get_any();
176 if (self) {
177 IRDA_ASSERT(self->magic == IRLAN_MAGIC, goto out;);
178
179 IRDA_DEBUG(1, "%s(), Found instance (%08x)!\n", __func__ ,
180 daddr);
181
182 irlan_client_wakeup(self, saddr, daddr);
183 }
184IRDA_ASSERT_LABEL(out:)
185 rcu_read_unlock();
186}
187
188
189
190
191
192
193
194static int irlan_client_ctrl_data_indication(void *instance, void *sap,
195 struct sk_buff *skb)
196{
197 struct irlan_cb *self;
198
199 IRDA_DEBUG(2, "%s()\n", __func__ );
200
201 self = (struct irlan_cb *) instance;
202
203 IRDA_ASSERT(self != NULL, return -1;);
204 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
205 IRDA_ASSERT(skb != NULL, return -1;);
206
207 irlan_do_client_event(self, IRLAN_DATA_INDICATION, skb);
208
209
210 IRDA_DEBUG(2, "%s(), clearing tx_busy\n", __func__ );
211 self->client.tx_busy = FALSE;
212
213
214 irlan_run_ctrl_tx_queue(self);
215
216 return 0;
217}
218
219static void irlan_client_ctrl_disconnect_indication(void *instance, void *sap,
220 LM_REASON reason,
221 struct sk_buff *userdata)
222{
223 struct irlan_cb *self;
224 struct tsap_cb *tsap;
225 struct sk_buff *skb;
226
227 IRDA_DEBUG(4, "%s(), reason=%d\n", __func__ , reason);
228
229 self = (struct irlan_cb *) instance;
230 tsap = (struct tsap_cb *) sap;
231
232 IRDA_ASSERT(self != NULL, return;);
233 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
234 IRDA_ASSERT(tsap != NULL, return;);
235 IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
236
237 IRDA_ASSERT(tsap == self->client.tsap_ctrl, return;);
238
239
240 while ((skb = skb_dequeue(&self->client.txq)) != NULL) {
241 dev_kfree_skb(skb);
242 }
243 self->client.tx_busy = FALSE;
244
245 irlan_do_client_event(self, IRLAN_LMP_DISCONNECT, NULL);
246}
247
248
249
250
251
252
253
254static void irlan_client_open_ctrl_tsap(struct irlan_cb *self)
255{
256 struct tsap_cb *tsap;
257 notify_t notify;
258
259 IRDA_DEBUG(4, "%s()\n", __func__ );
260
261 IRDA_ASSERT(self != NULL, return;);
262 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
263
264
265 if (self->client.tsap_ctrl)
266 return;
267
268 irda_notify_init(¬ify);
269
270
271 notify.data_indication = irlan_client_ctrl_data_indication;
272 notify.connect_confirm = irlan_client_ctrl_connect_confirm;
273 notify.disconnect_indication = irlan_client_ctrl_disconnect_indication;
274 notify.instance = self;
275 strlcpy(notify.name, "IrLAN ctrl (c)", sizeof(notify.name));
276
277 tsap = irttp_open_tsap(LSAP_ANY, DEFAULT_INITIAL_CREDIT, ¬ify);
278 if (!tsap) {
279 IRDA_DEBUG(2, "%s(), Got no tsap!\n", __func__ );
280 return;
281 }
282 self->client.tsap_ctrl = tsap;
283}
284
285
286
287
288
289
290
291static void irlan_client_ctrl_connect_confirm(void *instance, void *sap,
292 struct qos_info *qos,
293 __u32 max_sdu_size,
294 __u8 max_header_size,
295 struct sk_buff *skb)
296{
297 struct irlan_cb *self;
298
299 IRDA_DEBUG(4, "%s()\n", __func__ );
300
301 self = (struct irlan_cb *) instance;
302
303 IRDA_ASSERT(self != NULL, return;);
304 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
305
306 self->client.max_sdu_size = max_sdu_size;
307 self->client.max_header_size = max_header_size;
308
309
310
311 irlan_do_client_event(self, IRLAN_CONNECT_COMPLETE, NULL);
312}
313
314
315
316
317
318
319
320static void print_ret_code(__u8 code)
321{
322 switch(code) {
323 case 0:
324 printk(KERN_INFO "Success\n");
325 break;
326 case 1:
327 IRDA_WARNING("IrLAN: Insufficient resources\n");
328 break;
329 case 2:
330 IRDA_WARNING("IrLAN: Invalid command format\n");
331 break;
332 case 3:
333 IRDA_WARNING("IrLAN: Command not supported\n");
334 break;
335 case 4:
336 IRDA_WARNING("IrLAN: Parameter not supported\n");
337 break;
338 case 5:
339 IRDA_WARNING("IrLAN: Value not supported\n");
340 break;
341 case 6:
342 IRDA_WARNING("IrLAN: Not open\n");
343 break;
344 case 7:
345 IRDA_WARNING("IrLAN: Authentication required\n");
346 break;
347 case 8:
348 IRDA_WARNING("IrLAN: Invalid password\n");
349 break;
350 case 9:
351 IRDA_WARNING("IrLAN: Protocol error\n");
352 break;
353 case 255:
354 IRDA_WARNING("IrLAN: Asynchronous status\n");
355 break;
356 }
357}
358
359
360
361
362
363
364
365void irlan_client_parse_response(struct irlan_cb *self, struct sk_buff *skb)
366{
367 __u8 *frame;
368 __u8 *ptr;
369 int count;
370 int ret;
371 __u16 val_len;
372 int i;
373 char *name;
374 char *value;
375
376 IRDA_ASSERT(skb != NULL, return;);
377
378 IRDA_DEBUG(4, "%s() skb->len=%d\n", __func__ , (int) skb->len);
379
380 IRDA_ASSERT(self != NULL, return;);
381 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
382
383 if (!skb) {
384 IRDA_ERROR("%s(), Got NULL skb!\n", __func__);
385 return;
386 }
387 frame = skb->data;
388
389
390
391
392 if (frame[0]) {
393 print_ret_code(frame[0]);
394 return;
395 }
396
397 name = kmalloc(255, GFP_ATOMIC);
398 if (!name)
399 return;
400 value = kmalloc(1016, GFP_ATOMIC);
401 if (!value) {
402 kfree(name);
403 return;
404 }
405
406
407 count = frame[1];
408
409 IRDA_DEBUG(4, "%s(), got %d parameters\n", __func__ , count);
410
411 ptr = frame+2;
412
413
414 for (i=0; i<count;i++) {
415 ret = irlan_extract_param(ptr, name, value, &val_len);
416 if (ret < 0) {
417 IRDA_DEBUG(2, "%s(), IrLAN, Error!\n", __func__ );
418 break;
419 }
420 ptr += ret;
421 irlan_check_response_param(self, name, value, val_len);
422 }
423
424 kfree(name);
425 kfree(value);
426}
427
428
429
430
431
432
433
434static void irlan_check_response_param(struct irlan_cb *self, char *param,
435 char *value, int val_len)
436{
437 __u16 tmp_cpu;
438 __u8 *bytes;
439 int i;
440
441 IRDA_DEBUG(4, "%s(), parm=%s\n", __func__ , param);
442
443 IRDA_ASSERT(self != NULL, return;);
444 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
445
446
447 if (strcmp(param, "MEDIA") == 0) {
448 if (strcmp(value, "802.3") == 0)
449 self->media = MEDIA_802_3;
450 else
451 self->media = MEDIA_802_5;
452 return;
453 }
454 if (strcmp(param, "FILTER_TYPE") == 0) {
455 if (strcmp(value, "DIRECTED") == 0)
456 self->client.filter_type |= IRLAN_DIRECTED;
457 else if (strcmp(value, "FUNCTIONAL") == 0)
458 self->client.filter_type |= IRLAN_FUNCTIONAL;
459 else if (strcmp(value, "GROUP") == 0)
460 self->client.filter_type |= IRLAN_GROUP;
461 else if (strcmp(value, "MAC_FRAME") == 0)
462 self->client.filter_type |= IRLAN_MAC_FRAME;
463 else if (strcmp(value, "MULTICAST") == 0)
464 self->client.filter_type |= IRLAN_MULTICAST;
465 else if (strcmp(value, "BROADCAST") == 0)
466 self->client.filter_type |= IRLAN_BROADCAST;
467 else if (strcmp(value, "IPX_SOCKET") == 0)
468 self->client.filter_type |= IRLAN_IPX_SOCKET;
469
470 }
471 if (strcmp(param, "ACCESS_TYPE") == 0) {
472 if (strcmp(value, "DIRECT") == 0)
473 self->client.access_type = ACCESS_DIRECT;
474 else if (strcmp(value, "PEER") == 0)
475 self->client.access_type = ACCESS_PEER;
476 else if (strcmp(value, "HOSTED") == 0)
477 self->client.access_type = ACCESS_HOSTED;
478 else {
479 IRDA_DEBUG(2, "%s(), unknown access type!\n", __func__ );
480 }
481 }
482
483 if (strcmp(param, "IRLAN_VER") == 0) {
484 IRDA_DEBUG(4, "IrLAN version %d.%d\n", (__u8) value[0],
485 (__u8) value[1]);
486
487 self->version[0] = value[0];
488 self->version[1] = value[1];
489 return;
490 }
491
492 if (strcmp(param, "DATA_CHAN") == 0) {
493 self->dtsap_sel_data = value[0];
494 IRDA_DEBUG(4, "Data TSAP = %02x\n", self->dtsap_sel_data);
495 return;
496 }
497 if (strcmp(param, "CON_ARB") == 0) {
498 memcpy(&tmp_cpu, value, 2);
499 le16_to_cpus(&tmp_cpu);
500 self->client.recv_arb_val = tmp_cpu;
501 IRDA_DEBUG(2, "%s(), receive arb val=%d\n", __func__ ,
502 self->client.recv_arb_val);
503 }
504 if (strcmp(param, "MAX_FRAME") == 0) {
505 memcpy(&tmp_cpu, value, 2);
506 le16_to_cpus(&tmp_cpu);
507 self->client.max_frame = tmp_cpu;
508 IRDA_DEBUG(4, "%s(), max frame=%d\n", __func__ ,
509 self->client.max_frame);
510 }
511
512
513 if (strcmp(param, "RECONNECT_KEY") == 0) {
514 IRDA_DEBUG(4, "Got reconnect key: ");
515
516
517 memcpy(self->client.reconnect_key, value, val_len);
518 self->client.key_len = val_len;
519 IRDA_DEBUG(4, "\n");
520 }
521
522 if (strcmp(param, "FILTER_ENTRY") == 0) {
523 bytes = value;
524 IRDA_DEBUG(4, "Ethernet address = %pM\n", bytes);
525 for (i = 0; i < 6; i++)
526 self->dev->dev_addr[i] = bytes[i];
527 }
528}
529
530
531
532
533
534
535
536void irlan_client_get_value_confirm(int result, __u16 obj_id,
537 struct ias_value *value, void *priv)
538{
539 struct irlan_cb *self;
540
541 IRDA_DEBUG(4, "%s()\n", __func__ );
542
543 IRDA_ASSERT(priv != NULL, return;);
544
545 self = (struct irlan_cb *) priv;
546 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
547
548
549 iriap_close(self->client.iriap);
550 self->client.iriap = NULL;
551
552
553 if (result != IAS_SUCCESS) {
554 IRDA_DEBUG(2, "%s(), got NULL value!\n", __func__ );
555 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL,
556 NULL);
557 return;
558 }
559
560 switch (value->type) {
561 case IAS_INTEGER:
562 self->dtsap_sel_ctrl = value->t.integer;
563
564 if (value->t.integer != -1) {
565 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_AVAIL,
566 NULL);
567 return;
568 }
569 irias_delete_value(value);
570 break;
571 default:
572 IRDA_DEBUG(2, "%s(), unknown type!\n", __func__ );
573 break;
574 }
575 irlan_do_client_event(self, IRLAN_IAS_PROVIDER_NOT_AVAIL, NULL);
576}
577