?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import 2.3.4pre3
[davej-history.git] / net / irda / irlan / irlan_provider.c
blob9471418724948b0d99b8d5730bcdef684e35944f
1 /*********************************************************************
2 *
3 * Filename: irlan_provider.c
4 * Version: 0.9
5 * Description: IrDA LAN Access Protocol Implementation
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Aug 31 20:14:37 1997
9 * Modified at: Sun May 9 12:22:56 1999
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 * Sources: skeleton.c by Donald Becker <becker@CESDIS.gsfc.nasa.gov>
12 * slip.c by Laurence Culhane, <loz@holmes.demon.co.uk>
13 * Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
14 *
15 * Copyright (c) 1998-1999 Dag Brattli <dagb@cs.uit.no>,
16 * All Rights Reserved.
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License as
20 * published by the Free Software Foundation; either version 2 of
21 * the License, or (at your option) any later version.
22 *
23 * Neither Dag Brattli nor University of Tromsø admit liability nor
24 * provide warranty for any of this software. This material is
25 * provided "AS-IS" and at no charge.
26 *
27 ********************************************************************/
28
29 #include <linux/kernel.h>
30 #include <linux/string.h>
31 #include <linux/errno.h>
32 #include <linux/netdevice.h>
33 #include <linux/etherdevice.h>
34 #include <linux/init.h>
35 #include <linux/random.h>
36
37 #include <asm/system.h>
38 #include <asm/bitops.h>
39 #include <asm/byteorder.h>
40
41 #include <net/irda/irda.h>
42 #include <net/irda/irttp.h>
43 #include <net/irda/irlmp.h>
44 #include <net/irda/irias_object.h>
45 #include <net/irda/iriap.h>
46 #include <net/irda/timer.h>
47
48 #include <net/irda/irlan_common.h>
49 #include <net/irda/irlan_eth.h>
50 #include <net/irda/irlan_event.h>
51 #include <net/irda/irlan_provider.h>
52 #include <net/irda/irlan_filter.h>
53 #include <net/irda/irlan_client.h>
54
55 static void irlan_provider_connect_indication(void *instance, void *sap,
56 struct qos_info *qos,
57 __u32 max_sdu_size,
58 __u8 max_header_size,
59 struct sk_buff *skb);
60
61 /*
62 * Function irlan_provider_control_data_indication (handle, skb)
63 *
64 * This function gets the data that is received on the control channel
65 *
66 */
67 static int irlan_provider_data_indication(void *instance, void *sap,
68 struct sk_buff *skb)
69 {
70 struct irlan_cb *self;
71 __u8 code;
72
73 DEBUG(4, __FUNCTION__ "()\n");
74
75 self = (struct irlan_cb *) instance;
76
77 ASSERT(self != NULL, return -1;);
78 ASSERT(self->magic == IRLAN_MAGIC, return -1;);
79
80 ASSERT(skb != NULL, return -1;);
81
82 code = skb->data[0];
83 switch(code) {
84 case CMD_GET_PROVIDER_INFO:
85 DEBUG(4, "Got GET_PROVIDER_INFO command!\n");
86 irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
87 break;
88
89 case CMD_GET_MEDIA_CHAR:
90 DEBUG(4, "Got GET_MEDIA_CHAR command!\n");
91 irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
92 break;
93 case CMD_OPEN_DATA_CHANNEL:
94 DEBUG(4, "Got OPEN_DATA_CHANNEL command!\n");
95 irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
96 break;
97 case CMD_FILTER_OPERATION:
98 DEBUG(4, "Got FILTER_OPERATION command!\n");
99 irlan_do_provider_event(self, IRLAN_FILTER_CONFIG_CMD, skb);
100 break;
101 case CMD_RECONNECT_DATA_CHAN:
102 DEBUG(2, __FUNCTION__"(), Got RECONNECT_DATA_CHAN command\n");
103 DEBUG(2, __FUNCTION__"(), NOT IMPLEMENTED\n");
104 break;
105 case CMD_CLOSE_DATA_CHAN:
106 DEBUG(2, "Got CLOSE_DATA_CHAN command!\n");
107 DEBUG(2, __FUNCTION__"(), NOT IMPLEMENTED\n");
108 break;
109 default:
110 DEBUG(2, __FUNCTION__ "(), Unknown command!\n");
111 break;
112 }
113 return 0;
114 }
115
116 /*
117 * Function irlan_provider_connect_indication (handle, skb, priv)
118 *
119 * Got connection from peer IrLAN layer
120 *
121 */
122 static void irlan_provider_connect_indication(void *instance, void *sap,
123 struct qos_info *qos,
124 __u32 max_sdu_size,
125 __u8 max_header_size,
126 struct sk_buff *skb)
127 {
128 struct irlan_cb *self, *new;
129 struct tsap_cb *tsap;
130 __u32 saddr, daddr;
131
132 DEBUG(0, __FUNCTION__ "()\n");
133
134 self = (struct irlan_cb *) instance;
135 tsap = (struct tsap_cb *) sap;
136
137 ASSERT(self != NULL, return;);
138 ASSERT(self->magic == IRLAN_MAGIC, return;);
139
140 self->provider.max_sdu_size = max_sdu_size;
141 self->provider.max_header_size = max_header_size;
142
143 ASSERT(tsap == self->provider.tsap_ctrl,return;);
144 ASSERT(self->provider.state == IRLAN_IDLE, return;);
145
146 daddr = irttp_get_daddr(tsap);
147 saddr = irttp_get_saddr(tsap);
148
149 /* Check if we already dealing with this client or peer */
150 new = (struct irlan_cb *) hashbin_find(irlan, daddr, NULL);
151 if (new) {
152 ASSERT(new->magic == IRLAN_MAGIC, return;);
153 DEBUG(0, __FUNCTION__ "(), found instance!\n");
154
155 /* Update saddr, since client may have moved to a new link */
156 new->saddr = saddr;
157 DEBUG(2, __FUNCTION__ "(), saddr=%08x\n", new->saddr);
158
159 /* Make sure that any old provider control TSAP is removed */
160 if ((new != self) && new->provider.tsap_ctrl) {
161 irttp_disconnect_request(new->provider.tsap_ctrl,
162 NULL, P_NORMAL);
163 irttp_close_tsap(new->provider.tsap_ctrl);
164 new->provider.tsap_ctrl = NULL;
165 }
166 } else {
167 /* This must be the master instance, so start a new instance */
168 DEBUG(0, __FUNCTION__ "(), starting new provider!\n");
169
170 new = irlan_open(saddr, daddr, TRUE);
171 }
172
173 /*
174 * Check if the connection came in on the master server, or the
175 * slave server. If it came on the slave, then everything is
176 * really, OK (reconnect), if not we need to dup the connection and
177 * hand it over to the slave.
178 */
179 if (new != self) {
180
181 /* Now attach up the new "socket" */
182 new->provider.tsap_ctrl = irttp_dup(self->provider.tsap_ctrl,
183 new);
184 if (!new->provider.tsap_ctrl) {
185 DEBUG(0, __FUNCTION__ "(), dup failed!\n");
186 return;
187 }
188
189 /* new->stsap_sel = new->tsap->stsap_sel; */
190 new->dtsap_sel_ctrl = new->provider.tsap_ctrl->dtsap_sel;
191
192 /* Clean up the original one to keep it in listen state */
193 self->provider.tsap_ctrl->dtsap_sel = LSAP_ANY;
194 self->provider.tsap_ctrl->lsap->dlsap_sel = LSAP_ANY;
195 self->provider.tsap_ctrl->lsap->lsap_state = LSAP_DISCONNECTED;
196
197 /*
198 * Use the new instance from here instead of the master
199 * struct!
200 */
201 self = new;
202 }
203 /* Check if network device has been registered */
204 if (!self->netdev_registered)
205 irlan_register_netdev(self);
206
207 irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL);
208
209 /*
210 * If we are in peer mode, the client may not have got the discovery
211 * indication it needs to make progress. If the client is still in
212 * IDLE state, we must kick it to
213 */
214 if ((self->provider.access_type == ACCESS_PEER) &&
215 (self->client.state == IRLAN_IDLE)) {
216 irlan_client_wakeup(self, self->saddr, self->daddr);
217 }
218 }
219
220 /*
221 * Function irlan_provider_connect_response (handle)
222 *
223 * Accept incomming connection
224 *
225 */
226 void irlan_provider_connect_response(struct irlan_cb *self,
227 struct tsap_cb *tsap)
228 {
229 ASSERT(self != NULL, return;);
230 ASSERT(self->magic == IRLAN_MAGIC, return;);
231
232 /* Just accept */
233 irttp_connect_response(tsap, IRLAN_MTU, NULL);
234
235 /* Check if network device has been registered */
236 if (!self->netdev_registered)
237 irlan_register_netdev(self);
238
239 }
240
241 void irlan_provider_disconnect_indication(void *instance, void *sap,
242 LM_REASON reason,
243 struct sk_buff *userdata)
244 {
245 struct irlan_cb *self;
246 struct tsap_cb *tsap;
247
248 DEBUG(4, __FUNCTION__ "(), reason=%d\n", reason);
249
250 self = (struct irlan_cb *) instance;
251 tsap = (struct tsap_cb *) sap;
252
253 ASSERT(self != NULL, return;);
254 ASSERT(self->magic == IRLAN_MAGIC, return;);
255 ASSERT(tsap != NULL, return;);
256 ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
257
258 ASSERT(tsap == self->provider.tsap_ctrl, return;);
259
260 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
261 }
262
263 /*
264 * Function irlan_parse_open_data_cmd (self, skb)
265 *
266 *
267 *
268 */
269 int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb)
270 {
271 int ret;
272
273 ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb);
274
275 /* Open data channel */
276 irlan_open_data_tsap(self);
277
278 return ret;
279 }
280
281 /*
282 * Function parse_command (skb)
283 *
284 * Extract all parameters from received buffer, then feed them to
285 * check_params for parsing
286 *
287 */
288 int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
289 struct sk_buff *skb)
290 {
291 __u8 *frame;
292 __u8 *ptr;
293 int count;
294 __u16 val_len;
295 int i;
296 char *name;
297 char *value;
298 int ret = RSP_SUCCESS;
299
300 ASSERT(skb != NULL, return -RSP_PROTOCOL_ERROR;);
301
302 DEBUG(4, __FUNCTION__ "(), skb->len=%d\n", (int)skb->len);
303
304 ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;);
305 ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;);
306
307 if (!skb)
308 return -RSP_PROTOCOL_ERROR;
309
310 frame = skb->data;
311
312 name = kmalloc(255, GFP_ATOMIC);
313 if (!name)
314 return -RSP_INSUFFICIENT_RESOURCES;
315 value = kmalloc(1016, GFP_ATOMIC);
316 if (!value) {
317 kfree(name);
318 return -RSP_INSUFFICIENT_RESOURCES;
319 }
320
321 /* How many parameters? */
322 count = frame[1];
323
324 DEBUG(4, "Got %d parameters\n", count);
325
326 ptr = frame+2;
327
328 /* For all parameters */
329 for (i=0; i<count;i++) {
330 ret = irlan_extract_param(ptr, name, value, &val_len);
331 if (ret < 0) {
332 DEBUG(2, __FUNCTION__ "(), IrLAN, Error!\n");
333 break;
334 }
335 ptr+=ret;
336 ret = RSP_SUCCESS;
337 irlan_check_command_param(self, name, value);
338 }
339 /* Cleanup */
340 kfree(name);
341 kfree(value);
342
343 return ret;
344 }
345
346 /*
347 * Function irlan_provider_send_reply (self, info)
348 *
349 * Send reply to query to peer IrLAN layer
350 *
351 */
352 void irlan_provider_send_reply(struct irlan_cb *self, int command,
353 int ret_code)
354 {
355 struct sk_buff *skb;
356
357 DEBUG(4, __FUNCTION__ "()\n");
358
359 ASSERT(self != NULL, return;);
360 ASSERT(self->magic == IRLAN_MAGIC, return;);
361
362 skb = dev_alloc_skb(128);
363 if (!skb)
364 return;
365
366 /* Reserve space for TTP, LMP, and LAP header */
367 skb_reserve(skb, self->provider.max_header_size);
368 skb_put(skb, 2);
369
370 switch (command) {
371 case CMD_GET_PROVIDER_INFO:
372 skb->data[0] = 0x00; /* Success */
373 skb->data[1] = 0x02; /* 2 parameters */
374 switch (self->media) {
375 case MEDIA_802_3:
376 irlan_insert_string_param(skb, "MEDIA", "802.3");
377 break;
378 case MEDIA_802_5:
379 irlan_insert_string_param(skb, "MEDIA", "802.5");
380 break;
381 default:
382 DEBUG(2, __FUNCTION__ "(), unknown media type!\n");
383 break;
384 }
385 irlan_insert_short_param(skb, "IRLAN_VER", 0x0101);
386 break;
387
388 case CMD_GET_MEDIA_CHAR:
389 skb->data[0] = 0x00; /* Success */
390 skb->data[1] = 0x05; /* 5 parameters */
391 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
392 irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
393 irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
394
395 switch (self->provider.access_type) {
396 case ACCESS_DIRECT:
397 irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
398 break;
399 case ACCESS_PEER:
400 irlan_insert_string_param(skb, "ACCESS_TYPE", "PEER");
401 break;
402 case ACCESS_HOSTED:
403 irlan_insert_string_param(skb, "ACCESS_TYPE", "HOSTED");
404 break;
405 default:
406 DEBUG(2, __FUNCTION__ "(), Unknown access type\n");
407 break;
408 }
409 irlan_insert_short_param(skb, "MAX_FRAME", 0x05ee);
410 break;
411 case CMD_OPEN_DATA_CHANNEL:
412 skb->data[0] = 0x00; /* Success */
413 if (self->provider.send_arb_val) {
414 skb->data[1] = 0x03; /* 3 parameters */
415 irlan_insert_short_param(skb, "CON_ARB",
416 self->provider.send_arb_val);
417 } else
418 skb->data[1] = 0x02; /* 2 parameters */
419 irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data);
420 irlan_insert_array_param(skb, "RECONNECT_KEY", "LINUX RULES!",
421 12);
422 break;
423 case CMD_FILTER_OPERATION:
424 handle_filter_request(self, skb);
425 break;
426 default:
427 DEBUG(2, __FUNCTION__ "(), Unknown command!\n");
428 break;
429 }
430
431 irttp_data_request(self->provider.tsap_ctrl, skb);
432 }
433
434 /*
435 * Function irlan_provider_register(void)
436 *
437 * Register provider support so we can accept incomming connections.
438 *
439 */
440 int irlan_provider_open_ctrl_tsap(struct irlan_cb *self)
441 {
442 struct notify_t notify;
443 struct tsap_cb *tsap;
444
445 DEBUG(4, __FUNCTION__ "()\n");
446
447 ASSERT(self != NULL, return -1;);
448 ASSERT(self->magic == IRLAN_MAGIC, return -1;);
449
450 /* Check if already open */
451 if (self->provider.tsap_ctrl)
452 return -1;
453
454 /*
455 * First register well known control TSAP
456 */
457 irda_notify_init(&notify);
458 notify.data_indication = irlan_provider_data_indication;
459 notify.connect_indication = irlan_provider_connect_indication;
460 notify.disconnect_indication = irlan_provider_disconnect_indication;
461 notify.instance = self;
462 strncpy(notify.name, "IrLAN ctrl (p)", 16);
463
464 tsap = irttp_open_tsap(LSAP_ANY, 1, &notify);
465 if (!tsap) {
466 DEBUG(2, __FUNCTION__ "(), Got no tsap!\n");
467 return -1;
468 }
469 self->provider.tsap_ctrl = tsap;
470
471 /* Register with LM-IAS */
472 irlan_ias_register(self, tsap->stsap_sel);
473
474 return 0;
475 }
476
Copy of Dave Jones history.git as used by http://archive.org/details/git-history-of-linux