Lines Matching refs:sk
43 static void rfcomm_sock_close(struct sock *sk);
44 static void rfcomm_sock_kill(struct sock *sk);
52 struct sock *sk = d->owner;
53 if (!sk)
56 atomic_add(skb->len, &sk->sk_rmem_alloc);
57 skb_queue_tail(&sk->sk_receive_queue, skb);
58 sk->sk_data_ready(sk);
60 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
66 struct sock *sk = d->owner, *parent;
68 if (!sk)
73 lock_sock(sk);
76 sk->sk_err = err;
78 sk->sk_state = d->state;
80 parent = bt_sk(sk)->parent;
83 sock_set_flag(sk, SOCK_ZAPPED);
84 bt_accept_unlink(sk);
90 &rfcomm_pi(sk)->src, NULL);
91 sk->sk_state_change(sk);
94 release_sock(sk);
96 if (parent && sock_flag(sk, SOCK_ZAPPED)) {
100 rfcomm_sock_kill(sk);
108 struct sock *sk = NULL;
110 sk_for_each(sk, &rfcomm_sk_list.head) {
111 if (rfcomm_pi(sk)->channel != channel)
114 if (bacmp(&rfcomm_pi(sk)->src, src))
117 if (sk->sk_state == BT_BOUND || sk->sk_state == BT_LISTEN)
121 return sk ? sk : NULL;
129 struct sock *sk = NULL, *sk1 = NULL;
133 sk_for_each(sk, &rfcomm_sk_list.head) {
134 if (state && sk->sk_state != state)
137 if (rfcomm_pi(sk)->channel == channel) {
139 if (!bacmp(&rfcomm_pi(sk)->src, src))
143 if (!bacmp(&rfcomm_pi(sk)->src, BDADDR_ANY))
144 sk1 = sk;
150 return sk ? sk : sk1;
153 static void rfcomm_sock_destruct(struct sock *sk)
155 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
157 BT_DBG("sk %p dlc %p", sk, d);
159 skb_queue_purge(&sk->sk_receive_queue);
160 skb_queue_purge(&sk->sk_write_queue);
163 rfcomm_pi(sk)->dlc = NULL;
166 if (d->owner == sk)
175 struct sock *sk;
180 while ((sk = bt_accept_dequeue(parent, NULL))) {
181 rfcomm_sock_close(sk);
182 rfcomm_sock_kill(sk);
192 static void rfcomm_sock_kill(struct sock *sk)
194 if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
197 BT_DBG("sk %p state %d refcnt %d", sk, sk->sk_state, refcount_read(&sk->sk_refcnt));
200 bt_sock_unlink(&rfcomm_sk_list, sk);
201 sock_set_flag(sk, SOCK_DEAD);
202 sock_put(sk);
205 static void __rfcomm_sock_close(struct sock *sk)
207 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
209 BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
211 switch (sk->sk_state) {
213 rfcomm_sock_cleanup_listen(sk);
224 sock_set_flag(sk, SOCK_ZAPPED);
232 static void rfcomm_sock_close(struct sock *sk)
234 lock_sock(sk);
235 __rfcomm_sock_close(sk);
236 release_sock(sk);
239 static void rfcomm_sock_init(struct sock *sk, struct sock *parent)
241 struct rfcomm_pinfo *pi = rfcomm_pi(sk);
243 BT_DBG("sk %p", sk);
246 sk->sk_type = parent->sk_type;
253 security_sk_clone(parent, sk);
275 struct sock *sk;
277 sk = bt_sock_alloc(net, sock, &rfcomm_proto, proto, prio, kern);
278 if (!sk)
283 sk_free(sk);
290 rfcomm_pi(sk)->dlc = d;
291 d->owner = sk;
293 sk->sk_destruct = rfcomm_sock_destruct;
294 sk->sk_sndtimeo = RFCOMM_CONN_TIMEOUT;
296 sk->sk_sndbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
297 sk->sk_rcvbuf = RFCOMM_MAX_CREDITS * RFCOMM_DEFAULT_MTU * 10;
299 bt_sock_link(&rfcomm_sk_list, sk);
301 BT_DBG("sk %p", sk);
302 return sk;
308 struct sock *sk;
319 sk = rfcomm_sock_alloc(net, sock, protocol, GFP_ATOMIC, kern);
320 if (!sk)
323 rfcomm_sock_init(sk, NULL);
330 struct sock *sk = sock->sk;
341 BT_DBG("sk %p %pMR", sk, &sa.rc_bdaddr);
343 lock_sock(sk);
345 if (sk->sk_state != BT_OPEN) {
350 if (sk->sk_type != SOCK_STREAM) {
362 bacpy(&rfcomm_pi(sk)->src, &sa.rc_bdaddr);
363 rfcomm_pi(sk)->channel = sa.rc_channel;
364 sk->sk_state = BT_BOUND;
370 release_sock(sk);
377 struct sock *sk = sock->sk;
378 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
381 BT_DBG("sk %p", sk);
387 sock_hold(sk);
388 lock_sock(sk);
390 if (sk->sk_state != BT_OPEN && sk->sk_state != BT_BOUND) {
395 if (sk->sk_type != SOCK_STREAM) {
400 sk->sk_state = BT_CONNECT;
401 bacpy(&rfcomm_pi(sk)->dst, &sa->rc_bdaddr);
402 rfcomm_pi(sk)->channel = sa->rc_channel;
404 d->sec_level = rfcomm_pi(sk)->sec_level;
405 d->role_switch = rfcomm_pi(sk)->role_switch;
408 release_sock(sk);
409 err = rfcomm_dlc_open(d, &rfcomm_pi(sk)->src, &sa->rc_bdaddr,
411 lock_sock(sk);
412 if (!err && !sock_flag(sk, SOCK_ZAPPED))
413 err = bt_sock_wait_state(sk, BT_CONNECTED,
414 sock_sndtimeo(sk, flags & O_NONBLOCK));
417 release_sock(sk);
418 sock_put(sk);
424 struct sock *sk = sock->sk;
427 BT_DBG("sk %p backlog %d", sk, backlog);
429 lock_sock(sk);
431 if (sk->sk_state != BT_BOUND) {
436 if (sk->sk_type != SOCK_STREAM) {
441 if (!rfcomm_pi(sk)->channel) {
442 bdaddr_t *src = &rfcomm_pi(sk)->src;
451 rfcomm_pi(sk)->channel = channel;
462 sk->sk_max_ack_backlog = backlog;
463 sk->sk_ack_backlog = 0;
464 sk->sk_state = BT_LISTEN;
467 release_sock(sk);
475 struct sock *sk = sock->sk, *nsk;
479 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
481 if (sk->sk_type != SOCK_STREAM) {
486 timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
488 BT_DBG("sk %p timeo %ld", sk, timeo);
491 add_wait_queue_exclusive(sk_sleep(sk), &wait);
493 if (sk->sk_state != BT_LISTEN) {
498 nsk = bt_accept_dequeue(sk, newsock);
512 release_sock(sk);
516 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
518 remove_wait_queue(sk_sleep(sk), &wait);
528 release_sock(sk);
535 struct sock *sk = sock->sk;
537 BT_DBG("sock %p, sk %p", sock, sk);
539 if (peer && sk->sk_state != BT_CONNECTED &&
540 sk->sk_state != BT_CONNECT && sk->sk_state != BT_CONNECT2)
545 sa->rc_channel = rfcomm_pi(sk)->channel;
547 bacpy(&sa->rc_bdaddr, &rfcomm_pi(sk)->dst);
549 bacpy(&sa->rc_bdaddr, &rfcomm_pi(sk)->src);
557 struct sock *sk = sock->sk;
558 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
568 if (sk->sk_shutdown & SEND_SHUTDOWN)
571 BT_DBG("sock %p, sk %p", sock, sk);
573 lock_sock(sk);
575 sent = bt_sock_wait_ready(sk, msg->msg_flags);
577 release_sock(sk);
582 skb = bt_skb_sendmmsg(sk, msg, len, d->mtu, RFCOMM_SKB_HEAD_RESERVE,
597 struct sock *sk = sock->sk;
598 struct rfcomm_dlc *d = rfcomm_pi(sk)->dlc;
608 lock_sock(sk);
610 atomic_sub(len, &sk->sk_rmem_alloc);
612 if (atomic_read(&sk->sk_rmem_alloc) <= (sk->sk_rcvbuf >> 2))
613 rfcomm_dlc_unthrottle(rfcomm_pi(sk)->dlc);
614 release_sock(sk);
622 struct sock *sk = sock->sk;
626 BT_DBG("sk %p", sk);
628 lock_sock(sk);
643 rfcomm_pi(sk)->sec_level = BT_SECURITY_LOW;
645 rfcomm_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
647 rfcomm_pi(sk)->sec_level = BT_SECURITY_HIGH;
649 rfcomm_pi(sk)->role_switch = (opt & RFCOMM_LM_MASTER);
657 release_sock(sk);
664 struct sock *sk = sock->sk;
669 BT_DBG("sk %p", sk);
677 lock_sock(sk);
681 if (sk->sk_type != SOCK_STREAM) {
697 rfcomm_pi(sk)->sec_level = sec.level;
701 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
711 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
713 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
722 release_sock(sk);
728 struct sock *sk = sock->sk;
735 BT_DBG("sk %p", sk);
740 lock_sock(sk);
744 switch (rfcomm_pi(sk)->sec_level) {
764 if (rfcomm_pi(sk)->role_switch)
773 if (sk->sk_state != BT_CONNECTED &&
774 !rfcomm_pi(sk)->dlc->defer_setup) {
779 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
797 release_sock(sk);
803 struct sock *sk = sock->sk;
807 BT_DBG("sk %p", sk);
818 lock_sock(sk);
822 if (sk->sk_type != SOCK_STREAM) {
827 sec.level = rfcomm_pi(sk)->sec_level;
837 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
842 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
853 release_sock(sk);
859 struct sock *sk __maybe_unused = sock->sk;
862 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
868 lock_sock(sk);
869 err = rfcomm_dev_ioctl(sk, cmd, (void __user *) arg);
870 release_sock(sk);
888 struct sock *sk = sock->sk;
891 BT_DBG("sock %p, sk %p", sock, sk);
893 if (!sk)
896 lock_sock(sk);
897 if (!sk->sk_shutdown) {
898 sk->sk_shutdown = SHUTDOWN_MASK;
900 release_sock(sk);
901 __rfcomm_sock_close(sk);
902 lock_sock(sk);
904 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
906 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
908 release_sock(sk);
914 struct sock *sk = sock->sk;
917 BT_DBG("sock %p, sk %p", sock, sk);
919 if (!sk)
924 sock_orphan(sk);
925 rfcomm_sock_kill(sk);
935 struct sock *sk, *parent;
956 sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC, 0);
957 if (!sk)
960 bt_sock_reclassify_lock(sk, BTPROTO_RFCOMM);
962 rfcomm_sock_init(sk, parent);
963 bacpy(&rfcomm_pi(sk)->src, &src);
964 bacpy(&rfcomm_pi(sk)->dst, &dst);
965 rfcomm_pi(sk)->channel = channel;
967 sk->sk_state = BT_CONFIG;
968 bt_accept_enqueue(parent, sk, true);
971 *d = rfcomm_pi(sk)->dlc;
985 struct sock *sk;
989 sk_for_each(sk, &rfcomm_sk_list.head) {
991 &rfcomm_pi(sk)->src, &rfcomm_pi(sk)->dst,
992 sk->sk_state, rfcomm_pi(sk)->channel);