Lines Matching refs:sk
78 void dccp_set_state(struct sock *sk, const int state)
80 const int oldstate = sk->sk_state;
82 dccp_pr_debug("%s(%p) %s --> %s\n", dccp_role(sk), sk,
92 dccp_feat_list_purge(&dccp_sk(sk)->dccps_featneg);
100 sk->sk_prot->unhash(sk);
101 if (inet_csk(sk)->icsk_bind_hash != NULL &&
102 !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
103 inet_put_port(sk);
113 inet_sk_set_state(sk, state);
118 static void dccp_finish_passive_close(struct sock *sk)
120 switch (sk->sk_state) {
123 dccp_send_reset(sk, DCCP_RESET_CODE_CLOSED);
124 dccp_set_state(sk, DCCP_CLOSED);
131 dccp_send_close(sk, 1);
132 dccp_set_state(sk, DCCP_CLOSING);
136 void dccp_done(struct sock *sk)
138 dccp_set_state(sk, DCCP_CLOSED);
139 dccp_clear_xmit_timers(sk);
141 sk->sk_shutdown = SHUTDOWN_MASK;
143 if (!sock_flag(sk, SOCK_DEAD))
144 sk->sk_state_change(sk);
146 inet_csk_destroy_sock(sk);
174 void dccp_destruct_common(struct sock *sk)
176 struct dccp_sock *dp = dccp_sk(sk);
178 ccid_hc_tx_delete(dp->dccps_hc_tx_ccid, sk);
183 static void dccp_sk_destruct(struct sock *sk)
185 dccp_destruct_common(sk);
186 inet_sock_destruct(sk);
189 int dccp_init_sock(struct sock *sk, const __u8 ctl_sock_initialized)
191 struct dccp_sock *dp = dccp_sk(sk);
192 struct inet_connection_sock *icsk = inet_csk(sk);
196 sk->sk_state = DCCP_CLOSED;
197 sk->sk_write_space = dccp_write_space;
198 sk->sk_destruct = dccp_sk_destruct;
206 dccp_init_xmit_timers(sk);
211 return dccp_feat_init(sk);
217 void dccp_destroy_sock(struct sock *sk)
219 struct dccp_sock *dp = dccp_sk(sk);
221 __skb_queue_purge(&sk->sk_write_queue);
222 if (sk->sk_send_head != NULL) {
223 kfree_skb(sk->sk_send_head);
224 sk->sk_send_head = NULL;
228 if (inet_csk(sk)->icsk_bind_hash != NULL)
229 inet_put_port(sk);
238 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
247 static inline int dccp_listen_start(struct sock *sk, int backlog)
249 struct dccp_sock *dp = dccp_sk(sk);
255 return inet_csk_listen_start(sk, backlog);
264 int dccp_disconnect(struct sock *sk, int flags)
266 struct inet_connection_sock *icsk = inet_csk(sk);
267 struct inet_sock *inet = inet_sk(sk);
268 struct dccp_sock *dp = dccp_sk(sk);
269 const int old_state = sk->sk_state;
272 dccp_set_state(sk, DCCP_CLOSED);
279 inet_csk_listen_stop(sk);
281 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
282 sk->sk_err = ECONNRESET;
284 sk->sk_err = ECONNRESET;
286 dccp_clear_xmit_timers(sk);
287 ccid_hc_rx_delete(dp->dccps_hc_rx_ccid, sk);
290 __skb_queue_purge(&sk->sk_receive_queue);
291 __skb_queue_purge(&sk->sk_write_queue);
292 if (sk->sk_send_head != NULL) {
293 __kfree_skb(sk->sk_send_head);
294 sk->sk_send_head = NULL;
299 if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
300 inet_reset_saddr(sk);
302 sk->sk_shutdown = 0;
303 sock_reset_flag(sk, SOCK_DONE);
306 inet_csk_delack_init(sk);
307 __sk_dst_reset(sk);
311 sk->sk_error_report(sk);
327 struct sock *sk = sock->sk;
334 state = inet_sk_state_load(sk);
336 return inet_csk_listen_poll(sk);
344 if (READ_ONCE(sk->sk_err))
346 shutdown = READ_ONCE(sk->sk_shutdown);
355 if (atomic_read(&sk->sk_rmem_alloc) > 0)
359 if (sk_stream_is_writeable(sk)) {
362 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
363 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
369 if (sk_stream_is_writeable(sk))
378 int dccp_ioctl(struct sock *sk, int cmd, unsigned long arg)
382 lock_sock(sk);
384 if (sk->sk_state == DCCP_LISTEN)
389 int amount = sk_wmem_alloc_get(sk);
401 skb = skb_peek(&sk->sk_receive_queue);
417 release_sock(sk);
423 static int dccp_setsockopt_service(struct sock *sk, const __be32 service,
426 struct dccp_sock *dp = dccp_sk(sk);
447 lock_sock(sk);
453 release_sock(sk);
457 static int dccp_setsockopt_cscov(struct sock *sk, int cscov, bool rx)
481 rc = dccp_feat_register_sp(sk, DCCPF_MIN_CSUM_COVER, rx, list, len);
485 dccp_sk(sk)->dccps_pcrlen = cscov;
487 dccp_sk(sk)->dccps_pcslen = cscov;
493 static int dccp_setsockopt_ccid(struct sock *sk, int type,
506 lock_sock(sk);
508 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 1, val, optlen);
511 rc = dccp_feat_register_sp(sk, DCCPF_CCID, 0, val, optlen);
512 release_sock(sk);
518 static int do_dccp_setsockopt(struct sock *sk, int level, int optname,
521 struct dccp_sock *dp = dccp_sk(sk);
535 return dccp_setsockopt_ccid(sk, optname, optval, optlen);
545 return dccp_setsockopt_service(sk, val, optval, optlen);
547 lock_sock(sk);
556 err = dccp_setsockopt_cscov(sk, val, false);
559 err = dccp_setsockopt_cscov(sk, val, true);
562 if (sk->sk_state != DCCP_CLOSED)
579 release_sock(sk);
584 int dccp_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
588 return inet_csk(sk)->icsk_af_ops->setsockopt(sk, level,
591 return do_dccp_setsockopt(sk, level, optname, optval, optlen);
596 static int dccp_getsockopt_service(struct sock *sk, int len,
600 const struct dccp_sock *dp = dccp_sk(sk);
604 lock_sock(sk);
620 release_sock(sk);
624 static int do_dccp_getsockopt(struct sock *sk, int level, int optname,
636 dp = dccp_sk(sk);
643 return dccp_getsockopt_service(sk, len,
649 return ccid_getsockopt_builtin_ccids(sk, len, optval, optlen);
676 return ccid_hc_rx_getsockopt(dp->dccps_hc_rx_ccid, sk, optname,
679 return ccid_hc_tx_getsockopt(dp->dccps_hc_tx_ccid, sk, optname,
692 int dccp_getsockopt(struct sock *sk, int level, int optname,
696 return inet_csk(sk)->icsk_af_ops->getsockopt(sk, level,
699 return do_dccp_getsockopt(sk, level, optname, optval, optlen);
728 !dccp_qpolicy_param_ok(skb->sk, cmsg->cmsg_type))
744 int dccp_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
746 const struct dccp_sock *dp = dccp_sk(sk);
753 trace_dccp_probe(sk, len);
758 lock_sock(sk);
760 timeo = sock_sndtimeo(sk, noblock);
767 if ((1 << sk->sk_state) & ~(DCCPF_OPEN | DCCPF_PARTOPEN))
768 if ((rc = sk_stream_wait_connect(sk, &timeo)) != 0)
771 size = sk->sk_prot->max_header + len;
772 release_sock(sk);
773 skb = sock_alloc_send_skb(sk, size, noblock, &rc);
774 lock_sock(sk);
778 if (dccp_qpolicy_full(sk)) {
783 if (sk->sk_state == DCCP_CLOSED) {
794 skb_reserve(skb, sk->sk_prot->max_header);
803 dccp_qpolicy_push(sk, skb);
810 dccp_write_xmit(sk);
812 release_sock(sk);
821 int dccp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
827 lock_sock(sk);
829 if (sk->sk_state == DCCP_LISTEN) {
834 timeo = sock_rcvtimeo(sk, nonblock);
837 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
852 dccp_finish_passive_close(sk);
862 sk_eat_skb(sk, skb);
865 if (sock_flag(sk, SOCK_DONE)) {
870 if (sk->sk_err) {
871 len = sock_error(sk);
875 if (sk->sk_shutdown & RCV_SHUTDOWN) {
880 if (sk->sk_state == DCCP_CLOSED) {
881 if (!sock_flag(sk, SOCK_DONE)) {
902 sk_wait_data(sk, &timeo, NULL);
919 sk_eat_skb(sk, skb);
923 release_sock(sk);
931 struct sock *sk = sock->sk;
935 lock_sock(sk);
941 old_state = sk->sk_state;
945 WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
951 * FIXME: here it probably should be sk->sk_prot->listen_start
954 err = dccp_listen_start(sk, backlog);
961 release_sock(sk);
967 static void dccp_terminate_connection(struct sock *sk)
971 switch (sk->sk_state) {
974 dccp_finish_passive_close(sk);
977 dccp_pr_debug("Stop PARTOPEN timer (%p)\n", sk);
978 inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
981 dccp_send_close(sk, 1);
983 if (dccp_sk(sk)->dccps_role == DCCP_ROLE_SERVER &&
984 !dccp_sk(sk)->dccps_server_timewait)
990 dccp_set_state(sk, next_state);
994 void dccp_close(struct sock *sk, long timeout)
996 struct dccp_sock *dp = dccp_sk(sk);
1001 lock_sock(sk);
1003 sk->sk_shutdown = SHUTDOWN_MASK;
1005 if (sk->sk_state == DCCP_LISTEN) {
1006 dccp_set_state(sk, DCCP_CLOSED);
1009 inet_csk_listen_stop(sk);
1014 sk_stop_timer(sk, &dp->dccps_xmit_timer);
1021 while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
1027 if (sk->sk_state == DCCP_CLOSED)
1033 dccp_send_reset(sk, DCCP_RESET_CODE_ABORTED);
1034 dccp_set_state(sk, DCCP_CLOSED);
1035 } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1037 sk->sk_prot->disconnect(sk, 0);
1038 } else if (sk->sk_state != DCCP_CLOSED) {
1043 dccp_flush_write_queue(sk, &timeout);
1044 dccp_terminate_connection(sk);
1053 __skb_queue_purge(&sk->sk_write_queue);
1055 sk_stream_wait_close(sk, timeout);
1058 state = sk->sk_state;
1059 sock_hold(sk);
1060 sock_orphan(sk);
1065 release_sock(sk);
1071 bh_lock_sock(sk);
1072 WARN_ON(sock_owned_by_user(sk));
1077 if (state != DCCP_CLOSED && sk->sk_state == DCCP_CLOSED)
1080 if (sk->sk_state == DCCP_CLOSED)
1081 inet_csk_destroy_sock(sk);
1086 bh_unlock_sock(sk);
1088 sock_put(sk);
1093 void dccp_shutdown(struct sock *sk, int how)