?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.1.16
[linux/fpc-iii.git] / net / irda / irlan / irlan_provider.c
blob15c292cf264436a0cc468cba0285a1ef0391e248
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: Sat Oct 30 12:52:10 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 #include <linux/bitops.h>
37 #include <linux/slab.h>
38
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 self = instance;
74
75 IRDA_ASSERT(self != NULL, return -1;);
76 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
77
78 IRDA_ASSERT(skb != NULL, return -1;);
79
80 code = skb->data[0];
81 switch(code) {
82 case CMD_GET_PROVIDER_INFO:
83 pr_debug("Got GET_PROVIDER_INFO command!\n");
84 irlan_do_provider_event(self, IRLAN_GET_INFO_CMD, skb);
85 break;
86
87 case CMD_GET_MEDIA_CHAR:
88 pr_debug("Got GET_MEDIA_CHAR command!\n");
89 irlan_do_provider_event(self, IRLAN_GET_MEDIA_CMD, skb);
90 break;
91 case CMD_OPEN_DATA_CHANNEL:
92 pr_debug("Got OPEN_DATA_CHANNEL command!\n");
93 irlan_do_provider_event(self, IRLAN_OPEN_DATA_CMD, skb);
94 break;
95 case CMD_FILTER_OPERATION:
96 pr_debug("Got FILTER_OPERATION command!\n");
97 irlan_do_provider_event(self, IRLAN_FILTER_CONFIG_CMD, skb);
98 break;
99 case CMD_RECONNECT_DATA_CHAN:
100 pr_debug("%s(), Got RECONNECT_DATA_CHAN command\n", __func__);
101 pr_debug("%s(), NOT IMPLEMENTED\n", __func__);
102 break;
103 case CMD_CLOSE_DATA_CHAN:
104 pr_debug("Got CLOSE_DATA_CHAN command!\n");
105 pr_debug("%s(), NOT IMPLEMENTED\n", __func__);
106 break;
107 default:
108 pr_debug("%s(), Unknown command!\n", __func__);
109 break;
110 }
111 return 0;
112 }
113
114 /*
115 * Function irlan_provider_connect_indication (handle, skb, priv)
116 *
117 * Got connection from peer IrLAN client
118 *
119 */
120 static void irlan_provider_connect_indication(void *instance, void *sap,
121 struct qos_info *qos,
122 __u32 max_sdu_size,
123 __u8 max_header_size,
124 struct sk_buff *skb)
125 {
126 struct irlan_cb *self;
127 struct tsap_cb *tsap;
128
129 self = instance;
130 tsap = sap;
131
132 IRDA_ASSERT(self != NULL, return;);
133 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
134
135 IRDA_ASSERT(tsap == self->provider.tsap_ctrl,return;);
136 IRDA_ASSERT(self->provider.state == IRLAN_IDLE, return;);
137
138 self->provider.max_sdu_size = max_sdu_size;
139 self->provider.max_header_size = max_header_size;
140
141 irlan_do_provider_event(self, IRLAN_CONNECT_INDICATION, NULL);
142
143 /*
144 * If we are in peer mode, the client may not have got the discovery
145 * indication it needs to make progress. If the client is still in
146 * IDLE state, we must kick it.
147 */
148 if ((self->provider.access_type == ACCESS_PEER) &&
149 (self->client.state == IRLAN_IDLE))
150 {
151 irlan_client_wakeup(self, self->saddr, self->daddr);
152 }
153 }
154
155 /*
156 * Function irlan_provider_connect_response (handle)
157 *
158 * Accept incoming connection
159 *
160 */
161 void irlan_provider_connect_response(struct irlan_cb *self,
162 struct tsap_cb *tsap)
163 {
164 IRDA_ASSERT(self != NULL, return;);
165 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
166
167 /* Just accept */
168 irttp_connect_response(tsap, IRLAN_MTU, NULL);
169 }
170
171 static void irlan_provider_disconnect_indication(void *instance, void *sap,
172 LM_REASON reason,
173 struct sk_buff *userdata)
174 {
175 struct irlan_cb *self;
176 struct tsap_cb *tsap;
177
178 pr_debug("%s(), reason=%d\n", __func__ , reason);
179
180 self = instance;
181 tsap = sap;
182
183 IRDA_ASSERT(self != NULL, return;);
184 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
185 IRDA_ASSERT(tsap != NULL, return;);
186 IRDA_ASSERT(tsap->magic == TTP_TSAP_MAGIC, return;);
187
188 IRDA_ASSERT(tsap == self->provider.tsap_ctrl, return;);
189
190 irlan_do_provider_event(self, IRLAN_LMP_DISCONNECT, NULL);
191 }
192
193 /*
194 * Function irlan_parse_open_data_cmd (self, skb)
195 *
196 *
197 *
198 */
199 int irlan_parse_open_data_cmd(struct irlan_cb *self, struct sk_buff *skb)
200 {
201 int ret;
202
203 ret = irlan_provider_parse_command(self, CMD_OPEN_DATA_CHANNEL, skb);
204
205 /* Open data channel */
206 irlan_open_data_tsap(self);
207
208 return ret;
209 }
210
211 /*
212 * Function parse_command (skb)
213 *
214 * Extract all parameters from received buffer, then feed them to
215 * check_params for parsing
216 *
217 */
218 int irlan_provider_parse_command(struct irlan_cb *self, int cmd,
219 struct sk_buff *skb)
220 {
221 __u8 *frame;
222 __u8 *ptr;
223 int count;
224 __u16 val_len;
225 int i;
226 char *name;
227 char *value;
228 int ret = RSP_SUCCESS;
229
230 IRDA_ASSERT(skb != NULL, return -RSP_PROTOCOL_ERROR;);
231
232 pr_debug("%s(), skb->len=%d\n", __func__ , (int)skb->len);
233
234 IRDA_ASSERT(self != NULL, return -RSP_PROTOCOL_ERROR;);
235 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -RSP_PROTOCOL_ERROR;);
236
237 if (!skb)
238 return -RSP_PROTOCOL_ERROR;
239
240 frame = skb->data;
241
242 name = kmalloc(255, GFP_ATOMIC);
243 if (!name)
244 return -RSP_INSUFFICIENT_RESOURCES;
245 value = kmalloc(1016, GFP_ATOMIC);
246 if (!value) {
247 kfree(name);
248 return -RSP_INSUFFICIENT_RESOURCES;
249 }
250
251 /* How many parameters? */
252 count = frame[1];
253
254 pr_debug("Got %d parameters\n", count);
255
256 ptr = frame+2;
257
258 /* For all parameters */
259 for (i=0; i<count;i++) {
260 ret = irlan_extract_param(ptr, name, value, &val_len);
261 if (ret < 0) {
262 pr_debug("%s(), IrLAN, Error!\n", __func__);
263 break;
264 }
265 ptr+=ret;
266 ret = RSP_SUCCESS;
267 irlan_check_command_param(self, name, value);
268 }
269 /* Cleanup */
270 kfree(name);
271 kfree(value);
272
273 return ret;
274 }
275
276 /*
277 * Function irlan_provider_send_reply (self, info)
278 *
279 * Send reply to query to peer IrLAN layer
280 *
281 */
282 void irlan_provider_send_reply(struct irlan_cb *self, int command,
283 int ret_code)
284 {
285 struct sk_buff *skb;
286
287 IRDA_ASSERT(self != NULL, return;);
288 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return;);
289
290 skb = alloc_skb(IRLAN_MAX_HEADER + IRLAN_CMD_HEADER +
291 /* Bigger param length comes from CMD_GET_MEDIA_CHAR */
292 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "DIRECTED") +
293 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "BROADCAST") +
294 IRLAN_STRING_PARAMETER_LEN("FILTER_TYPE", "MULTICAST") +
295 IRLAN_STRING_PARAMETER_LEN("ACCESS_TYPE", "HOSTED"),
296 GFP_ATOMIC);
297
298 if (!skb)
299 return;
300
301 /* Reserve space for TTP, LMP, and LAP header */
302 skb_reserve(skb, self->provider.max_header_size);
303 skb_put(skb, 2);
304
305 switch (command) {
306 case CMD_GET_PROVIDER_INFO:
307 skb->data[0] = 0x00; /* Success */
308 skb->data[1] = 0x02; /* 2 parameters */
309 switch (self->media) {
310 case MEDIA_802_3:
311 irlan_insert_string_param(skb, "MEDIA", "802.3");
312 break;
313 case MEDIA_802_5:
314 irlan_insert_string_param(skb, "MEDIA", "802.5");
315 break;
316 default:
317 pr_debug("%s(), unknown media type!\n", __func__);
318 break;
319 }
320 irlan_insert_short_param(skb, "IRLAN_VER", 0x0101);
321 break;
322
323 case CMD_GET_MEDIA_CHAR:
324 skb->data[0] = 0x00; /* Success */
325 skb->data[1] = 0x05; /* 5 parameters */
326 irlan_insert_string_param(skb, "FILTER_TYPE", "DIRECTED");
327 irlan_insert_string_param(skb, "FILTER_TYPE", "BROADCAST");
328 irlan_insert_string_param(skb, "FILTER_TYPE", "MULTICAST");
329
330 switch (self->provider.access_type) {
331 case ACCESS_DIRECT:
332 irlan_insert_string_param(skb, "ACCESS_TYPE", "DIRECT");
333 break;
334 case ACCESS_PEER:
335 irlan_insert_string_param(skb, "ACCESS_TYPE", "PEER");
336 break;
337 case ACCESS_HOSTED:
338 irlan_insert_string_param(skb, "ACCESS_TYPE", "HOSTED");
339 break;
340 default:
341 pr_debug("%s(), Unknown access type\n", __func__);
342 break;
343 }
344 irlan_insert_short_param(skb, "MAX_FRAME", 0x05ee);
345 break;
346 case CMD_OPEN_DATA_CHANNEL:
347 skb->data[0] = 0x00; /* Success */
348 if (self->provider.send_arb_val) {
349 skb->data[1] = 0x03; /* 3 parameters */
350 irlan_insert_short_param(skb, "CON_ARB",
351 self->provider.send_arb_val);
352 } else
353 skb->data[1] = 0x02; /* 2 parameters */
354 irlan_insert_byte_param(skb, "DATA_CHAN", self->stsap_sel_data);
355 irlan_insert_string_param(skb, "RECONNECT_KEY", "LINUX RULES!");
356 break;
357 case CMD_FILTER_OPERATION:
358 irlan_filter_request(self, skb);
359 break;
360 default:
361 pr_debug("%s(), Unknown command!\n", __func__);
362 break;
363 }
364
365 irttp_data_request(self->provider.tsap_ctrl, skb);
366 }
367
368 /*
369 * Function irlan_provider_register(void)
370 *
371 * Register provider support so we can accept incoming connections.
372 *
373 */
374 int irlan_provider_open_ctrl_tsap(struct irlan_cb *self)
375 {
376 struct tsap_cb *tsap;
377 notify_t notify;
378
379 IRDA_ASSERT(self != NULL, return -1;);
380 IRDA_ASSERT(self->magic == IRLAN_MAGIC, return -1;);
381
382 /* Check if already open */
383 if (self->provider.tsap_ctrl)
384 return -1;
385
386 /*
387 * First register well known control TSAP
388 */
389 irda_notify_init(&notify);
390 notify.data_indication = irlan_provider_data_indication;
391 notify.connect_indication = irlan_provider_connect_indication;
392 notify.disconnect_indication = irlan_provider_disconnect_indication;
393 notify.instance = self;
394 strlcpy(notify.name, "IrLAN ctrl (p)", sizeof(notify.name));
395
396 tsap = irttp_open_tsap(LSAP_ANY, 1, &notify);
397 if (!tsap) {
398 pr_debug("%s(), Got no tsap!\n", __func__);
399 return -1;
400 }
401 self->provider.tsap_ctrl = tsap;
402
403 /* Register with LM-IAS */
404 irlan_ias_register(self, tsap->stsap_sel);
405
406 return 0;
407 }
408
Linux with added FPC-III support