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;
670 BT_DBG("sk %p", sk);
678 lock_sock(sk);
682 if (sk->sk_type != SOCK_STREAM) {
700 rfcomm_pi(sk)->sec_level = sec.level;
704 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
715 set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
717 clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
726 release_sock(sk);
732 struct sock *sk = sock->sk;
739 BT_DBG("sk %p", sk);
744 lock_sock(sk);
748 switch (rfcomm_pi(sk)->sec_level) {
768 if (rfcomm_pi(sk)->role_switch)
777 if (sk->sk_state != BT_CONNECTED &&
778 !rfcomm_pi(sk)->dlc->defer_setup) {
783 l2cap_sk = rfcomm_pi(sk)->dlc->session->sock->sk;
801 release_sock(sk);
807 struct sock *sk = sock->sk;
811 BT_DBG("sk %p", sk);
822 lock_sock(sk);
826 if (sk->sk_type != SOCK_STREAM) {
831 sec.level = rfcomm_pi(sk)->sec_level;
841 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
846 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
857 release_sock(sk);
863 struct sock *sk __maybe_unused = sock->sk;
866 BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
872 lock_sock(sk);
873 err = rfcomm_dev_ioctl(sk, cmd, (void __user *) arg);
874 release_sock(sk);
892 struct sock *sk = sock->sk;
895 BT_DBG("sock %p, sk %p", sock, sk);
897 if (!sk)
900 lock_sock(sk);
901 if (!sk->sk_shutdown) {
902 sk->sk_shutdown = SHUTDOWN_MASK;
904 release_sock(sk);
905 __rfcomm_sock_close(sk);
906 lock_sock(sk);
908 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime &&
910 err = bt_sock_wait_state(sk, BT_CLOSED, sk->sk_lingertime);
912 release_sock(sk);
918 struct sock *sk = sock->sk;
921 BT_DBG("sock %p, sk %p", sock, sk);
923 if (!sk)
928 sock_orphan(sk);
929 rfcomm_sock_kill(sk);
939 struct sock *sk, *parent;
960 sk = rfcomm_sock_alloc(sock_net(parent), NULL, BTPROTO_RFCOMM, GFP_ATOMIC, 0);
961 if (!sk)
964 bt_sock_reclassify_lock(sk, BTPROTO_RFCOMM);
966 rfcomm_sock_init(sk, parent);
967 bacpy(&rfcomm_pi(sk)->src, &src);
968 bacpy(&rfcomm_pi(sk)->dst, &dst);
969 rfcomm_pi(sk)->channel = channel;
971 sk->sk_state = BT_CONFIG;
972 bt_accept_enqueue(parent, sk, true);
975 *d = rfcomm_pi(sk)->dlc;
989 struct sock *sk;
993 sk_for_each(sk, &rfcomm_sk_list.head) {
995 &rfcomm_pi(sk)->src, &rfcomm_pi(sk)->dst,
996 sk->sk_state, rfcomm_pi(sk)->channel);