?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bluetooth: Ask upper layers for HCI disconnect reason
[linux-2.6/linux-2.6-openrd.git] / net / bluetooth / hci_conn.c
blob96281a11a1869294c905fb1b0a65071d1eb5ee17
1 /*
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
4
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License version 2 as
9 published by the Free Software Foundation;
10
11 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
12 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
14 IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
15 CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
16 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
17 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
22 SOFTWARE IS DISCLAIMED.
23 */
24
25 /* Bluetooth HCI connection handling. */
26
27 #include <linux/module.h>
28
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/kernel.h>
32 #include <linux/slab.h>
33 #include <linux/poll.h>
34 #include <linux/fcntl.h>
35 #include <linux/init.h>
36 #include <linux/skbuff.h>
37 #include <linux/interrupt.h>
38 #include <linux/notifier.h>
39 #include <net/sock.h>
40
41 #include <asm/system.h>
42 #include <asm/uaccess.h>
43 #include <asm/unaligned.h>
44
45 #include <net/bluetooth/bluetooth.h>
46 #include <net/bluetooth/hci_core.h>
47
48 void hci_acl_connect(struct hci_conn *conn)
49 {
50 struct hci_dev *hdev = conn->hdev;
51 struct inquiry_entry *ie;
52 struct hci_cp_create_conn cp;
53
54 BT_DBG("%p", conn);
55
56 conn->state = BT_CONNECT;
57 conn->out = 1;
58
59 conn->link_mode = HCI_LM_MASTER;
60
61 conn->attempt++;
62
63 conn->link_policy = hdev->link_policy;
64
65 memset(&cp, 0, sizeof(cp));
66 bacpy(&cp.bdaddr, &conn->dst);
67 cp.pscan_rep_mode = 0x02;
68
69 if ((ie = hci_inquiry_cache_lookup(hdev, &conn->dst))) {
70 if (inquiry_entry_age(ie) <= INQUIRY_ENTRY_AGE_MAX) {
71 cp.pscan_rep_mode = ie->data.pscan_rep_mode;
72 cp.pscan_mode = ie->data.pscan_mode;
73 cp.clock_offset = ie->data.clock_offset |
74 cpu_to_le16(0x8000);
75 }
76
77 memcpy(conn->dev_class, ie->data.dev_class, 3);
78 conn->ssp_mode = ie->data.ssp_mode;
79 }
80
81 cp.pkt_type = cpu_to_le16(conn->pkt_type);
82 if (lmp_rswitch_capable(hdev) && !(hdev->link_mode & HCI_LM_MASTER))
83 cp.role_switch = 0x01;
84 else
85 cp.role_switch = 0x00;
86
87 hci_send_cmd(hdev, HCI_OP_CREATE_CONN, sizeof(cp), &cp);
88 }
89
90 static void hci_acl_connect_cancel(struct hci_conn *conn)
91 {
92 struct hci_cp_create_conn_cancel cp;
93
94 BT_DBG("%p", conn);
95
96 if (conn->hdev->hci_ver < 2)
97 return;
98
99 bacpy(&cp.bdaddr, &conn->dst);
100 hci_send_cmd(conn->hdev, HCI_OP_CREATE_CONN_CANCEL, sizeof(cp), &cp);
101 }
102
103 void hci_acl_disconn(struct hci_conn *conn, __u8 reason)
104 {
105 struct hci_cp_disconnect cp;
106
107 BT_DBG("%p", conn);
108
109 conn->state = BT_DISCONN;
110
111 cp.handle = cpu_to_le16(conn->handle);
112 cp.reason = reason;
113 hci_send_cmd(conn->hdev, HCI_OP_DISCONNECT, sizeof(cp), &cp);
114 }
115
116 void hci_add_sco(struct hci_conn *conn, __u16 handle)
117 {
118 struct hci_dev *hdev = conn->hdev;
119 struct hci_cp_add_sco cp;
120
121 BT_DBG("%p", conn);
122
123 conn->state = BT_CONNECT;
124 conn->out = 1;
125
126 conn->attempt++;
127
128 cp.handle = cpu_to_le16(handle);
129 cp.pkt_type = cpu_to_le16(conn->pkt_type);
130
131 hci_send_cmd(hdev, HCI_OP_ADD_SCO, sizeof(cp), &cp);
132 }
133
134 void hci_setup_sync(struct hci_conn *conn, __u16 handle)
135 {
136 struct hci_dev *hdev = conn->hdev;
137 struct hci_cp_setup_sync_conn cp;
138
139 BT_DBG("%p", conn);
140
141 conn->state = BT_CONNECT;
142 conn->out = 1;
143
144 conn->attempt++;
145
146 cp.handle = cpu_to_le16(handle);
147 cp.pkt_type = cpu_to_le16(conn->pkt_type);
148
149 cp.tx_bandwidth = cpu_to_le32(0x00001f40);
150 cp.rx_bandwidth = cpu_to_le32(0x00001f40);
151 cp.max_latency = cpu_to_le16(0xffff);
152 cp.voice_setting = cpu_to_le16(hdev->voice_setting);
153 cp.retrans_effort = 0xff;
154
155 hci_send_cmd(hdev, HCI_OP_SETUP_SYNC_CONN, sizeof(cp), &cp);
156 }
157
158 static void hci_conn_timeout(unsigned long arg)
159 {
160 struct hci_conn *conn = (void *) arg;
161 struct hci_dev *hdev = conn->hdev;
162 __u8 reason;
163
164 BT_DBG("conn %p state %d", conn, conn->state);
165
166 if (atomic_read(&conn->refcnt))
167 return;
168
169 hci_dev_lock(hdev);
170
171 switch (conn->state) {
172 case BT_CONNECT:
173 case BT_CONNECT2:
174 if (conn->type == ACL_LINK)
175 hci_acl_connect_cancel(conn);
176 else
177 hci_acl_disconn(conn, 0x13);
178 break;
179 case BT_CONFIG:
180 case BT_CONNECTED:
181 reason = hci_proto_disconn_ind(conn);
182 hci_acl_disconn(conn, reason);
183 break;
184 default:
185 conn->state = BT_CLOSED;
186 break;
187 }
188
189 hci_dev_unlock(hdev);
190 }
191
192 static void hci_conn_idle(unsigned long arg)
193 {
194 struct hci_conn *conn = (void *) arg;
195
196 BT_DBG("conn %p mode %d", conn, conn->mode);
197
198 hci_conn_enter_sniff_mode(conn);
199 }
200
201 struct hci_conn *hci_conn_add(struct hci_dev *hdev, int type, bdaddr_t *dst)
202 {
203 struct hci_conn *conn;
204
205 BT_DBG("%s dst %s", hdev->name, batostr(dst));
206
207 conn = kzalloc(sizeof(struct hci_conn), GFP_ATOMIC);
208 if (!conn)
209 return NULL;
210
211 bacpy(&conn->dst, dst);
212 conn->hdev = hdev;
213 conn->type = type;
214 conn->mode = HCI_CM_ACTIVE;
215 conn->state = BT_OPEN;
216
217 conn->power_save = 1;
218
219 switch (type) {
220 case ACL_LINK:
221 conn->pkt_type = hdev->pkt_type & ACL_PTYPE_MASK;
222 break;
223 case SCO_LINK:
224 if (lmp_esco_capable(hdev))
225 conn->pkt_type = (hdev->esco_type & SCO_ESCO_MASK) |
226 (hdev->esco_type & EDR_ESCO_MASK);
227 else
228 conn->pkt_type = hdev->pkt_type & SCO_PTYPE_MASK;
229 break;
230 case ESCO_LINK:
231 conn->pkt_type = hdev->esco_type & ~EDR_ESCO_MASK;
232 break;
233 }
234
235 skb_queue_head_init(&conn->data_q);
236
237 setup_timer(&conn->disc_timer, hci_conn_timeout, (unsigned long)conn);
238 setup_timer(&conn->idle_timer, hci_conn_idle, (unsigned long)conn);
239
240 atomic_set(&conn->refcnt, 0);
241
242 hci_dev_hold(hdev);
243
244 tasklet_disable(&hdev->tx_task);
245
246 hci_conn_hash_add(hdev, conn);
247 if (hdev->notify)
248 hdev->notify(hdev, HCI_NOTIFY_CONN_ADD);
249
250 tasklet_enable(&hdev->tx_task);
251
252 return conn;
253 }
254
255 int hci_conn_del(struct hci_conn *conn)
256 {
257 struct hci_dev *hdev = conn->hdev;
258
259 BT_DBG("%s conn %p handle %d", hdev->name, conn, conn->handle);
260
261 del_timer(&conn->idle_timer);
262
263 del_timer(&conn->disc_timer);
264
265 if (conn->type == ACL_LINK) {
266 struct hci_conn *sco = conn->link;
267 if (sco)
268 sco->link = NULL;
269
270 /* Unacked frames */
271 hdev->acl_cnt += conn->sent;
272 } else {
273 struct hci_conn *acl = conn->link;
274 if (acl) {
275 acl->link = NULL;
276 hci_conn_put(acl);
277 }
278 }
279
280 tasklet_disable(&hdev->tx_task);
281
282 hci_conn_hash_del(hdev, conn);
283 if (hdev->notify)
284 hdev->notify(hdev, HCI_NOTIFY_CONN_DEL);
285
286 tasklet_enable(&hdev->tx_task);
287
288 skb_queue_purge(&conn->data_q);
289
290 return 0;
291 }
292
293 struct hci_dev *hci_get_route(bdaddr_t *dst, bdaddr_t *src)
294 {
295 int use_src = bacmp(src, BDADDR_ANY);
296 struct hci_dev *hdev = NULL;
297 struct list_head *p;
298
299 BT_DBG("%s -> %s", batostr(src), batostr(dst));
300
301 read_lock_bh(&hci_dev_list_lock);
302
303 list_for_each(p, &hci_dev_list) {
304 struct hci_dev *d = list_entry(p, struct hci_dev, list);
305
306 if (!test_bit(HCI_UP, &d->flags) || test_bit(HCI_RAW, &d->flags))
307 continue;
308
309 /* Simple routing:
310 * No source address - find interface with bdaddr != dst
311 * Source address - find interface with bdaddr == src
312 */
313
314 if (use_src) {
315 if (!bacmp(&d->bdaddr, src)) {
316 hdev = d; break;
317 }
318 } else {
319 if (bacmp(&d->bdaddr, dst)) {
320 hdev = d; break;
321 }
322 }
323 }
324
325 if (hdev)
326 hdev = hci_dev_hold(hdev);
327
328 read_unlock_bh(&hci_dev_list_lock);
329 return hdev;
330 }
331 EXPORT_SYMBOL(hci_get_route);
332
333 /* Create SCO or ACL connection.
334 * Device _must_ be locked */
335 struct hci_conn *hci_connect(struct hci_dev *hdev, int type, bdaddr_t *dst, __u8 sec_level, __u8 auth_type)
336 {
337 struct hci_conn *acl;
338 struct hci_conn *sco;
339
340 BT_DBG("%s dst %s", hdev->name, batostr(dst));
341
342 if (!(acl = hci_conn_hash_lookup_ba(hdev, ACL_LINK, dst))) {
343 if (!(acl = hci_conn_add(hdev, ACL_LINK, dst)))
344 return NULL;
345 }
346
347 hci_conn_hold(acl);
348
349 if (acl->state == BT_OPEN || acl->state == BT_CLOSED) {
350 acl->sec_level = sec_level;
351 acl->auth_type = auth_type;
352 hci_acl_connect(acl);
353 }
354
355 if (type == ACL_LINK)
356 return acl;
357
358 if (!(sco = hci_conn_hash_lookup_ba(hdev, type, dst))) {
359 if (!(sco = hci_conn_add(hdev, type, dst))) {
360 hci_conn_put(acl);
361 return NULL;
362 }
363 }
364
365 acl->link = sco;
366 sco->link = acl;
367
368 hci_conn_hold(sco);
369
370 if (acl->state == BT_CONNECTED &&
371 (sco->state == BT_OPEN || sco->state == BT_CLOSED)) {
372 if (lmp_esco_capable(hdev))
373 hci_setup_sync(sco, acl->handle);
374 else
375 hci_add_sco(sco, acl->handle);
376 }
377
378 return sco;
379 }
380 EXPORT_SYMBOL(hci_connect);
381
382 /* Check link security requirement */
383 int hci_conn_check_link_mode(struct hci_conn *conn)
384 {
385 BT_DBG("conn %p", conn);
386
387 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0 &&
388 !(conn->link_mode & HCI_LM_ENCRYPT))
389 return 0;
390
391 return 1;
392 }
393 EXPORT_SYMBOL(hci_conn_check_link_mode);
394
395 /* Authenticate remote device */
396 static int hci_conn_auth(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
397 {
398 BT_DBG("conn %p", conn);
399
400 if (sec_level > conn->sec_level) {
401 conn->sec_level = sec_level;
402 conn->auth_type = auth_type;
403 } else if (conn->link_mode & HCI_LM_AUTH)
404 return 1;
405
406 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
407 struct hci_cp_auth_requested cp;
408 cp.handle = cpu_to_le16(conn->handle);
409 hci_send_cmd(conn->hdev, HCI_OP_AUTH_REQUESTED,
410 sizeof(cp), &cp);
411 }
412
413 return 0;
414 }
415
416 /* Enable security */
417 int hci_conn_security(struct hci_conn *conn, __u8 sec_level, __u8 auth_type)
418 {
419 BT_DBG("conn %p", conn);
420
421 if (conn->auth_type == 0xff)
422 conn->auth_type = auth_type;
423
424 if (sec_level == BT_SECURITY_SDP)
425 return 1;
426
427 if (sec_level == BT_SECURITY_LOW) {
428 if (conn->ssp_mode > 0 && conn->hdev->ssp_mode > 0)
429 return hci_conn_auth(conn, sec_level, auth_type);
430 else
431 return 1;
432 }
433
434 if (conn->link_mode & HCI_LM_ENCRYPT)
435 return hci_conn_auth(conn, sec_level, auth_type);
436
437 if (test_and_set_bit(HCI_CONN_ENCRYPT_PEND, &conn->pend))
438 return 0;
439
440 if (hci_conn_auth(conn, sec_level, auth_type)) {
441 struct hci_cp_set_conn_encrypt cp;
442 cp.handle = cpu_to_le16(conn->handle);
443 cp.encrypt = 1;
444 hci_send_cmd(conn->hdev, HCI_OP_SET_CONN_ENCRYPT,
445 sizeof(cp), &cp);
446 }
447
448 return 0;
449 }
450 EXPORT_SYMBOL(hci_conn_security);
451
452 /* Change link key */
453 int hci_conn_change_link_key(struct hci_conn *conn)
454 {
455 BT_DBG("conn %p", conn);
456
457 if (!test_and_set_bit(HCI_CONN_AUTH_PEND, &conn->pend)) {
458 struct hci_cp_change_conn_link_key cp;
459 cp.handle = cpu_to_le16(conn->handle);
460 hci_send_cmd(conn->hdev, HCI_OP_CHANGE_CONN_LINK_KEY,
461 sizeof(cp), &cp);
462 }
463
464 return 0;
465 }
466 EXPORT_SYMBOL(hci_conn_change_link_key);
467
468 /* Switch role */
469 int hci_conn_switch_role(struct hci_conn *conn, __u8 role)
470 {
471 BT_DBG("conn %p", conn);
472
473 if (!role && conn->link_mode & HCI_LM_MASTER)
474 return 1;
475
476 if (!test_and_set_bit(HCI_CONN_RSWITCH_PEND, &conn->pend)) {
477 struct hci_cp_switch_role cp;
478 bacpy(&cp.bdaddr, &conn->dst);
479 cp.role = role;
480 hci_send_cmd(conn->hdev, HCI_OP_SWITCH_ROLE, sizeof(cp), &cp);
481 }
482
483 return 0;
484 }
485 EXPORT_SYMBOL(hci_conn_switch_role);
486
487 /* Enter active mode */
488 void hci_conn_enter_active_mode(struct hci_conn *conn)
489 {
490 struct hci_dev *hdev = conn->hdev;
491
492 BT_DBG("conn %p mode %d", conn, conn->mode);
493
494 if (test_bit(HCI_RAW, &hdev->flags))
495 return;
496
497 if (conn->mode != HCI_CM_SNIFF || !conn->power_save)
498 goto timer;
499
500 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
501 struct hci_cp_exit_sniff_mode cp;
502 cp.handle = cpu_to_le16(conn->handle);
503 hci_send_cmd(hdev, HCI_OP_EXIT_SNIFF_MODE, sizeof(cp), &cp);
504 }
505
506 timer:
507 if (hdev->idle_timeout > 0)
508 mod_timer(&conn->idle_timer,
509 jiffies + msecs_to_jiffies(hdev->idle_timeout));
510 }
511
512 /* Enter sniff mode */
513 void hci_conn_enter_sniff_mode(struct hci_conn *conn)
514 {
515 struct hci_dev *hdev = conn->hdev;
516
517 BT_DBG("conn %p mode %d", conn, conn->mode);
518
519 if (test_bit(HCI_RAW, &hdev->flags))
520 return;
521
522 if (!lmp_sniff_capable(hdev) || !lmp_sniff_capable(conn))
523 return;
524
525 if (conn->mode != HCI_CM_ACTIVE || !(conn->link_policy & HCI_LP_SNIFF))
526 return;
527
528 if (lmp_sniffsubr_capable(hdev) && lmp_sniffsubr_capable(conn)) {
529 struct hci_cp_sniff_subrate cp;
530 cp.handle = cpu_to_le16(conn->handle);
531 cp.max_latency = cpu_to_le16(0);
532 cp.min_remote_timeout = cpu_to_le16(0);
533 cp.min_local_timeout = cpu_to_le16(0);
534 hci_send_cmd(hdev, HCI_OP_SNIFF_SUBRATE, sizeof(cp), &cp);
535 }
536
537 if (!test_and_set_bit(HCI_CONN_MODE_CHANGE_PEND, &conn->pend)) {
538 struct hci_cp_sniff_mode cp;
539 cp.handle = cpu_to_le16(conn->handle);
540 cp.max_interval = cpu_to_le16(hdev->sniff_max_interval);
541 cp.min_interval = cpu_to_le16(hdev->sniff_min_interval);
542 cp.attempt = cpu_to_le16(4);
543 cp.timeout = cpu_to_le16(1);
544 hci_send_cmd(hdev, HCI_OP_SNIFF_MODE, sizeof(cp), &cp);
545 }
546 }
547
548 /* Drop all connection on the device */
549 void hci_conn_hash_flush(struct hci_dev *hdev)
550 {
551 struct hci_conn_hash *h = &hdev->conn_hash;
552 struct list_head *p;
553
554 BT_DBG("hdev %s", hdev->name);
555
556 p = h->list.next;
557 while (p != &h->list) {
558 struct hci_conn *c;
559
560 c = list_entry(p, struct hci_conn, list);
561 p = p->next;
562
563 c->state = BT_CLOSED;
564
565 hci_conn_del_sysfs(c);
566
567 hci_proto_disconn_cfm(c, 0x16);
568 hci_conn_del(c);
569 }
570 }
571
572 /* Check pending connect attempts */
573 void hci_conn_check_pending(struct hci_dev *hdev)
574 {
575 struct hci_conn *conn;
576
577 BT_DBG("hdev %s", hdev->name);
578
579 hci_dev_lock(hdev);
580
581 conn = hci_conn_hash_lookup_state(hdev, ACL_LINK, BT_CONNECT2);
582 if (conn)
583 hci_acl_connect(conn);
584
585 hci_dev_unlock(hdev);
586 }
587
588 int hci_get_conn_list(void __user *arg)
589 {
590 struct hci_conn_list_req req, *cl;
591 struct hci_conn_info *ci;
592 struct hci_dev *hdev;
593 struct list_head *p;
594 int n = 0, size, err;
595
596 if (copy_from_user(&req, arg, sizeof(req)))
597 return -EFAULT;
598
599 if (!req.conn_num || req.conn_num > (PAGE_SIZE * 2) / sizeof(*ci))
600 return -EINVAL;
601
602 size = sizeof(req) + req.conn_num * sizeof(*ci);
603
604 if (!(cl = kmalloc(size, GFP_KERNEL)))
605 return -ENOMEM;
606
607 if (!(hdev = hci_dev_get(req.dev_id))) {
608 kfree(cl);
609 return -ENODEV;
610 }
611
612 ci = cl->conn_info;
613
614 hci_dev_lock_bh(hdev);
615 list_for_each(p, &hdev->conn_hash.list) {
616 register struct hci_conn *c;
617 c = list_entry(p, struct hci_conn, list);
618
619 bacpy(&(ci + n)->bdaddr, &c->dst);
620 (ci + n)->handle = c->handle;
621 (ci + n)->type = c->type;
622 (ci + n)->out = c->out;
623 (ci + n)->state = c->state;
624 (ci + n)->link_mode = c->link_mode;
625 if (++n >= req.conn_num)
626 break;
627 }
628 hci_dev_unlock_bh(hdev);
629
630 cl->dev_id = hdev->id;
631 cl->conn_num = n;
632 size = sizeof(req) + n * sizeof(*ci);
633
634 hci_dev_put(hdev);
635
636 err = copy_to_user(arg, cl, size);
637 kfree(cl);
638
639 return err ? -EFAULT : 0;
640 }
641
642 int hci_get_conn_info(struct hci_dev *hdev, void __user *arg)
643 {
644 struct hci_conn_info_req req;
645 struct hci_conn_info ci;
646 struct hci_conn *conn;
647 char __user *ptr = arg + sizeof(req);
648
649 if (copy_from_user(&req, arg, sizeof(req)))
650 return -EFAULT;
651
652 hci_dev_lock_bh(hdev);
653 conn = hci_conn_hash_lookup_ba(hdev, req.type, &req.bdaddr);
654 if (conn) {
655 bacpy(&ci.bdaddr, &conn->dst);
656 ci.handle = conn->handle;
657 ci.type = conn->type;
658 ci.out = conn->out;
659 ci.state = conn->state;
660 ci.link_mode = conn->link_mode;
661 }
662 hci_dev_unlock_bh(hdev);
663
664 if (!conn)
665 return -ENOENT;
666
667 return copy_to_user(ptr, &ci, sizeof(ci)) ? -EFAULT : 0;
668 }
669
670 int hci_get_auth_info(struct hci_dev *hdev, void __user *arg)
671 {
672 struct hci_auth_info_req req;
673 struct hci_conn *conn;
674
675 if (copy_from_user(&req, arg, sizeof(req)))
676 return -EFAULT;
677
678 hci_dev_lock_bh(hdev);
679 conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &req.bdaddr);
680 if (conn)
681 req.type = conn->auth_type;
682 hci_dev_unlock_bh(hdev);
683
684 if (!conn)
685 return -ENOENT;
686
687 return copy_to_user(arg, &req, sizeof(req)) ? -EFAULT : 0;
688 }
linux 2.6 git repository for openrd