Lines Matching +full:tx +full:- +full:sched +full:- +full:sp
1 // SPDX-License-Identifier: GPL-2.0-or-later
4 * Copyright (c) 1999-2000 Cisco, Inc.
5 * Copyright (c) 1999-2001 Motorola, Inc.
6 * Copyright (c) 2001-2003 Intel Corp.
7 * Copyright (c) 2001-2002 Nokia, Inc.
16 * functions--this file is the functions which populate the struct proto
21 * lksctp developers <linux-sctp@vger.kernel.org>
31 * Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>
44 #include <linux/sched/signal.h>
110 struct sock *sk = asoc->base.sk;
112 return asoc->ep->sndbuf_policy ? sk->sk_sndbuf - asoc->sndbuf_used
120 * Since it is always 1-1 between chunk and skb, and also a new skb is always
127 struct sctp_association *asoc = chunk->asoc;
128 struct sock *sk = asoc->base.sk;
133 if (chunk->shkey)
134 sctp_auth_shkey_hold(chunk->shkey);
136 skb_set_owner_w(chunk->skb, sk);
138 chunk->skb->destructor = sctp_wfree;
140 skb_shinfo(chunk->skb)->destructor_arg = chunk;
142 refcount_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
143 asoc->sndbuf_used += chunk->skb->truesize + sizeof(struct sctp_chunk);
144 sk_wmem_queued_add(sk, chunk->skb->truesize + sizeof(struct sctp_chunk));
145 sk_mem_charge(sk, chunk->skb->truesize);
150 skb_orphan(chunk->skb);
155 msg = chunk->msg; \
158 list_for_each_entry(c, &msg->chunks, frag_list) { \
159 if ((clear && asoc->base.sk == c->skb->sk) || \
160 (!clear && asoc->base.sk != c->skb->sk)) \
172 struct sctp_outq *q = &asoc->outqueue;
176 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports)
177 list_for_each_entry(chunk, &t->transmitted, transmitted_list)
180 list_for_each_entry(chunk, &q->retransmit, transmitted_list)
183 list_for_each_entry(chunk, &q->sacked, transmitted_list)
186 list_for_each_entry(chunk, &q->abandoned, transmitted_list)
189 list_for_each_entry(chunk, &q->out_chunk_list, list)
199 sctp_skb_for_each(skb, &asoc->ulpq.lobby, tmp)
202 sctp_skb_for_each(skb, &asoc->ulpq.reasm, tmp)
205 sctp_skb_for_each(skb, &asoc->ulpq.reasm_uo, tmp)
218 return -EINVAL;
221 if (!af->addr_valid(addr, sctp_sk(sk), NULL))
222 return -EINVAL;
224 if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
225 return -EINVAL;
230 /* Look up the association by its id. If this is not a UDP-style
237 /* If this is not a UDP-style socket, assoc id should be ignored. */
240 * could be a TCP-style listening socket or a socket which
247 if (!list_empty(&sctp_sk(sk)->ep->asocs))
248 asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
253 /* Otherwise this is a UDP-style socket. */
259 if (asoc && (asoc->base.sk != sk || asoc->base.dead))
275 struct sctp_af *af = sctp_get_af_specific(addr->ss_family);
279 if (!af || sctp_verify_addr(sk, laddr, af->sockaddr_len))
282 addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
293 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
299 /* API 3.1.2 bind() - UDP Style Syntax
304 * sd - the socket descriptor returned by socket().
305 * addr - the address structure (struct sockaddr_in or struct
307 * addr_len - the size of the address structure.
319 if (!sctp_sk(sk)->ep->base.bind_addr.port)
323 retval = -EINVAL;
342 if (!opt->pf->af_supported(addr->sa.sa_family, opt))
345 if (addr->sa.sa_family == AF_INET6) {
349 if (ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
350 !opt->pf->af_supported(AF_INET, opt))
355 af = sctp_get_af_specific(addr->sa.sa_family);
357 if (len < af->sockaddr_len)
363 static void sctp_auto_asconf_init(struct sctp_sock *sp)
365 struct net *net = sock_net(&sp->inet.sk);
367 if (net->sctp.default_auto_asconf) {
368 spin_lock_bh(&net->sctp.addr_wq_lock);
369 list_add_tail(&sp->auto_asconf_list, &net->sctp.auto_asconf_splist);
370 spin_unlock_bh(&net->sctp.addr_wq_lock);
371 sp->do_auto_asconf = 1;
379 struct sctp_sock *sp = sctp_sk(sk);
380 struct sctp_endpoint *ep = sp->ep;
381 struct sctp_bind_addr *bp = &ep->base.bind_addr;
387 af = sctp_sockaddr_af(sp, addr, len);
391 return -EINVAL;
394 snum = ntohs(addr->v4.sin_port);
397 __func__, sk, &addr->sa, bp->port, snum, len);
400 if (!sp->pf->bind_verify(sp, addr))
401 return -EADDRNOTAVAIL;
407 if (bp->port) {
409 snum = bp->port;
410 else if (snum != bp->port) {
412 "%d\n", __func__, snum, bp->port);
413 return -EINVAL;
418 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
419 return -EACCES;
424 if (sctp_bind_addr_match(bp, addr, sp))
425 return -EINVAL;
431 addr->v4.sin_port = htons(snum);
433 return -EADDRINUSE;
436 if (!bp->port) {
437 bp->port = inet_sk(sk)->inet_num;
438 sctp_auto_asconf_init(sp);
444 ret = sctp_add_bind_addr(bp, addr, af->sockaddr_len,
452 inet_sk(sk)->inet_sport = htons(inet_sk(sk)->inet_num);
453 sp->pf->to_sk_saddr(addr, sk);
463 * ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
465 * time two ASCONF may be in-transit on any given association (one sent
476 if (asoc->addip_last_asconf) {
477 list_add_tail(&chunk->list, &asoc->addip_chunk_list);
483 retval = sctp_primitive_ASCONF(asoc->base.net, asoc, chunk);
487 asoc->addip_last_asconf = chunk;
522 af = sctp_get_af_specific(sa_addr->sa_family);
524 retval = -EINVAL;
529 af->sockaddr_len);
531 addr_buf += af->sockaddr_len;
559 struct sctp_sock *sp;
573 sp = sctp_sk(sk);
574 ep = sp->ep;
576 if (!ep->asconf_enable)
582 list_for_each_entry(asoc, &ep->asocs, asocs) {
583 if (!asoc->peer.asconf_capable)
586 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
600 af = sctp_get_af_specific(addr->v4.sin_family);
602 retval = -EINVAL;
609 addr_buf += af->sockaddr_len;
617 bp = &asoc->base.bind_addr;
618 p = bp->address_list.next;
620 chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
623 retval = -ENOMEM;
633 af = sctp_get_af_specific(addr->v4.sin_family);
634 memcpy(&saveaddr, addr, af->sockaddr_len);
638 addr_buf += af->sockaddr_len;
640 if (asoc->src_out_of_asoc_ok) {
644 &asoc->peer.transport_addr_list, transports) {
645 trans->cwnd = min(4*asoc->pathmtu, max_t(__u32,
646 2*asoc->pathmtu, 4380));
647 trans->ssthresh = asoc->peer.i.a_rwnd;
648 trans->rto = asoc->rto_initial;
650 trans->rtt = trans->srtt = trans->rttvar = 0;
653 sctp_sk(asoc->base.sk));
674 * available, the operation will return -EBUSY.
680 struct sctp_sock *sp = sctp_sk(sk);
681 struct sctp_endpoint *ep = sp->ep;
683 struct sctp_bind_addr *bp = &ep->base.bind_addr;
698 if (list_empty(&bp->address_list) ||
699 (sctp_list_single_entry(&bp->address_list))) {
700 retval = -EBUSY;
705 af = sctp_get_af_specific(sa_addr->sa.sa_family);
707 retval = -EINVAL;
711 if (!af->addr_valid(sa_addr, sp, NULL)) {
712 retval = -EADDRNOTAVAIL;
716 if (sa_addr->v4.sin_port &&
717 sa_addr->v4.sin_port != htons(bp->port)) {
718 retval = -EINVAL;
722 if (!sa_addr->v4.sin_port)
723 sa_addr->v4.sin_port = htons(bp->port);
725 /* FIXME - There is probably a need to check if sk->sk_saddr and
726 * sk->sk_rcv_addr are currently set to one of the addresses to
728 * when we are fixing the outstanding issues with multi-homing
730 * sctp_do_bind(). -daisy
734 addr_buf += af->sockaddr_len;
761 struct sctp_sock *sp;
776 sp = sctp_sk(sk);
777 ep = sp->ep;
779 if (!ep->asconf_enable)
785 list_for_each_entry(asoc, &ep->asocs, asocs) {
787 if (!asoc->peer.asconf_capable)
790 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
804 af = sctp_get_af_specific(laddr->v4.sin_family);
806 retval = -EINVAL;
813 addr_buf += af->sockaddr_len;
823 bp = &asoc->base.bind_addr;
825 addrcnt, sp);
827 if (asoc->asconf_addr_del_pending)
829 asoc->asconf_addr_del_pending =
831 if (asoc->asconf_addr_del_pending == NULL) {
832 retval = -ENOMEM;
835 asoc->asconf_addr_del_pending->sa.sa_family =
836 addrs->sa_family;
837 asoc->asconf_addr_del_pending->v4.sin_port =
838 htons(bp->port);
839 if (addrs->sa_family == AF_INET) {
843 asoc->asconf_addr_del_pending->v4.sin_addr.s_addr = sin->sin_addr.s_addr;
844 } else if (addrs->sa_family == AF_INET6) {
848 asoc->asconf_addr_del_pending->v6.sin6_addr = sin6->sin6_addr;
852 __func__, asoc, &asoc->asconf_addr_del_pending->sa,
853 asoc->asconf_addr_del_pending);
855 asoc->src_out_of_asoc_ok = 1;
861 return -EINVAL;
870 retval = -ENOMEM;
881 af = sctp_get_af_specific(laddr->v4.sin_family);
882 list_for_each_entry(saddr, &bp->address_list, list) {
883 if (sctp_cmp_addr_exact(&saddr->a, laddr))
884 saddr->state = SCTP_ADDR_DEL;
886 addr_buf += af->sockaddr_len;
893 list_for_each_entry(transport, &asoc->peer.transport_addr_list,
896 sctp_sk(asoc->base.sk));
909 int sctp_asconf_mgmt(struct sctp_sock *sp, struct sctp_sockaddr_entry *addrw)
911 struct sock *sk = sctp_opt2sk(sp);
916 addr = &addrw->a;
917 addr->v4.sin_port = htons(sp->ep->base.bind_addr.port);
918 af = sctp_get_af_specific(addr->sa.sa_family);
920 return -EINVAL;
921 if (sctp_verify_addr(sk, addr, af->sockaddr_len))
922 return -EINVAL;
924 if (addrw->state == SCTP_ADDR_NEW)
951 * -1, and sets errno to the appropriate error code.
1013 return -EINVAL;
1018 return -EINVAL;
1021 af = sctp_get_af_specific(sa_addr->sa_family);
1026 if (!af || (walk_size + af->sockaddr_len) > addrs_size)
1027 return -EINVAL;
1029 addr_buf += af->sockaddr_len;
1030 walk_size += af->sockaddr_len;
1052 return -EINVAL;
1073 struct sock *sk = ep->base.sk;
1079 return -EADDRNOTAVAIL;
1081 if (!ep->base.bind_addr.port) {
1083 return -EAGAIN;
1085 if (inet_port_requires_bind_service(net, ep->base.bind_addr.port) &&
1086 !ns_capable(net->user_ns, CAP_NET_BIND_SERVICE))
1087 return -EACCES;
1093 return -ENOMEM;
1101 err = -ENOMEM;
1108 if (init->sinit_num_ostreams) {
1109 __u16 outcnt = init->sinit_num_ostreams;
1111 asoc->c.sinit_num_ostreams = outcnt;
1112 /* outcnt has been changed, need to re-init stream */
1113 err = sctp_stream_init(&asoc->stream, outcnt, 0, GFP_KERNEL);
1118 if (init->sinit_max_instreams)
1119 asoc->c.sinit_max_instreams = init->sinit_max_instreams;
1121 if (init->sinit_max_attempts)
1122 asoc->max_init_attempts = init->sinit_max_attempts;
1124 if (init->sinit_max_init_timeo)
1125 asoc->max_init_timeo =
1126 msecs_to_jiffies(init->sinit_max_init_timeo);
1137 struct sctp_endpoint *ep = asoc->ep;
1142 err = sctp_verify_addr(ep->base.sk, daddr, addr_len);
1148 return old->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1149 : -EALREADY;
1152 return -EADDRNOTAVAIL;
1156 return -ENOMEM;
1169 struct sctp_sock *sp = sctp_sk(sk);
1170 struct sctp_endpoint *ep = sp->ep;
1181 return -EISCONN;
1184 af = sctp_get_af_specific(daddr->sa.sa_family);
1185 if (!af || af->sockaddr_len > addrs_size)
1186 return -EINVAL;
1188 err = sctp_verify_addr(sk, daddr, af->sockaddr_len);
1194 return asoc->state >= SCTP_STATE_ESTABLISHED ? -EISCONN
1195 : -EALREADY;
1200 asoc = transport->asoc;
1202 addr_buf += af->sockaddr_len;
1203 walk_size = af->sockaddr_len;
1205 err = -EINVAL;
1210 af = sctp_get_af_specific(daddr->sa.sa_family);
1211 if (!af || af->sockaddr_len + walk_size > addrs_size)
1214 if (asoc->peer.port != ntohs(daddr->v4.sin_port))
1217 err = sctp_connect_add_peer(asoc, daddr, af->sockaddr_len);
1221 addr_buf += af->sockaddr_len;
1222 walk_size += af->sockaddr_len;
1239 inet_sk(sk)->inet_dport = htons(asoc->peer.port);
1240 sp->pf->to_sk_daddr(daddr, sk);
1241 sk->sk_err = 0;
1244 *assoc_id = asoc->assoc_id;
1278 * returns -1, and sets errno to the appropriate error code. The assoc_id
1285 * an endpoint that is multi-homed. Much like sctp_bindx() this call
1321 return -EINVAL;
1330 /* in-kernel sockets don't generally have a file allocated to them
1333 if (sk->sk_socket->file)
1334 flags = sk->sk_socket->file->f_flags;
1373 * We use the sctp_getaddrs_old structure so that use-space library
1376 * addrs_num structure member. That way we can re-use the existing
1401 return -EINVAL;
1403 return -EFAULT;
1412 return -EINVAL;
1414 return -EFAULT;
1423 if (err == 0 || err == -EINPROGRESS) {
1425 return -EFAULT;
1427 return -EFAULT;
1433 /* API 3.1.4 close() - UDP Style Syntax
1436 * by a UDP-style socket.
1442 * sd - the socket descriptor of the associations to be closed.
1445 * UDP-style socket, an application should use the sendmsg() call,
1449 * If sd in the close() call is a branched-off socket representing only
1452 * 4.1.6 close() - TCP Style Syntax
1460 * sd - the socket descriptor of the association to be closed.
1467 * An application using the TCP-style socket can use this option to
1494 sk->sk_shutdown = SHUTDOWN_MASK;
1497 ep = sctp_sk(sk)->ep;
1500 data_was_unread = sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1501 data_was_unread += sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1504 list_for_each_safe(pos, temp, &ep->asocs) {
1509 * it belongs to a TCP-style listening socket that is
1519 if (data_was_unread || !skb_queue_empty(&asoc->ulpq.lobby) ||
1520 !skb_queue_empty(&asoc->ulpq.reasm) ||
1521 !skb_queue_empty(&asoc->ulpq.reasm_uo) ||
1522 (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime)) {
1531 /* On a TCP-style socket, block for at most linger_time if set. */
1543 spin_lock_bh(&net->sctp.addr_wq_lock);
1553 spin_unlock_bh(&net->sctp.addr_wq_lock);
1563 if (err == -EPIPE)
1564 err = sock_error(sk) ? : -EPIPE;
1565 if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1570 /* API 3.1.3 sendmsg() - UDP Style Syntax
1578 * socket - the socket descriptor of the endpoint.
1579 * message - pointer to the msghdr structure which contains a single
1585 * flags - flags sent or received with the user message, see Section
1604 return -EPIPE;
1606 if (msg_len > sk->sk_sndbuf)
1607 return -EMSGSIZE;
1617 if (cmsgs->srinfo) {
1618 srinfo->sinfo_stream = cmsgs->srinfo->sinfo_stream;
1619 srinfo->sinfo_flags = cmsgs->srinfo->sinfo_flags;
1620 srinfo->sinfo_ppid = cmsgs->srinfo->sinfo_ppid;
1621 srinfo->sinfo_context = cmsgs->srinfo->sinfo_context;
1622 srinfo->sinfo_assoc_id = cmsgs->srinfo->sinfo_assoc_id;
1623 srinfo->sinfo_timetolive = cmsgs->srinfo->sinfo_timetolive;
1626 if (cmsgs->sinfo) {
1627 srinfo->sinfo_stream = cmsgs->sinfo->snd_sid;
1628 srinfo->sinfo_flags = cmsgs->sinfo->snd_flags;
1629 srinfo->sinfo_ppid = cmsgs->sinfo->snd_ppid;
1630 srinfo->sinfo_context = cmsgs->sinfo->snd_context;
1631 srinfo->sinfo_assoc_id = cmsgs->sinfo->snd_assoc_id;
1634 if (cmsgs->prinfo) {
1635 srinfo->sinfo_timetolive = cmsgs->prinfo->pr_value;
1636 SCTP_PR_SET_POLICY(srinfo->sinfo_flags,
1637 cmsgs->prinfo->pr_policy);
1640 sflags = srinfo->sinfo_flags;
1645 return -EINVAL;
1649 return -EINVAL;
1651 if ((sflags & SCTP_ADDR_OVER) && !msg->msg_name)
1652 return -EINVAL;
1662 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1672 return -EINVAL;
1676 return -EADDRNOTAVAIL;
1678 /* Label connection socket for first association 1-to-many
1679 * style for client sequence socket()->sendmsg(). This
1684 af = sctp_get_af_specific(daddr->sa.sa_family);
1686 return -EINVAL;
1689 af->sockaddr_len);
1693 err = sctp_connect_new_asoc(ep, daddr, cmsgs->init, tp);
1696 asoc = (*tp)->asoc;
1698 if (!cmsgs->addrs_msg)
1701 if (daddr->sa.sa_family == AF_INET6)
1702 flowinfo = daddr->v6.sin6_flowinfo;
1705 for_each_cmsghdr(cmsg, cmsgs->addrs_msg) {
1709 if (cmsg->cmsg_level != IPPROTO_SCTP ||
1710 (cmsg->cmsg_type != SCTP_DSTADDRV4 &&
1711 cmsg->cmsg_type != SCTP_DSTADDRV6))
1716 dlen = cmsg->cmsg_len - sizeof(struct cmsghdr);
1717 if (cmsg->cmsg_type == SCTP_DSTADDRV4) {
1719 err = -EINVAL;
1724 daddr->v4.sin_family = AF_INET;
1725 daddr->v4.sin_port = htons(asoc->peer.port);
1726 memcpy(&daddr->v4.sin_addr, CMSG_DATA(cmsg), dlen);
1729 err = -EINVAL;
1734 daddr->v6.sin6_flowinfo = flowinfo;
1735 daddr->v6.sin6_family = AF_INET6;
1736 daddr->v6.sin6_port = htons(asoc->peer.port);
1737 memcpy(&daddr->v6.sin6_addr, CMSG_DATA(cmsg), dlen);
1756 struct sock *sk = asoc->base.sk;
1760 return -EPIPE;
1778 return -ENOMEM;
1782 iov_iter_revert(&msg->msg_iter, msg_len);
1795 struct sock *sk = asoc->base.sk;
1796 struct sctp_sock *sp = sctp_sk(sk);
1804 if (sinfo->sinfo_stream >= asoc->stream.outcnt) {
1805 err = -EINVAL;
1809 if (unlikely(!SCTP_SO(&asoc->stream, sinfo->sinfo_stream)->ext)) {
1810 err = sctp_stream_init_ext(&asoc->stream, sinfo->sinfo_stream);
1815 if (sp->disable_fragments && msg_len > asoc->frag_point) {
1816 err = -EMSGSIZE;
1820 if (asoc->pmtu_pending) {
1821 if (sp->param_flags & SPP_PMTUD_ENABLE)
1823 asoc->pmtu_pending = 0;
1827 sctp_prsctp_prune(asoc, sinfo, msg_len - sctp_wspace(asoc));
1830 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1834 if (unlikely(sinfo->sinfo_stream >= asoc->stream.outcnt)) {
1835 err = -EINVAL;
1845 if (asoc->ep->intl_enable) {
1849 err = -ESRCH;
1859 datamsg = sctp_datamsg_from_user(asoc, sinfo, &msg->msg_iter);
1865 asoc->force_delay = !!(msg->msg_flags & MSG_MORE);
1867 list_for_each_entry(chunk, &datamsg->chunks, frag_list) {
1870 chunk->transport = transport;
1884 timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1901 if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1902 int len = msg->msg_namelen;
1907 daddr = (union sctp_addr *)msg->msg_name;
1921 if (!cmsgs->srinfo && !cmsgs->sinfo) {
1922 sinfo->sinfo_stream = asoc->default_stream;
1923 sinfo->sinfo_ppid = asoc->default_ppid;
1924 sinfo->sinfo_context = asoc->default_context;
1925 sinfo->sinfo_assoc_id = sctp_assoc2id(asoc);
1927 if (!cmsgs->prinfo)
1928 sinfo->sinfo_flags = asoc->default_flags;
1931 if (!cmsgs->srinfo && !cmsgs->prinfo)
1932 sinfo->sinfo_timetolive = asoc->default_timetolive;
1934 if (cmsgs->authinfo) {
1936 * sinfo_ssn to save the keyid on tx path.
1938 sinfo->sinfo_tsn = 1;
1939 sinfo->sinfo_ssn = cmsgs->authinfo->auth_keynumber;
1945 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
1961 sflags = sinfo->sinfo_flags;
1974 list_for_each_entry_safe(asoc, tmp, &ep->asocs, asocs) {
1989 iov_iter_revert(&msg->msg_iter, err);
2009 asoc = transport->asoc;
2016 asoc = sctp_id2assoc(sk, sinfo->sinfo_assoc_id);
2018 err = -EPIPE;
2032 if (err < 0 && err != -ESRCH && new)
2038 return sctp_error(sk, msg->msg_flags, err);
2058 len -= skb_len;
2063 skb->len -= (len-rlen);
2064 skb->data_len -= (len-rlen);
2075 /* API 3.1.3 recvmsg() - UDP Style Syntax
2080 * socket - the socket descriptor of the endpoint.
2081 * message - pointer to the msghdr structure which contains a single
2087 * flags - flags sent or received with the user message, see Section
2094 struct sctp_sock *sp = sctp_sk(sk);
2107 skb_queue_empty_lockless(&sk->sk_receive_queue))
2114 err = -ENOTCONN;
2125 skb_len = skb->len;
2138 if (event->chunk && event->chunk->head_skb)
2139 head_skb = event->chunk->head_skb;
2144 msg->msg_flags |= MSG_NOTIFICATION;
2145 sp->pf->event_msgname(event, msg->msg_name, addr_len);
2147 sp->pf->skb_msgname(head_skb, msg->msg_name, addr_len);
2151 if (sp->recvnxtinfo)
2154 if (sp->recvrcvinfo)
2157 if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_DATA_IO_EVENT))
2167 msg->msg_flags &= ~MSG_EOR;
2171 skb_queue_head(&sk->sk_receive_queue, skb);
2178 sctp_assoc_rwnd_increase(event->asoc, copied);
2180 } else if ((event->msg_flags & MSG_NOTIFICATION) ||
2181 (event->msg_flags & MSG_EOR))
2182 msg->msg_flags |= MSG_EOR;
2184 msg->msg_flags &= ~MSG_EOR;
2215 return -EINVAL;
2216 sctp_sk(sk)->disable_fragments = (*val == 0) ? 0 : 1;
2223 struct sctp_sock *sp = sctp_sk(sk);
2228 return -EINVAL;
2231 sctp_ulpevent_type_set(&sp->subscribe, SCTP_SN_TYPE_BASE + i,
2234 list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2235 asoc->subscribe = sctp_sk(sk)->subscribe;
2241 if (sctp_ulpevent_type_enabled(sp->subscribe, SCTP_SENDER_DRY_EVENT)) {
2245 if (asoc && sctp_outq_is_empty(&asoc->outqueue)) {
2249 return -ENOMEM;
2251 asoc->stream.si->enqueue_event(&asoc->ulpq, event);
2260 * This socket option is applicable to the UDP-style socket only. When
2272 struct sctp_sock *sp = sctp_sk(sk);
2275 /* Applicable to UDP-style socket only */
2277 return -EOPNOTSUPP;
2279 return -EINVAL;
2281 sp->autoclose = *optval;
2282 if (sp->autoclose > net->sctp.max_autoclose)
2283 sp->autoclose = net->sctp.max_autoclose;
2309 * spp_assoc_id - (one-to-many style socket) This is filled in the
2312 * spp_address - This specifies which address is of interest.
2313 * spp_hbinterval - This contains the value of the heartbeat interval,
2317 * spp_pathmaxrxt - This contains the maximum number of
2322 * spp_pathmtu - When Path MTU discovery is disabled the value
2328 * spp_sackdelay - When delayed sack is enabled, this value specifies
2336 * spp_flags - These flags are used to control various features
2340 * SPP_HB_ENABLE - Enable heartbeats on the
2345 * SPP_HB_DISABLE - Disable heartbeats on the
2354 * SPP_HB_DEMAND - Request a user initiated heartbeat
2357 * SPP_HB_TIME_IS_ZERO - Specify's that the time for
2361 * SPP_PMTUD_ENABLE - This field will enable PMTU
2366 * SPP_PMTUD_DISABLE - This field will disable PMTU
2374 * SPP_SACKDELAY_ENABLE - Setting this flag turns
2380 * SPP_SACKDELAY_DISABLE - Setting this flag turns
2398 * returned. For non-IPv6 sockets, this flag will be left
2415 * - This field is used in conjunction with the
2418 * label. This setting has precedence over any IPv6-layer
2421 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
2424 * IPv4- or IPv6- layer setting.
2429 struct sctp_sock *sp,
2436 if (params->spp_flags & SPP_HB_DEMAND && trans) {
2437 error = sctp_primitive_REQUESTHEARTBEAT(trans->asoc->base.net,
2438 trans->asoc, trans);
2447 if (params->spp_flags & SPP_HB_ENABLE) {
2449 /* Re-zero the interval if the SPP_HB_TIME_IS_ZERO is
2453 if (params->spp_flags & SPP_HB_TIME_IS_ZERO)
2454 params->spp_hbinterval = 0;
2456 if (params->spp_hbinterval ||
2457 (params->spp_flags & SPP_HB_TIME_IS_ZERO)) {
2459 trans->hbinterval =
2460 msecs_to_jiffies(params->spp_hbinterval);
2463 asoc->hbinterval =
2464 msecs_to_jiffies(params->spp_hbinterval);
2466 sp->hbinterval = params->spp_hbinterval;
2473 trans->param_flags =
2474 (trans->param_flags & ~SPP_HB) | hb_change;
2476 asoc->param_flags =
2477 (asoc->param_flags & ~SPP_HB) | hb_change;
2479 sp->param_flags =
2480 (sp->param_flags & ~SPP_HB) | hb_change;
2489 if ((params->spp_flags & SPP_PMTUD_DISABLE) && params->spp_pathmtu) {
2491 trans->pathmtu = params->spp_pathmtu;
2494 sctp_assoc_set_pmtu(asoc, params->spp_pathmtu);
2496 sp->pathmtu = params->spp_pathmtu;
2502 int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2503 (params->spp_flags & SPP_PMTUD_ENABLE);
2504 trans->param_flags =
2505 (trans->param_flags & ~SPP_PMTUD) | pmtud_change;
2507 sctp_transport_pmtu(trans, sctp_opt2sk(sp));
2512 asoc->param_flags =
2513 (asoc->param_flags & ~SPP_PMTUD) | pmtud_change;
2515 sp->param_flags =
2516 (sp->param_flags & ~SPP_PMTUD) | pmtud_change;
2524 if ((params->spp_flags & SPP_SACKDELAY_ENABLE) && params->spp_sackdelay) {
2526 trans->sackdelay =
2527 msecs_to_jiffies(params->spp_sackdelay);
2529 asoc->sackdelay =
2530 msecs_to_jiffies(params->spp_sackdelay);
2532 sp->sackdelay = params->spp_sackdelay;
2538 trans->param_flags =
2539 (trans->param_flags & ~SPP_SACKDELAY) |
2542 asoc->param_flags =
2543 (asoc->param_flags & ~SPP_SACKDELAY) |
2546 sp->param_flags =
2547 (sp->param_flags & ~SPP_SACKDELAY) |
2555 if (params->spp_pathmaxrxt) {
2557 trans->pathmaxrxt = params->spp_pathmaxrxt;
2559 asoc->pathmaxrxt = params->spp_pathmaxrxt;
2561 sp->pathmaxrxt = params->spp_pathmaxrxt;
2565 if (params->spp_flags & SPP_IPV6_FLOWLABEL) {
2567 if (trans->ipaddr.sa.sa_family == AF_INET6) {
2568 trans->flowlabel = params->spp_ipv6_flowlabel &
2570 trans->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2575 list_for_each_entry(t, &asoc->peer.transport_addr_list,
2577 if (t->ipaddr.sa.sa_family != AF_INET6)
2579 t->flowlabel = params->spp_ipv6_flowlabel &
2581 t->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2583 asoc->flowlabel = params->spp_ipv6_flowlabel &
2585 asoc->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2586 } else if (sctp_opt2sk(sp)->sk_family == AF_INET6) {
2587 sp->flowlabel = params->spp_ipv6_flowlabel &
2589 sp->flowlabel |= SCTP_FLOWLABEL_SET_MASK;
2593 if (params->spp_flags & SPP_DSCP) {
2595 trans->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2596 trans->dscp |= SCTP_DSCP_SET_MASK;
2600 list_for_each_entry(t, &asoc->peer.transport_addr_list,
2602 t->dscp = params->spp_dscp &
2604 t->dscp |= SCTP_DSCP_SET_MASK;
2606 asoc->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2607 asoc->dscp |= SCTP_DSCP_SET_MASK;
2609 sp->dscp = params->spp_dscp & SCTP_DSCP_VAL_MASK;
2610 sp->dscp |= SCTP_DSCP_SET_MASK;
2623 struct sctp_sock *sp = sctp_sk(sk);
2629 if (params->spp_flags & (SPP_DSCP | SPP_IPV6_FLOWLABEL))
2630 return -EINVAL;
2632 return -EINVAL;
2636 hb_change = params->spp_flags & SPP_HB;
2637 pmtud_change = params->spp_flags & SPP_PMTUD;
2638 sackdelay_change = params->spp_flags & SPP_SACKDELAY;
2643 params->spp_sackdelay > 500 ||
2644 (params->spp_pathmtu &&
2645 params->spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2646 return -EINVAL;
2651 if (!sctp_is_any(sk, (union sctp_addr *)¶ms->spp_address)) {
2652 trans = sctp_addr_id2transport(sk, ¶ms->spp_address,
2653 params->spp_assoc_id);
2655 return -EINVAL;
2662 asoc = sctp_id2assoc(sk, params->spp_assoc_id);
2663 if (!asoc && params->spp_assoc_id != SCTP_FUTURE_ASSOC &&
2665 return -EINVAL;
2670 if (params->spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2671 return -EINVAL;
2674 error = sctp_apply_peer_addr_params(params, trans, asoc, sp,
2685 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2687 sctp_apply_peer_addr_params(params, trans, asoc, sp,
2711 if (params->sack_delay) {
2712 asoc->sackdelay = msecs_to_jiffies(params->sack_delay);
2713 asoc->param_flags =
2714 sctp_spp_sackdelay_enable(asoc->param_flags);
2716 if (params->sack_freq == 1) {
2717 asoc->param_flags =
2718 sctp_spp_sackdelay_disable(asoc->param_flags);
2719 } else if (params->sack_freq > 1) {
2720 asoc->sackfreq = params->sack_freq;
2721 asoc->param_flags =
2722 sctp_spp_sackdelay_enable(asoc->param_flags);
2725 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
2727 if (params->sack_delay) {
2728 trans->sackdelay = msecs_to_jiffies(params->sack_delay);
2729 trans->param_flags =
2730 sctp_spp_sackdelay_enable(trans->param_flags);
2732 if (params->sack_freq == 1) {
2733 trans->param_flags =
2734 sctp_spp_sackdelay_disable(trans->param_flags);
2735 } else if (params->sack_freq > 1) {
2736 trans->sackfreq = params->sack_freq;
2737 trans->param_flags =
2738 sctp_spp_sackdelay_enable(trans->param_flags);
2751 * values. If the assoc_id field is non-zero, then the set or get
2763 * sack_assoc_id - This parameter, indicates which association the user
2768 * sack_delay - This parameter contains the number of milliseconds that
2773 * sack_freq - This parameter contains the number of packets that must
2781 struct sctp_sock *sp = sctp_sk(sk);
2785 if (params->sack_delay > 500)
2786 return -EINVAL;
2792 asoc = sctp_id2assoc(sk, params->sack_assoc_id);
2793 if (!asoc && params->sack_assoc_id > SCTP_ALL_ASSOC &&
2795 return -EINVAL;
2804 params->sack_assoc_id = SCTP_FUTURE_ASSOC;
2806 if (params->sack_assoc_id == SCTP_FUTURE_ASSOC ||
2807 params->sack_assoc_id == SCTP_ALL_ASSOC) {
2808 if (params->sack_delay) {
2809 sp->sackdelay = params->sack_delay;
2810 sp->param_flags =
2811 sctp_spp_sackdelay_enable(sp->param_flags);
2813 if (params->sack_freq == 1) {
2814 sp->param_flags =
2815 sctp_spp_sackdelay_disable(sp->param_flags);
2816 } else if (params->sack_freq > 1) {
2817 sp->sackfreq = params->sack_freq;
2818 sp->param_flags =
2819 sctp_spp_sackdelay_enable(sp->param_flags);
2823 if (params->sack_assoc_id == SCTP_CURRENT_ASSOC ||
2824 params->sack_assoc_id == SCTP_ALL_ASSOC)
2825 list_for_each_entry(asoc, &sp->ep->asocs, asocs)
2843 current->comm, task_pid_nr(current));
2845 p.sack_assoc_id = v->assoc_id;
2846 p.sack_delay = v->assoc_value;
2847 p.sack_freq = v->assoc_value ? 0 : 1;
2852 return -EINVAL;
2853 if (params->sack_delay == 0 && params->sack_freq == 0)
2865 * socket (for UDP-style sockets only future associations are effected
2866 * by the change). With TCP-style sockets, this option is inherited by
2872 struct sctp_sock *sp = sctp_sk(sk);
2875 return -EINVAL;
2877 if (sinit->sinit_num_ostreams)
2878 sp->initmsg.sinit_num_ostreams = sinit->sinit_num_ostreams;
2879 if (sinit->sinit_max_instreams)
2880 sp->initmsg.sinit_max_instreams = sinit->sinit_max_instreams;
2881 if (sinit->sinit_max_attempts)
2882 sp->initmsg.sinit_max_attempts = sinit->sinit_max_attempts;
2883 if (sinit->sinit_max_init_timeo)
2884 sp->initmsg.sinit_max_init_timeo = sinit->sinit_max_init_timeo;
2907 struct sctp_sock *sp = sctp_sk(sk);
2911 return -EINVAL;
2912 if (info->sinfo_flags &
2915 return -EINVAL;
2917 asoc = sctp_id2assoc(sk, info->sinfo_assoc_id);
2918 if (!asoc && info->sinfo_assoc_id > SCTP_ALL_ASSOC &&
2920 return -EINVAL;
2923 asoc->default_stream = info->sinfo_stream;
2924 asoc->default_flags = info->sinfo_flags;
2925 asoc->default_ppid = info->sinfo_ppid;
2926 asoc->default_context = info->sinfo_context;
2927 asoc->default_timetolive = info->sinfo_timetolive;
2933 info->sinfo_assoc_id = SCTP_FUTURE_ASSOC;
2935 if (info->sinfo_assoc_id == SCTP_FUTURE_ASSOC ||
2936 info->sinfo_assoc_id == SCTP_ALL_ASSOC) {
2937 sp->default_stream = info->sinfo_stream;
2938 sp->default_flags = info->sinfo_flags;
2939 sp->default_ppid = info->sinfo_ppid;
2940 sp->default_context = info->sinfo_context;
2941 sp->default_timetolive = info->sinfo_timetolive;
2944 if (info->sinfo_assoc_id == SCTP_CURRENT_ASSOC ||
2945 info->sinfo_assoc_id == SCTP_ALL_ASSOC) {
2946 list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
2947 asoc->default_stream = info->sinfo_stream;
2948 asoc->default_flags = info->sinfo_flags;
2949 asoc->default_ppid = info->sinfo_ppid;
2950 asoc->default_context = info->sinfo_context;
2951 asoc->default_timetolive = info->sinfo_timetolive;
2965 struct sctp_sock *sp = sctp_sk(sk);
2969 return -EINVAL;
2970 if (info->snd_flags &
2973 return -EINVAL;
2975 asoc = sctp_id2assoc(sk, info->snd_assoc_id);
2976 if (!asoc && info->snd_assoc_id > SCTP_ALL_ASSOC &&
2978 return -EINVAL;
2981 asoc->default_stream = info->snd_sid;
2982 asoc->default_flags = info->snd_flags;
2983 asoc->default_ppid = info->snd_ppid;
2984 asoc->default_context = info->snd_context;
2990 info->snd_assoc_id = SCTP_FUTURE_ASSOC;
2992 if (info->snd_assoc_id == SCTP_FUTURE_ASSOC ||
2993 info->snd_assoc_id == SCTP_ALL_ASSOC) {
2994 sp->default_stream = info->snd_sid;
2995 sp->default_flags = info->snd_flags;
2996 sp->default_ppid = info->snd_ppid;
2997 sp->default_context = info->snd_context;
3000 if (info->snd_assoc_id == SCTP_CURRENT_ASSOC ||
3001 info->snd_assoc_id == SCTP_ALL_ASSOC) {
3002 list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
3003 asoc->default_stream = info->snd_sid;
3004 asoc->default_flags = info->snd_flags;
3005 asoc->default_ppid = info->snd_ppid;
3006 asoc->default_context = info->snd_context;
3027 return -EINVAL;
3030 af = sctp_get_af_specific(prim->ssp_addr.ss_family);
3032 return -EINVAL;
3035 (struct sockaddr *)&prim->ssp_addr,
3036 af->sockaddr_len);
3040 trans = sctp_addr_id2transport(sk, &prim->ssp_addr, prim->ssp_assoc_id);
3042 return -EINVAL;
3044 sctp_assoc_set_primary(trans->asoc, trans);
3052 * Turn on/off any Nagle-like algorithm. This means that packets are
3061 return -EINVAL;
3062 sctp_sk(sk)->nodelay = (*val == 0) ? 0 : 1;
3084 struct sctp_sock *sp = sctp_sk(sk);
3087 return -EINVAL;
3089 asoc = sctp_id2assoc(sk, rtoinfo->srto_assoc_id);
3092 if (!asoc && rtoinfo->srto_assoc_id != SCTP_FUTURE_ASSOC &&
3094 return -EINVAL;
3096 rto_max = rtoinfo->srto_max;
3097 rto_min = rtoinfo->srto_min;
3102 rto_max = asoc ? asoc->rto_max : sp->rtoinfo.srto_max;
3107 rto_min = asoc ? asoc->rto_min : sp->rtoinfo.srto_min;
3110 return -EINVAL;
3113 if (rtoinfo->srto_initial != 0)
3114 asoc->rto_initial =
3115 msecs_to_jiffies(rtoinfo->srto_initial);
3116 asoc->rto_max = rto_max;
3117 asoc->rto_min = rto_min;
3119 /* If there is no association or the association-id = 0
3122 if (rtoinfo->srto_initial != 0)
3123 sp->rtoinfo.srto_initial = rtoinfo->srto_initial;
3124 sp->rtoinfo.srto_max = rto_max;
3125 sp->rtoinfo.srto_min = rto_min;
3150 return -EINVAL;
3152 asoc = sctp_id2assoc(sk, assocparams->sasoc_assoc_id);
3154 if (!asoc && assocparams->sasoc_assoc_id != SCTP_FUTURE_ASSOC &&
3156 return -EINVAL;
3160 if (assocparams->sasoc_asocmaxrxt != 0) {
3165 list_for_each_entry(peer_addr, &asoc->peer.transport_addr_list,
3167 path_sum += peer_addr->pathmaxrxt;
3177 assocparams->sasoc_asocmaxrxt > path_sum)
3178 return -EINVAL;
3180 asoc->max_retrans = assocparams->sasoc_asocmaxrxt;
3183 if (assocparams->sasoc_cookie_life != 0)
3184 asoc->cookie_life =
3185 ms_to_ktime(assocparams->sasoc_cookie_life);
3188 struct sctp_sock *sp = sctp_sk(sk);
3190 if (assocparams->sasoc_asocmaxrxt != 0)
3191 sp->assocparams.sasoc_asocmaxrxt =
3192 assocparams->sasoc_asocmaxrxt;
3193 if (assocparams->sasoc_cookie_life != 0)
3194 sp->assocparams.sasoc_cookie_life =
3195 assocparams->sasoc_cookie_life;
3213 struct sctp_sock *sp = sctp_sk(sk);
3216 return -EINVAL;
3218 sp->v4mapped = 1;
3220 sp->v4mapped = 0;
3245 * assoc_id: This parameter is ignored for one-to-one style sockets.
3246 * For one-to-many style sockets this parameter indicates which
3256 struct sctp_sock *sp = sctp_sk(sk);
3266 current->comm, task_pid_nr(current));
3270 assoc_id = params->assoc_id;
3271 val = params->assoc_value;
3273 return -EINVAL;
3279 return -EINVAL;
3283 __u16 datasize = asoc ? sctp_datachk_len(&asoc->stream) :
3286 min_len = sctp_min_frag_point(sp, datasize);
3287 max_len = SCTP_MAX_CHUNK_LEN - datasize;
3290 return -EINVAL;
3294 asoc->user_frag = val;
3297 sp->user_frag = val;
3316 struct sctp_sock *sp;
3322 sp = sctp_sk(sk);
3324 if (!sp->ep->asconf_enable)
3325 return -EPERM;
3328 return -EINVAL;
3330 asoc = sctp_id2assoc(sk, prim->sspp_assoc_id);
3332 return -EINVAL;
3334 if (!asoc->peer.asconf_capable)
3335 return -EPERM;
3337 if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
3338 return -EPERM;
3341 return -ENOTCONN;
3343 af = sctp_get_af_specific(prim->sspp_addr.ss_family);
3345 return -EINVAL;
3347 if (!af->addr_valid((union sctp_addr *)&prim->sspp_addr, sp, NULL))
3348 return -EADDRNOTAVAIL;
3350 if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim->sspp_addr))
3351 return -EADDRNOTAVAIL;
3355 (struct sockaddr *)&prim->sspp_addr,
3356 af->sockaddr_len);
3362 (union sctp_addr *)&prim->sspp_addr);
3364 return -ENOMEM;
3378 return -EINVAL;
3380 sctp_sk(sk)->adaptation_ind = adapt->ssb_adaptation_ind;
3393 * one-2-many model for an application to keep some reference to an
3403 struct sctp_sock *sp = sctp_sk(sk);
3407 return -EINVAL;
3409 asoc = sctp_id2assoc(sk, params->assoc_id);
3410 if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
3412 return -EINVAL;
3415 asoc->default_rcv_context = params->assoc_value;
3421 params->assoc_id = SCTP_FUTURE_ASSOC;
3423 if (params->assoc_id == SCTP_FUTURE_ASSOC ||
3424 params->assoc_id == SCTP_ALL_ASSOC)
3425 sp->default_rcv_context = params->assoc_value;
3427 if (params->assoc_id == SCTP_CURRENT_ASSOC ||
3428 params->assoc_id == SCTP_ALL_ASSOC)
3429 list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3430 asoc->default_rcv_context = params->assoc_value;
3450 * This option takes a boolean value. A non-zero value indicates that
3463 return -EINVAL;
3465 sctp_sk(sk)->frag_interleave = !!*val;
3467 if (!sctp_sk(sk)->frag_interleave)
3468 sctp_sk(sk)->ep->intl_enable = 0;
3494 return -EINVAL;
3499 if (*val > (sk->sk_rcvbuf >> 1))
3500 return -EINVAL;
3502 sctp_sk(sk)->pd_point = *val;
3522 struct sctp_sock *sp = sctp_sk(sk);
3532 current->comm, task_pid_nr(current));
3536 assoc_id = params->assoc_id;
3537 assoc_value = params->assoc_value;
3539 return -EINVAL;
3543 return -EINVAL;
3546 asoc->max_burst = assoc_value;
3555 sp->max_burst = assoc_value;
3558 list_for_each_entry(asoc, &sp->ep->asocs, asocs)
3559 asoc->max_burst = assoc_value;
3575 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3577 if (!ep->auth_enable)
3578 return -EACCES;
3581 return -EINVAL;
3583 switch (val->sauth_chunk) {
3588 return -EINVAL;
3592 return sctp_auth_ep_add_chunkid(ep, val->sauth_chunk);
3605 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3608 if (!ep->auth_enable)
3609 return -EACCES;
3612 return -EINVAL;
3616 idents = hmacs->shmac_num_idents;
3618 (idents * sizeof(u16)) > (optlen - sizeof(struct sctp_hmacalgo)))
3619 return -EINVAL;
3634 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3636 int ret = -EINVAL;
3639 return -EINVAL;
3640 /* authkey->sca_keylength is u16, so optlen can't be bigger than
3645 if (authkey->sca_keylength > optlen - sizeof(*authkey))
3648 asoc = sctp_id2assoc(sk, authkey->sca_assoc_id);
3649 if (!asoc && authkey->sca_assoc_id > SCTP_ALL_ASSOC &&
3659 authkey->sca_assoc_id = SCTP_FUTURE_ASSOC;
3661 if (authkey->sca_assoc_id == SCTP_FUTURE_ASSOC ||
3662 authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3670 if (authkey->sca_assoc_id == SCTP_CURRENT_ASSOC ||
3671 authkey->sca_assoc_id == SCTP_ALL_ASSOC) {
3672 list_for_each_entry(asoc, &ep->asocs, asocs) {
3695 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3700 return -EINVAL;
3702 asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3703 if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3705 return -EINVAL;
3708 return sctp_auth_set_active_key(ep, asoc, val->scact_keynumber);
3711 val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3713 if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3714 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3715 ret = sctp_auth_set_active_key(ep, asoc, val->scact_keynumber);
3720 if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3721 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3722 list_for_each_entry(asoc, &ep->asocs, asocs) {
3724 val->scact_keynumber);
3743 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3748 return -EINVAL;
3750 asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3751 if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3753 return -EINVAL;
3756 return sctp_auth_del_key_id(ep, asoc, val->scact_keynumber);
3759 val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3761 if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3762 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3763 ret = sctp_auth_del_key_id(ep, asoc, val->scact_keynumber);
3768 if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3769 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3770 list_for_each_entry(asoc, &ep->asocs, asocs) {
3772 val->scact_keynumber);
3791 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
3796 return -EINVAL;
3798 asoc = sctp_id2assoc(sk, val->scact_assoc_id);
3799 if (!asoc && val->scact_assoc_id > SCTP_ALL_ASSOC &&
3801 return -EINVAL;
3804 return sctp_auth_deact_key_id(ep, asoc, val->scact_keynumber);
3807 val->scact_assoc_id = SCTP_FUTURE_ASSOC;
3809 if (val->scact_assoc_id == SCTP_FUTURE_ASSOC ||
3810 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3811 ret = sctp_auth_deact_key_id(ep, asoc, val->scact_keynumber);
3816 if (val->scact_assoc_id == SCTP_CURRENT_ASSOC ||
3817 val->scact_assoc_id == SCTP_ALL_ASSOC) {
3818 list_for_each_entry(asoc, &ep->asocs, asocs) {
3820 val->scact_keynumber);
3839 * This option expects an integer boolean flag, where a non-zero value turns on
3847 struct sctp_sock *sp = sctp_sk(sk);
3850 return -EINVAL;
3852 return -EINVAL;
3853 if ((*val && sp->do_auto_asconf) || (!*val && !sp->do_auto_asconf))
3856 spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3857 if (*val == 0 && sp->do_auto_asconf) {
3858 list_del(&sp->auto_asconf_list);
3859 sp->do_auto_asconf = 0;
3860 } else if (*val && !sp->do_auto_asconf) {
3861 list_add_tail(&sp->auto_asconf_list,
3862 &sock_net(sk)->sctp.auto_asconf_splist);
3863 sp->do_auto_asconf = 1;
3865 spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock);
3874 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
3886 return -EINVAL;
3888 if (v2 && val->spt_pathpfthld > val->spt_pathcpthld)
3889 return -EINVAL;
3891 if (!sctp_is_any(sk, (const union sctp_addr *)&val->spt_address)) {
3892 trans = sctp_addr_id2transport(sk, &val->spt_address,
3893 val->spt_assoc_id);
3895 return -ENOENT;
3897 if (val->spt_pathmaxrxt)
3898 trans->pathmaxrxt = val->spt_pathmaxrxt;
3900 trans->ps_retrans = val->spt_pathcpthld;
3901 trans->pf_retrans = val->spt_pathpfthld;
3906 asoc = sctp_id2assoc(sk, val->spt_assoc_id);
3907 if (!asoc && val->spt_assoc_id != SCTP_FUTURE_ASSOC &&
3909 return -EINVAL;
3912 list_for_each_entry(trans, &asoc->peer.transport_addr_list,
3914 if (val->spt_pathmaxrxt)
3915 trans->pathmaxrxt = val->spt_pathmaxrxt;
3917 trans->ps_retrans = val->spt_pathcpthld;
3918 trans->pf_retrans = val->spt_pathpfthld;
3921 if (val->spt_pathmaxrxt)
3922 asoc->pathmaxrxt = val->spt_pathmaxrxt;
3924 asoc->ps_retrans = val->spt_pathcpthld;
3925 asoc->pf_retrans = val->spt_pathpfthld;
3927 struct sctp_sock *sp = sctp_sk(sk);
3929 if (val->spt_pathmaxrxt)
3930 sp->pathmaxrxt = val->spt_pathmaxrxt;
3932 sp->ps_retrans = val->spt_pathcpthld;
3933 sp->pf_retrans = val->spt_pathpfthld;
3943 return -EINVAL;
3945 sctp_sk(sk)->recvrcvinfo = (*val == 0) ? 0 : 1;
3954 return -EINVAL;
3956 sctp_sk(sk)->recvnxtinfo = (*val == 0) ? 0 : 1;
3968 return -EINVAL;
3970 asoc = sctp_id2assoc(sk, params->assoc_id);
3971 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
3973 return -EINVAL;
3975 sctp_sk(sk)->ep->prsctp_enable = !!params->assoc_value;
3984 struct sctp_sock *sp = sctp_sk(sk);
3986 int retval = -EINVAL;
3991 if (info->pr_policy & ~SCTP_PR_SCTP_MASK)
3994 if (info->pr_policy == SCTP_PR_SCTP_NONE)
3995 info->pr_value = 0;
3997 asoc = sctp_id2assoc(sk, info->pr_assoc_id);
3998 if (!asoc && info->pr_assoc_id > SCTP_ALL_ASSOC &&
4005 SCTP_PR_SET_POLICY(asoc->default_flags, info->pr_policy);
4006 asoc->default_timetolive = info->pr_value;
4011 info->pr_assoc_id = SCTP_FUTURE_ASSOC;
4013 if (info->pr_assoc_id == SCTP_FUTURE_ASSOC ||
4014 info->pr_assoc_id == SCTP_ALL_ASSOC) {
4015 SCTP_PR_SET_POLICY(sp->default_flags, info->pr_policy);
4016 sp->default_timetolive = info->pr_value;
4019 if (info->pr_assoc_id == SCTP_CURRENT_ASSOC ||
4020 info->pr_assoc_id == SCTP_ALL_ASSOC) {
4021 list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4022 SCTP_PR_SET_POLICY(asoc->default_flags,
4023 info->pr_policy);
4024 asoc->default_timetolive = info->pr_value;
4037 int retval = -EINVAL;
4042 asoc = sctp_id2assoc(sk, params->assoc_id);
4043 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4047 sctp_sk(sk)->ep->reconf_enable = !!params->assoc_value;
4059 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
4061 int retval = -EINVAL;
4066 if (params->assoc_value & (~SCTP_ENABLE_STRRESET_MASK))
4069 asoc = sctp_id2assoc(sk, params->assoc_id);
4070 if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
4077 asoc->strreset_enable = params->assoc_value;
4082 params->assoc_id = SCTP_FUTURE_ASSOC;
4084 if (params->assoc_id == SCTP_FUTURE_ASSOC ||
4085 params->assoc_id == SCTP_ALL_ASSOC)
4086 ep->strreset_enable = params->assoc_value;
4088 if (params->assoc_id == SCTP_CURRENT_ASSOC ||
4089 params->assoc_id == SCTP_ALL_ASSOC)
4090 list_for_each_entry(asoc, &ep->asocs, asocs)
4091 asoc->strreset_enable = params->assoc_value;
4104 return -EINVAL;
4109 if (params->srs_number_streams * sizeof(__u16) >
4110 optlen - sizeof(*params))
4111 return -EINVAL;
4113 asoc = sctp_id2assoc(sk, params->srs_assoc_id);
4115 return -EINVAL;
4126 return -EINVAL;
4130 return -EINVAL;
4142 return -EINVAL;
4144 asoc = sctp_id2assoc(sk, params->sas_assoc_id);
4146 return -EINVAL;
4155 struct sctp_sock *sp = sctp_sk(sk);
4160 return -EINVAL;
4162 if (params->assoc_value > SCTP_SS_MAX)
4163 return -EINVAL;
4165 asoc = sctp_id2assoc(sk, params->assoc_id);
4166 if (!asoc && params->assoc_id > SCTP_ALL_ASSOC &&
4168 return -EINVAL;
4171 return sctp_sched_set_sched(asoc, params->assoc_value);
4174 params->assoc_id = SCTP_FUTURE_ASSOC;
4176 if (params->assoc_id == SCTP_FUTURE_ASSOC ||
4177 params->assoc_id == SCTP_ALL_ASSOC)
4178 sp->default_ss = params->assoc_value;
4180 if (params->assoc_id == SCTP_CURRENT_ASSOC ||
4181 params->assoc_id == SCTP_ALL_ASSOC) {
4182 list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4184 params->assoc_value);
4199 int retval = -EINVAL;
4204 asoc = sctp_id2assoc(sk, params->assoc_id);
4205 if (!asoc && params->assoc_id != SCTP_CURRENT_ASSOC &&
4210 retval = sctp_sched_set_value(asoc, params->stream_id,
4211 params->stream_value, GFP_KERNEL);
4217 list_for_each_entry(asoc, &sctp_sk(sk)->ep->asocs, asocs) {
4218 int ret = sctp_sched_set_value(asoc, params->stream_id,
4219 params->stream_value,
4233 struct sctp_sock *sp = sctp_sk(sk);
4237 return -EINVAL;
4239 asoc = sctp_id2assoc(sk, p->assoc_id);
4240 if (!asoc && p->assoc_id != SCTP_FUTURE_ASSOC && sctp_style(sk, UDP))
4241 return -EINVAL;
4243 if (!sock_net(sk)->sctp.intl_enable || !sp->frag_interleave) {
4244 return -EPERM;
4247 sp->ep->intl_enable = !!p->assoc_value;
4255 return -EOPNOTSUPP;
4257 if (sctp_sk(sk)->ep->base.bind_addr.port)
4258 return -EFAULT;
4261 return -EINVAL;
4263 sctp_sk(sk)->reuse = !!*val;
4273 sctp_ulpevent_type_set(&asoc->subscribe, param->se_type, param->se_on);
4275 if (param->se_type == SCTP_SENDER_DRY_EVENT && param->se_on) {
4276 if (sctp_outq_is_empty(&asoc->outqueue)) {
4280 return -ENOMEM;
4282 asoc->stream.si->enqueue_event(&asoc->ulpq, event);
4292 struct sctp_sock *sp = sctp_sk(sk);
4297 return -EINVAL;
4299 if (param->se_type < SCTP_SN_TYPE_BASE ||
4300 param->se_type > SCTP_SN_TYPE_MAX)
4301 return -EINVAL;
4303 asoc = sctp_id2assoc(sk, param->se_assoc_id);
4304 if (!asoc && param->se_assoc_id > SCTP_ALL_ASSOC &&
4306 return -EINVAL;
4312 param->se_assoc_id = SCTP_FUTURE_ASSOC;
4314 if (param->se_assoc_id == SCTP_FUTURE_ASSOC ||
4315 param->se_assoc_id == SCTP_ALL_ASSOC)
4316 sctp_ulpevent_type_set(&sp->subscribe,
4317 param->se_type, param->se_on);
4319 if (param->se_assoc_id == SCTP_CURRENT_ASSOC ||
4320 param->se_assoc_id == SCTP_ALL_ASSOC) {
4321 list_for_each_entry(asoc, &sp->ep->asocs, asocs) {
4338 int retval = -EINVAL;
4343 asoc = sctp_id2assoc(sk, params->assoc_id);
4344 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4348 ep = sctp_sk(sk)->ep;
4349 ep->asconf_enable = !!params->assoc_value;
4351 if (ep->asconf_enable && ep->auth_enable) {
4368 int retval = -EINVAL;
4373 asoc = sctp_id2assoc(sk, params->assoc_id);
4374 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4378 ep = sctp_sk(sk)->ep;
4379 if (params->assoc_value) {
4383 if (ep->asconf_enable) {
4389 ep->auth_enable = !!params->assoc_value;
4401 int retval = -EINVAL;
4406 asoc = sctp_id2assoc(sk, params->assoc_id);
4407 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4411 sctp_sk(sk)->ep->ecn_enable = !!params->assoc_value;
4423 int retval = -EINVAL;
4428 if (params->assoc_value > SCTP_PF_EXPOSE_MAX)
4431 asoc = sctp_id2assoc(sk, params->assoc_id);
4432 if (!asoc && params->assoc_id != SCTP_FUTURE_ASSOC &&
4437 asoc->pf_expose = params->assoc_value;
4439 sctp_sk(sk)->pf_expose = params->assoc_value;
4455 return -EINVAL;
4460 encap_port = (__force __be16)encap->sue_port;
4461 if (!sctp_is_any(sk, (union sctp_addr *)&encap->sue_address)) {
4462 t = sctp_addr_id2transport(sk, &encap->sue_address,
4463 encap->sue_assoc_id);
4465 return -EINVAL;
4467 t->encap_port = encap_port;
4475 asoc = sctp_id2assoc(sk, encap->sue_assoc_id);
4476 if (!asoc && encap->sue_assoc_id != SCTP_FUTURE_ASSOC &&
4478 return -EINVAL;
4484 list_for_each_entry(t, &asoc->peer.transport_addr_list,
4486 t->encap_port = encap_port;
4488 asoc->encap_port = encap_port;
4492 sctp_sk(sk)->encap_port = encap_port;
4505 return -EINVAL;
4507 probe_interval = params->spi_interval;
4509 return -EINVAL;
4514 if (!sctp_is_any(sk, (union sctp_addr *)¶ms->spi_address)) {
4515 t = sctp_addr_id2transport(sk, ¶ms->spi_address,
4516 params->spi_assoc_id);
4518 return -EINVAL;
4520 t->probe_interval = msecs_to_jiffies(probe_interval);
4529 asoc = sctp_id2assoc(sk, params->spi_assoc_id);
4530 if (!asoc && params->spi_assoc_id != SCTP_FUTURE_ASSOC &&
4532 return -EINVAL;
4538 list_for_each_entry(t, &asoc->peer.transport_addr_list, transports) {
4539 t->probe_interval = msecs_to_jiffies(probe_interval);
4543 asoc->probe_interval = msecs_to_jiffies(probe_interval);
4547 sctp_sk(sk)->probe_interval = probe_interval;
4564 * sd - the socket descript.
4565 * level - set to IPPROTO_SCTP for all SCTP options.
4566 * optname - the option name.
4567 * optval - the buffer to store the value of the option.
4568 * optlen - the size of the buffer.
4582 * are at all well-founded.
4585 struct sctp_af *af = sctp_sk(sk)->pf->af;
4587 return af->setsockopt(sk, level, optname, optval, optlen);
4781 retval = -ENOPROTOOPT;
4790 /* API 3.1.6 connect() - UDP Style Syntax
4810 int err = -EINVAL;
4817 af = sctp_get_af_specific(addr->sa_family);
4818 if (af && addr_len >= af->sockaddr_len)
4819 err = __sctp_connect(sk, addr, af->sockaddr_len, flags, NULL);
4828 if (addr_len < sizeof(uaddr->sa_family))
4829 return -EINVAL;
4831 if (uaddr->sa_family == AF_UNSPEC)
4832 return -EOPNOTSUPP;
4834 return sctp_connect(sock->sk, uaddr, addr_len, flags);
4841 return -EOPNOTSUPP;
4843 sk->sk_shutdown |= RCV_SHUTDOWN;
4847 /* 4.1.4 accept() - TCP Style Syntax
4856 struct sctp_sock *sp;
4865 sp = sctp_sk(sk);
4866 ep = sp->ep;
4869 error = -EOPNOTSUPP;
4874 (sk->sk_shutdown & RCV_SHUTDOWN)) {
4875 error = -EINVAL;
4879 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK);
4888 asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
4890 newsk = sp->pf->create_accept_sk(sk, asoc, arg->kern);
4892 error = -ENOMEM;
4907 arg->err = error;
4914 int rc = -ENOTCONN;
4919 * SEQPACKET-style sockets in LISTENING state are valid, for
4920 * SCTP, so only discard TCP-style sockets in LISTENING state.
4930 skb = skb_peek(&sk->sk_receive_queue);
4936 *karg = skb->len;
4942 rc = -ENOIOCTLCMD;
4951 * initialized the SCTP-specific portion of the sock.
4952 * The sock structure should already be zero-filled memory.
4957 struct sctp_sock *sp;
4961 sp = sctp_sk(sk);
4964 switch (sk->sk_type) {
4966 sp->type = SCTP_SOCKET_UDP;
4969 sp->type = SCTP_SOCKET_TCP;
4972 return -ESOCKTNOSUPPORT;
4975 sk->sk_gso_type = SKB_GSO_SCTP;
4980 sp->default_stream = 0;
4981 sp->default_ppid = 0;
4982 sp->default_flags = 0;
4983 sp->default_context = 0;
4984 sp->default_timetolive = 0;
4986 sp->default_rcv_context = 0;
4987 sp->max_burst = net->sctp.max_burst;
4989 sp->cookie_auth_enable = net->sctp.cookie_auth_enable;
4995 sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;
4996 sp->initmsg.sinit_max_instreams = sctp_max_instreams;
4997 sp->initmsg.sinit_max_attempts = net->sctp.max_retrans_init;
4998 sp->initmsg.sinit_max_init_timeo = net->sctp.rto_max;
5003 sp->rtoinfo.srto_initial = net->sctp.rto_initial;
5004 sp->rtoinfo.srto_max = net->sctp.rto_max;
5005 sp->rtoinfo.srto_min = net->sctp.rto_min;
5010 sp->assocparams.sasoc_asocmaxrxt = net->sctp.max_retrans_association;
5011 sp->assocparams.sasoc_number_peer_destinations = 0;
5012 sp->assocparams.sasoc_peer_rwnd = 0;
5013 sp->assocparams.sasoc_local_rwnd = 0;
5014 sp->assocparams.sasoc_cookie_life = net->sctp.valid_cookie_life;
5019 sp->subscribe = 0;
5024 sp->hbinterval = net->sctp.hb_interval;
5025 sp->udp_port = htons(net->sctp.udp_port);
5026 sp->encap_port = htons(net->sctp.encap_port);
5027 sp->pathmaxrxt = net->sctp.max_retrans_path;
5028 sp->pf_retrans = net->sctp.pf_retrans;
5029 sp->ps_retrans = net->sctp.ps_retrans;
5030 sp->pf_expose = net->sctp.pf_expose;
5031 sp->pathmtu = 0; /* allow default discovery */
5032 sp->sackdelay = net->sctp.sack_timeout;
5033 sp->sackfreq = 2;
5034 sp->param_flags = SPP_HB_ENABLE |
5037 sp->default_ss = SCTP_SS_DEFAULT;
5042 sp->disable_fragments = 0;
5045 sp->nodelay = 0;
5047 sp->recvrcvinfo = 0;
5048 sp->recvnxtinfo = 0;
5051 sp->v4mapped = 1;
5053 /* Auto-close idle associations after the configured
5056 * for UDP-style sockets only.
5058 sp->autoclose = 0;
5061 sp->user_frag = 0;
5063 sp->adaptation_ind = 0;
5065 sp->pf = sctp_get_pf_specific(sk->sk_family);
5068 atomic_set(&sp->pd_mode, 0);
5069 skb_queue_head_init(&sp->pd_lobby);
5070 sp->frag_interleave = 0;
5071 sp->probe_interval = net->sctp.probe_interval;
5075 * be useful for storing pre-connect address information.
5077 sp->ep = sctp_endpoint_new(sk, GFP_KERNEL);
5078 if (!sp->ep)
5079 return -ENOMEM;
5081 sk->sk_destruct = sctp_destruct_sock;
5086 sock_prot_inuse_add(net, sk->sk_prot, 1);
5092 * sock_net(sk)->sctp.addr_wq_lock held if sp->do_auto_asconf is true
5096 struct sctp_sock *sp;
5101 sp = sctp_sk(sk);
5105 if (sp->ep == NULL)
5108 if (sp->do_auto_asconf) {
5109 sp->do_auto_asconf = 0;
5110 list_del(&sp->auto_asconf_list);
5112 sctp_endpoint_free(sp->ep);
5114 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
5122 /* API 4.1.7 shutdown() - TCP Style Syntax
5125 * sd - the socket descriptor of the association to be closed.
5126 * how - Specifies the type of shutdown. The values are
5146 ep = sctp_sk(sk)->ep;
5147 if (how & SEND_SHUTDOWN && !list_empty(&ep->asocs)) {
5151 asoc = list_entry(ep->asocs.next,
5166 struct sctp_sock *sp = sctp_sk(sk);
5168 info->sctpi_s_autoclose = sp->autoclose;
5169 info->sctpi_s_adaptation_ind = sp->adaptation_ind;
5170 info->sctpi_s_pd_point = sp->pd_point;
5171 info->sctpi_s_nodelay = sp->nodelay;
5172 info->sctpi_s_disable_fragments = sp->disable_fragments;
5173 info->sctpi_s_v4mapped = sp->v4mapped;
5174 info->sctpi_s_frag_interleave = sp->frag_interleave;
5175 info->sctpi_s_type = sp->type;
5180 info->sctpi_tag = asoc->c.my_vtag;
5181 info->sctpi_state = asoc->state;
5182 info->sctpi_rwnd = asoc->a_rwnd;
5183 info->sctpi_unackdata = asoc->unack_data;
5184 info->sctpi_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5185 info->sctpi_instrms = asoc->stream.incnt;
5186 info->sctpi_outstrms = asoc->stream.outcnt;
5187 list_for_each(pos, &asoc->base.inqueue.in_chunk_list)
5188 info->sctpi_inqueue++;
5189 list_for_each(pos, &asoc->outqueue.out_chunk_list)
5190 info->sctpi_outqueue++;
5191 info->sctpi_overall_error = asoc->overall_error_count;
5192 info->sctpi_max_burst = asoc->max_burst;
5193 info->sctpi_maxseg = asoc->frag_point;
5194 info->sctpi_peer_rwnd = asoc->peer.rwnd;
5195 info->sctpi_peer_tag = asoc->c.peer_vtag;
5197 mask = asoc->peer.intl_capable << 1;
5198 mask = (mask | asoc->peer.ecn_capable) << 1;
5199 mask = (mask | asoc->peer.ipv4_address) << 1;
5200 mask = (mask | asoc->peer.ipv6_address) << 1;
5201 mask = (mask | asoc->peer.reconf_capable) << 1;
5202 mask = (mask | asoc->peer.asconf_capable) << 1;
5203 mask = (mask | asoc->peer.prsctp_capable) << 1;
5204 mask = (mask | asoc->peer.auth_capable);
5205 info->sctpi_peer_capable = mask;
5206 mask = asoc->peer.sack_needed << 1;
5207 mask = (mask | asoc->peer.sack_generation) << 1;
5208 mask = (mask | asoc->peer.zero_window_announced);
5209 info->sctpi_peer_sack = mask;
5211 info->sctpi_isacks = asoc->stats.isacks;
5212 info->sctpi_osacks = asoc->stats.osacks;
5213 info->sctpi_opackets = asoc->stats.opackets;
5214 info->sctpi_ipackets = asoc->stats.ipackets;
5215 info->sctpi_rtxchunks = asoc->stats.rtxchunks;
5216 info->sctpi_outofseqtsns = asoc->stats.outofseqtsns;
5217 info->sctpi_idupchunks = asoc->stats.idupchunks;
5218 info->sctpi_gapcnt = asoc->stats.gapcnt;
5219 info->sctpi_ouodchunks = asoc->stats.ouodchunks;
5220 info->sctpi_iuodchunks = asoc->stats.iuodchunks;
5221 info->sctpi_oodchunks = asoc->stats.oodchunks;
5222 info->sctpi_iodchunks = asoc->stats.iodchunks;
5223 info->sctpi_octrlchunks = asoc->stats.octrlchunks;
5224 info->sctpi_ictrlchunks = asoc->stats.ictrlchunks;
5226 prim = asoc->peer.primary_path;
5227 memcpy(&info->sctpi_p_address, &prim->ipaddr, sizeof(prim->ipaddr));
5228 info->sctpi_p_state = prim->state;
5229 info->sctpi_p_cwnd = prim->cwnd;
5230 info->sctpi_p_srtt = prim->srtt;
5231 info->sctpi_p_rto = jiffies_to_msecs(prim->rto);
5232 info->sctpi_p_hbinterval = prim->hbinterval;
5233 info->sctpi_p_pathmaxrxt = prim->pathmaxrxt;
5234 info->sctpi_p_sackdelay = jiffies_to_msecs(prim->sackdelay);
5235 info->sctpi_p_ssthresh = prim->ssthresh;
5236 info->sctpi_p_partial_bytes_acked = prim->partial_bytes_acked;
5237 info->sctpi_p_flight_size = prim->flight_size;
5238 info->sctpi_p_error = prim->error_count;
5266 if (PTR_ERR(t) == -EAGAIN)
5274 if (net_eq(t->asoc->base.net, net) &&
5275 t->asoc->peer.primary_path == t)
5294 if (!--pos)
5311 read_lock_bh(&head->lock);
5312 sctp_for_each_hentry(ep, &head->chain) {
5317 read_unlock_bh(&head->lock);
5330 int err = -ENOENT;
5338 ep = transport->asoc->ep;
5367 ep = tsp->asoc->ep;
5399 * receipt. This information is read-only.
5412 retval = -EINVAL;
5418 retval = -EFAULT;
5425 retval = -EINVAL;
5429 transport = asoc->peer.primary_path;
5433 status.sstat_rwnd = asoc->peer.rwnd;
5434 status.sstat_unackdata = asoc->unack_data;
5436 status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
5437 status.sstat_instrms = asoc->stream.incnt;
5438 status.sstat_outstrms = asoc->stream.outcnt;
5439 status.sstat_fragmentation_point = asoc->frag_point;
5440 status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5441 memcpy(&status.sstat_primary.spinfo_address, &transport->ipaddr,
5442 transport->af_specific->sockaddr_len);
5443 /* Map ipv4 address into v4-mapped-on-v6 address. */
5444 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sctp_sk(sk),
5446 status.sstat_primary.spinfo_state = transport->state;
5447 status.sstat_primary.spinfo_cwnd = transport->cwnd;
5448 status.sstat_primary.spinfo_srtt = transport->srtt;
5449 status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
5450 status.sstat_primary.spinfo_mtu = transport->pathmtu;
5456 retval = -EFAULT;
5465 retval = -EFAULT;
5479 * read-only.
5490 retval = -EINVAL;
5496 retval = -EFAULT;
5503 retval = -EINVAL;
5507 if (transport->state == SCTP_PF &&
5508 transport->asoc->pf_expose == SCTP_PF_EXPOSE_DISABLE) {
5509 retval = -EACCES;
5513 pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
5514 pinfo.spinfo_state = transport->state;
5515 pinfo.spinfo_cwnd = transport->cwnd;
5516 pinfo.spinfo_srtt = transport->srtt;
5517 pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
5518 pinfo.spinfo_mtu = transport->pathmtu;
5524 retval = -EFAULT;
5529 retval = -EFAULT;
5550 return -EINVAL;
5553 val = (sctp_sk(sk)->disable_fragments == 1);
5555 return -EFAULT;
5557 return -EFAULT;
5574 return -EINVAL;
5578 return -EFAULT;
5581 sn_type[i] = sctp_ulpevent_type_enabled(sctp_sk(sk)->subscribe,
5585 return -EFAULT;
5592 * This socket option is applicable to the UDP-style socket only. When
5603 /* Applicable to UDP-style socket only */
5605 return -EOPNOTSUPP;
5607 return -EINVAL;
5610 return -EFAULT;
5611 if (put_user(sctp_sk(sk)->autoclose, (int __user *)optval))
5612 return -EFAULT;
5621 struct sctp_sock *sp = sctp_sk(sk);
5626 if (!net_eq(current->nsproxy->net_ns, sock_net(sk)))
5627 return -EINVAL;
5630 return -EINVAL;
5632 /* An association cannot be branched off from an already peeled-off
5636 return -EINVAL;
5639 err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
5643 sctp_copy_sock(sock->sk, sk, asoc);
5645 /* Make peeled-off sockets more like 1-1 accepted sockets.
5649 sp->pf->to_sk_daddr(&asoc->peer.primary_addr, sock->sk);
5650 sp->pf->copy_ip_options(sk, sock->sk);
5655 err = sctp_sock_migrate(sk, sock->sk, asoc,
5673 retval = sctp_do_peeloff(sk, peeloff->associd, &newsock);
5692 pr_debug("%s: sk:%p, newsk:%p, sd:%d\n", __func__, sk, newsock->sk,
5695 peeloff->sd = retval;
5698 (*newfile)->f_flags |= O_NONBLOCK;
5710 return -EINVAL;
5713 return -EFAULT;
5723 return -EFAULT;
5729 return -EFAULT;
5744 return -EINVAL;
5747 return -EFAULT;
5758 return -EFAULT;
5764 return -EFAULT;
5790 * spp_assoc_id - (one-to-many style socket) This is filled in the
5793 * spp_address - This specifies which address is of interest.
5794 * spp_hbinterval - This contains the value of the heartbeat interval,
5798 * spp_pathmaxrxt - This contains the maximum number of
5803 * spp_pathmtu - When Path MTU discovery is disabled the value
5809 * spp_sackdelay - When delayed sack is enabled, this value specifies
5817 * spp_flags - These flags are used to control various features
5821 * SPP_HB_ENABLE - Enable heartbeats on the
5826 * SPP_HB_DISABLE - Disable heartbeats on the
5835 * SPP_HB_DEMAND - Request a user initiated heartbeat
5838 * SPP_PMTUD_ENABLE - This field will enable PMTU
5843 * SPP_PMTUD_DISABLE - This field will disable PMTU
5851 * SPP_SACKDELAY_ENABLE - Setting this flag turns
5857 * SPP_SACKDELAY_DISABLE - Setting this flag turns
5875 * returned. For non-IPv6 sockets, this flag will be left
5892 * - This field is used in conjunction with the
5895 * label. This setting has precedence over any IPv6-layer
5898 * spp_dscp - This field is used in conjunction with the SPP_DSCP flag
5901 * IPv4- or IPv6- layer setting.
5909 struct sctp_sock *sp = sctp_sk(sk);
5918 return -EINVAL;
5921 return -EFAULT;
5931 return -EINVAL;
5943 return -EINVAL;
5948 params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
5949 params.spp_pathmtu = trans->pathmtu;
5950 params.spp_pathmaxrxt = trans->pathmaxrxt;
5951 params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
5953 /*draft-11 doesn't say what to return in spp_flags*/
5954 params.spp_flags = trans->param_flags;
5955 if (trans->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5956 params.spp_ipv6_flowlabel = trans->flowlabel &
5960 if (trans->dscp & SCTP_DSCP_SET_MASK) {
5961 params.spp_dscp = trans->dscp & SCTP_DSCP_VAL_MASK;
5966 params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
5967 params.spp_pathmtu = asoc->pathmtu;
5968 params.spp_pathmaxrxt = asoc->pathmaxrxt;
5969 params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
5971 /*draft-11 doesn't say what to return in spp_flags*/
5972 params.spp_flags = asoc->param_flags;
5973 if (asoc->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5974 params.spp_ipv6_flowlabel = asoc->flowlabel &
5978 if (asoc->dscp & SCTP_DSCP_SET_MASK) {
5979 params.spp_dscp = asoc->dscp & SCTP_DSCP_VAL_MASK;
5984 params.spp_hbinterval = sp->hbinterval;
5985 params.spp_pathmtu = sp->pathmtu;
5986 params.spp_sackdelay = sp->sackdelay;
5987 params.spp_pathmaxrxt = sp->pathmaxrxt;
5989 /*draft-11 doesn't say what to return in spp_flags*/
5990 params.spp_flags = sp->param_flags;
5991 if (sp->flowlabel & SCTP_FLOWLABEL_SET_MASK) {
5992 params.spp_ipv6_flowlabel = sp->flowlabel &
5996 if (sp->dscp & SCTP_DSCP_SET_MASK) {
5997 params.spp_dscp = sp->dscp & SCTP_DSCP_VAL_MASK;
6003 return -EFAULT;
6006 return -EFAULT;
6019 * values. If the assoc_id field is non-zero, then the set or get
6031 * sack_assoc_id - This parameter, indicates which association the user
6036 * sack_delay - This parameter contains the number of milliseconds that
6041 * sack_freq - This parameter contains the number of packets that must
6052 struct sctp_sock *sp = sctp_sk(sk);
6058 return -EFAULT;
6064 current->comm, task_pid_nr(current));
6066 return -EFAULT;
6068 return -EINVAL;
6077 return -EINVAL;
6081 if (asoc->param_flags & SPP_SACKDELAY_ENABLE) {
6082 params.sack_delay = jiffies_to_msecs(asoc->sackdelay);
6083 params.sack_freq = asoc->sackfreq;
6091 if (sp->param_flags & SPP_SACKDELAY_ENABLE) {
6092 params.sack_delay = sp->sackdelay;
6093 params.sack_freq = sp->sackfreq;
6101 return -EFAULT;
6104 return -EFAULT;
6116 * socket (for UDP-style sockets only future associations are effected
6117 * by the change). With TCP-style sockets, this option is inherited by
6123 return -EINVAL;
6126 return -EFAULT;
6127 if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
6128 return -EFAULT;
6142 struct sctp_sock *sp = sctp_sk(sk);
6148 return -EINVAL;
6151 return -EFAULT;
6153 /* For UDP-style sockets, id specifies the association to query. */
6156 return -EINVAL;
6159 space_left = len - offsetof(struct sctp_getaddrs, addrs);
6161 list_for_each_entry(from, &asoc->peer.transport_addr_list,
6163 memcpy(&temp, &from->ipaddr, sizeof(temp));
6164 addrlen = sctp_get_pf_specific(sk->sk_family)
6165 ->addr_to_user(sp, &temp);
6167 return -ENOMEM;
6169 return -EFAULT;
6172 space_left -= addrlen;
6175 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
6176 return -EFAULT;
6177 bytes_copied = ((char __user *)to) - optval;
6179 return -EFAULT;
6194 list_for_each_entry_rcu(addr, &net->sctp.local_addr_list, list) {
6195 if (!addr->valid)
6198 if ((PF_INET == sk->sk_family) &&
6199 (AF_INET6 == addr->a.sa.sa_family))
6201 if ((PF_INET6 == sk->sk_family) &&
6203 (AF_INET == addr->a.sa.sa_family))
6205 memcpy(&temp, &addr->a, sizeof(temp));
6209 addrlen = sctp_get_pf_specific(sk->sk_family)
6210 ->addr_to_user(sctp_sk(sk), &temp);
6213 cnt = -ENOMEM;
6220 space_left -= addrlen;
6239 struct sctp_sock *sp = sctp_sk(sk);
6248 return -EINVAL;
6251 return -EFAULT;
6254 * For UDP-style sockets, id specifies the association to query.
6260 bp = &sctp_sk(sk)->ep->base.bind_addr;
6264 return -EINVAL;
6265 bp = &asoc->base.bind_addr;
6269 space_left = len - offsetof(struct sctp_getaddrs, addrs);
6273 return -ENOMEM;
6278 if (sctp_list_single_entry(&bp->address_list)) {
6279 addr = list_entry(bp->address_list.next,
6281 if (sctp_is_any(sk, &addr->a)) {
6282 cnt = sctp_copy_laddrs(sk, bp->port, addrs,
6297 list_for_each_entry(addr, &bp->address_list, list) {
6298 memcpy(&temp, &addr->a, sizeof(temp));
6299 addrlen = sctp_get_pf_specific(sk->sk_family)
6300 ->addr_to_user(sp, &temp);
6302 err = -ENOMEM; /*fixme: right error?*/
6309 space_left -= addrlen;
6314 err = -EFAULT;
6317 if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num)) {
6318 err = -EFAULT;
6325 err = -EFAULT;
6342 struct sctp_sock *sp = sctp_sk(sk);
6345 return -EINVAL;
6350 return -EFAULT;
6354 return -EINVAL;
6356 if (!asoc->peer.primary_path)
6357 return -ENOTCONN;
6359 memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
6360 asoc->peer.primary_path->af_specific->sockaddr_len);
6362 sctp_get_pf_specific(sk->sk_family)->addr_to_user(sp,
6366 return -EFAULT;
6368 return -EFAULT;
6377 * Indication parameter for all future INIT and INIT-ACK exchanges.
6385 return -EINVAL;
6389 adaptation.ssb_adaptation_ind = sctp_sk(sk)->adaptation_ind;
6392 return -EFAULT;
6394 return -EFAULT;
6422 struct sctp_sock *sp = sctp_sk(sk);
6427 return -EINVAL;
6432 return -EFAULT;
6437 return -EINVAL;
6440 info.sinfo_stream = asoc->default_stream;
6441 info.sinfo_flags = asoc->default_flags;
6442 info.sinfo_ppid = asoc->default_ppid;
6443 info.sinfo_context = asoc->default_context;
6444 info.sinfo_timetolive = asoc->default_timetolive;
6446 info.sinfo_stream = sp->default_stream;
6447 info.sinfo_flags = sp->default_flags;
6448 info.sinfo_ppid = sp->default_ppid;
6449 info.sinfo_context = sp->default_context;
6450 info.sinfo_timetolive = sp->default_timetolive;
6454 return -EFAULT;
6456 return -EFAULT;
6468 struct sctp_sock *sp = sctp_sk(sk);
6473 return -EINVAL;
6478 return -EFAULT;
6483 return -EINVAL;
6486 info.snd_sid = asoc->default_stream;
6487 info.snd_flags = asoc->default_flags;
6488 info.snd_ppid = asoc->default_ppid;
6489 info.snd_context = asoc->default_context;
6491 info.snd_sid = sp->default_stream;
6492 info.snd_flags = sp->default_flags;
6493 info.snd_ppid = sp->default_ppid;
6494 info.snd_context = sp->default_context;
6498 return -EFAULT;
6500 return -EFAULT;
6509 * Turn on/off any Nagle-like algorithm. This means that packets are
6521 return -EINVAL;
6524 val = (sctp_sk(sk)->nodelay == 1);
6526 return -EFAULT;
6528 return -EFAULT;
6551 return -EINVAL;
6556 return -EFAULT;
6562 return -EINVAL;
6566 rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
6567 rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
6568 rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
6571 struct sctp_sock *sp = sctp_sk(sk);
6573 rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
6574 rtoinfo.srto_max = sp->rtoinfo.srto_max;
6575 rtoinfo.srto_min = sp->rtoinfo.srto_min;
6579 return -EFAULT;
6582 return -EFAULT;
6609 return -EINVAL;
6614 return -EFAULT;
6620 return -EINVAL;
6624 assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
6625 assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
6626 assocparams.sasoc_local_rwnd = asoc->a_rwnd;
6627 assocparams.sasoc_cookie_life = ktime_to_ms(asoc->cookie_life);
6629 list_for_each(pos, &asoc->peer.transport_addr_list) {
6636 struct sctp_sock *sp = sctp_sk(sk);
6638 assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
6639 assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
6640 assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
6642 sp->assocparams.sasoc_cookie_life;
6644 sp->assocparams.
6649 return -EFAULT;
6652 return -EFAULT;
6671 struct sctp_sock *sp = sctp_sk(sk);
6674 return -EINVAL;
6677 val = sp->v4mapped;
6679 return -EFAULT;
6681 return -EFAULT;
6697 return -EINVAL;
6702 return -EFAULT;
6707 return -EINVAL;
6709 params.assoc_value = asoc ? asoc->default_rcv_context
6710 : sctp_sk(sk)->default_rcv_context;
6713 return -EFAULT;
6715 return -EFAULT;
6740 * assoc_id: This parameter is ignored for one-to-one style sockets.
6741 * For one-to-many style sockets this parameter indicates which
6758 current->comm, task_pid_nr(current));
6763 return -EFAULT;
6765 return -EINVAL;
6770 return -EINVAL;
6773 params.assoc_value = asoc->frag_point;
6775 params.assoc_value = sctp_sk(sk)->user_frag;
6778 return -EFAULT;
6781 return -EFAULT;
6784 return -EFAULT;
6800 return -EINVAL;
6804 val = sctp_sk(sk)->frag_interleave;
6806 return -EFAULT;
6808 return -EFAULT;
6824 return -EINVAL;
6828 val = sctp_sk(sk)->pd_point;
6830 return -EFAULT;
6832 return -EFAULT;
6853 current->comm, task_pid_nr(current));
6858 return -EFAULT;
6860 return -EINVAL;
6865 return -EINVAL;
6867 params.assoc_value = asoc ? asoc->max_burst : sctp_sk(sk)->max_burst;
6871 return -EFAULT;
6874 return -EFAULT;
6884 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6891 if (!ep->auth_enable)
6892 return -EACCES;
6894 hmacs = ep->auth_hmacs_list;
6895 data_len = ntohs(hmacs->param_hdr.length) -
6899 return -EINVAL;
6905 return -EFAULT;
6906 if (put_user(num_idents, &p->shmac_num_idents))
6907 return -EFAULT;
6909 __u16 hmacid = ntohs(hmacs->hmac_ids[i]);
6911 if (copy_to_user(&p->shmac_idents[i], &hmacid, sizeof(__u16)))
6912 return -EFAULT;
6920 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
6925 return -EINVAL;
6929 return -EFAULT;
6933 return -EINVAL;
6936 if (!asoc->peer.auth_capable)
6937 return -EACCES;
6938 val.scact_keynumber = asoc->active_key_id;
6940 if (!ep->auth_enable)
6941 return -EACCES;
6942 val.scact_keynumber = ep->active_key_id;
6946 return -EFAULT;
6948 return -EFAULT;
6964 return -EINVAL;
6967 return -EFAULT;
6969 to = p->gauth_chunks;
6972 return -EINVAL;
6974 if (!asoc->peer.auth_capable)
6975 return -EACCES;
6977 ch = asoc->peer.peer_chunks;
6982 num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
6984 return -EINVAL;
6986 if (copy_to_user(to, ch->chunks, num_chunks))
6987 return -EFAULT;
6991 return -EFAULT;
6992 if (put_user(num_chunks, &p->gauth_number_of_chunks))
6993 return -EFAULT;
7000 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
7009 return -EINVAL;
7012 return -EFAULT;
7014 to = p->gauth_chunks;
7018 return -EINVAL;
7021 if (!asoc->peer.auth_capable)
7022 return -EACCES;
7023 ch = (struct sctp_chunks_param *)asoc->c.auth_chunks;
7025 if (!ep->auth_enable)
7026 return -EACCES;
7027 ch = ep->auth_chunk_list;
7032 num_chunks = ntohs(ch->param_hdr.length) - sizeof(struct sctp_paramhdr);
7034 return -EINVAL;
7036 if (copy_to_user(to, ch->chunks, num_chunks))
7037 return -EFAULT;
7041 return -EFAULT;
7042 if (put_user(num_chunks, &p->gauth_number_of_chunks))
7043 return -EFAULT;
7051 * to a one-to-many style socket. The option value is an uint32_t.
7056 struct sctp_sock *sp = sctp_sk(sk);
7061 return -EOPNOTSUPP;
7064 return -EINVAL;
7068 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7073 return -EFAULT;
7075 return -EFAULT;
7090 return -EINVAL;
7093 if (sctp_sk(sk)->do_auto_asconf && sctp_is_ep_boundall(sk))
7096 return -EFAULT;
7098 return -EFAULT;
7107 * the SCTP associations handled by a one-to-many style socket.
7112 struct sctp_sock *sp = sctp_sk(sk);
7119 return -EOPNOTSUPP;
7122 return -EINVAL;
7124 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7130 return -EINVAL;
7135 return -ENOMEM;
7137 ids->gaids_number_of_ids = num;
7139 list_for_each_entry(asoc, &(sp->ep->asocs), asocs) {
7140 ids->gaids_assoc_id[num++] = asoc->assoc_id;
7145 return -EFAULT;
7157 * http://www.ietf.org/id/draft-nishida-tsvwg-sctp-failover-05.txt
7170 return -EINVAL;
7173 return -EFAULT;
7179 return -ENOENT;
7181 val.spt_pathmaxrxt = trans->pathmaxrxt;
7182 val.spt_pathpfthld = trans->pf_retrans;
7183 val.spt_pathcpthld = trans->ps_retrans;
7191 return -EINVAL;
7194 val.spt_pathpfthld = asoc->pf_retrans;
7195 val.spt_pathmaxrxt = asoc->pathmaxrxt;
7196 val.spt_pathcpthld = asoc->ps_retrans;
7198 struct sctp_sock *sp = sctp_sk(sk);
7200 val.spt_pathpfthld = sp->pf_retrans;
7201 val.spt_pathmaxrxt = sp->pathmaxrxt;
7202 val.spt_pathcpthld = sp->ps_retrans;
7207 return -EFAULT;
7227 return -EINVAL;
7233 return -EFAULT;
7237 return -EINVAL;
7239 sas.sas_rtxchunks = asoc->stats.rtxchunks;
7240 sas.sas_gapcnt = asoc->stats.gapcnt;
7241 sas.sas_outofseqtsns = asoc->stats.outofseqtsns;
7242 sas.sas_osacks = asoc->stats.osacks;
7243 sas.sas_isacks = asoc->stats.isacks;
7244 sas.sas_octrlchunks = asoc->stats.octrlchunks;
7245 sas.sas_ictrlchunks = asoc->stats.ictrlchunks;
7246 sas.sas_oodchunks = asoc->stats.oodchunks;
7247 sas.sas_iodchunks = asoc->stats.iodchunks;
7248 sas.sas_ouodchunks = asoc->stats.ouodchunks;
7249 sas.sas_iuodchunks = asoc->stats.iuodchunks;
7250 sas.sas_idupchunks = asoc->stats.idupchunks;
7251 sas.sas_opackets = asoc->stats.opackets;
7252 sas.sas_ipackets = asoc->stats.ipackets;
7258 sas.sas_maxrto = asoc->stats.max_obs_rto;
7259 memcpy(&sas.sas_obs_rto_ipaddr, &asoc->stats.obs_rto_ipaddr,
7263 asoc->stats.max_obs_rto = asoc->rto_min;
7266 return -EFAULT;
7271 return -EFAULT;
7283 return -EINVAL;
7286 if (sctp_sk(sk)->recvrcvinfo)
7289 return -EFAULT;
7291 return -EFAULT;
7303 return -EINVAL;
7306 if (sctp_sk(sk)->recvnxtinfo)
7309 return -EFAULT;
7311 return -EFAULT;
7322 int retval = -EFAULT;
7325 retval = -EINVAL;
7336 retval = -EINVAL;
7340 params.assoc_value = asoc ? asoc->peer.prsctp_capable
7341 : sctp_sk(sk)->ep->prsctp_enable;
7361 int retval = -EFAULT;
7364 retval = -EINVAL;
7375 retval = -EINVAL;
7380 info.pr_policy = SCTP_PR_POLICY(asoc->default_flags);
7381 info.pr_value = asoc->default_timetolive;
7383 struct sctp_sock *sp = sctp_sk(sk);
7385 info.pr_policy = SCTP_PR_POLICY(sp->default_flags);
7386 info.pr_value = sp->default_timetolive;
7408 int retval = -EINVAL;
7415 retval = -EFAULT;
7433 asoc->abandoned_unsent[policy];
7435 asoc->abandoned_sent[policy];
7439 asoc->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7441 asoc->abandoned_sent[__SCTP_PR_INDEX(policy)];
7445 retval = -EFAULT;
7450 retval = -EFAULT;
7467 int retval = -EINVAL;
7475 retval = -EFAULT;
7485 if (!asoc || params.sprstat_sid >= asoc->stream.outcnt)
7488 streamoute = SCTP_SO(&asoc->stream, params.sprstat_sid)->ext;
7502 streamoute->abandoned_unsent[policy];
7504 streamoute->abandoned_sent[policy];
7508 streamoute->abandoned_unsent[__SCTP_PR_INDEX(policy)];
7510 streamoute->abandoned_sent[__SCTP_PR_INDEX(policy)];
7514 retval = -EFAULT;
7530 int retval = -EFAULT;
7533 retval = -EINVAL;
7544 retval = -EINVAL;
7548 params.assoc_value = asoc ? asoc->peer.reconf_capable
7549 : sctp_sk(sk)->ep->reconf_enable;
7569 int retval = -EFAULT;
7572 retval = -EINVAL;
7583 retval = -EINVAL;
7587 params.assoc_value = asoc ? asoc->strreset_enable
7588 : sctp_sk(sk)->ep->strreset_enable;
7608 int retval = -EFAULT;
7611 retval = -EINVAL;
7622 retval = -EINVAL;
7627 : sctp_sk(sk)->default_ss;
7647 int retval = -EFAULT;
7650 retval = -EINVAL;
7660 retval = -EINVAL;
7670 retval = -EFAULT;
7675 retval = -EFAULT;
7689 int retval = -EFAULT;
7692 retval = -EINVAL;
7703 retval = -EINVAL;
7707 params.assoc_value = asoc ? asoc->peer.intl_capable
7708 : sctp_sk(sk)->ep->intl_enable;
7729 return -EINVAL;
7732 val = sctp_sk(sk)->reuse;
7734 return -EFAULT;
7737 return -EFAULT;
7750 return -EINVAL;
7754 return -EFAULT;
7758 return -EINVAL;
7763 return -EINVAL;
7765 subscribe = asoc ? asoc->subscribe : sctp_sk(sk)->subscribe;
7769 return -EFAULT;
7772 return -EFAULT;
7783 int retval = -EFAULT;
7786 retval = -EINVAL;
7797 retval = -EINVAL;
7801 params.assoc_value = asoc ? asoc->peer.asconf_capable
7802 : sctp_sk(sk)->ep->asconf_enable;
7822 int retval = -EFAULT;
7825 retval = -EINVAL;
7836 retval = -EINVAL;
7840 params.assoc_value = asoc ? asoc->peer.auth_capable
7841 : sctp_sk(sk)->ep->auth_enable;
7861 int retval = -EFAULT;
7864 retval = -EINVAL;
7875 retval = -EINVAL;
7879 params.assoc_value = asoc ? asoc->peer.ecn_capable
7880 : sctp_sk(sk)->ep->ecn_enable;
7900 int retval = -EFAULT;
7903 retval = -EINVAL;
7914 retval = -EINVAL;
7918 params.assoc_value = asoc ? asoc->pf_expose
7919 : sctp_sk(sk)->pf_expose;
7942 return -EINVAL;
7946 return -EFAULT;
7956 return -EINVAL;
7959 encap_port = t->encap_port;
7971 return -EINVAL;
7975 encap_port = asoc->encap_port;
7979 encap_port = sctp_sk(sk)->encap_port;
7984 return -EFAULT;
7987 return -EFAULT;
8002 return -EINVAL;
8006 return -EFAULT;
8016 return -EINVAL;
8019 probe_interval = jiffies_to_msecs(t->probe_interval);
8031 return -EINVAL;
8035 probe_interval = jiffies_to_msecs(asoc->probe_interval);
8039 probe_interval = sctp_sk(sk)->probe_interval;
8044 return -EFAULT;
8047 return -EFAULT;
8064 * are at all well-founded.
8067 struct sctp_af *af = sctp_sk(sk)->pf->af;
8069 retval = af->getsockopt(sk, level, optname, optval, optlen);
8074 return -EFAULT;
8077 return -EINVAL;
8175 retval = -EOPNOTSUPP;
8279 retval = -ENOPROTOOPT;
8331 struct sctp_sock *sp = sctp_sk(sk);
8332 bool reuse = (sk->sk_reuse || sp->reuse);
8340 snum = ntohs(addr->v4.sin_port);
8350 remaining = (high - low) + 1;
8361 spin_lock_bh(&head->lock);
8362 sctp_for_each_hentry(pp, &head->chain)
8363 if ((pp->port == rover) &&
8364 net_eq(net, pp->net))
8368 spin_unlock_bh(&head->lock);
8370 } while (--remaining > 0);
8378 * hash table list entry) is non-NULL and we hold it's
8386 * to the port number (snum) - we detect that with the
8390 spin_lock_bh(&head->lock);
8391 sctp_for_each_hentry(pp, &head->chain) {
8392 if ((pp->port == snum) && net_eq(pp->net, net))
8399 if (!hlist_empty(&pp->owner)) {
8400 /* We had a port hash table hit - there is an
8402 * used by other socket (pp->owner not empty); that other
8409 if ((pp->fastreuse && reuse &&
8410 sk->sk_state != SCTP_SS_LISTENING) ||
8411 (pp->fastreuseport && sk->sk_reuseport &&
8412 uid_eq(pp->fastuid, uid)))
8416 * (pp->port) [via the pointers bind_next and
8417 * bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
8425 sk_for_each_bound(sk2, &pp->owner) {
8426 int bound_dev_if2 = READ_ONCE(sk2->sk_bound_dev_if);
8428 struct sctp_endpoint *ep2 = sp2->ep;
8431 (reuse && (sk2->sk_reuse || sp2->reuse) &&
8432 sk2->sk_state != SCTP_SS_LISTENING) ||
8433 (sk->sk_reuseport && sk2->sk_reuseport &&
8437 if ((!sk->sk_bound_dev_if || !bound_dev_if2 ||
8438 sk->sk_bound_dev_if == bound_dev_if2) &&
8439 sctp_bind_addr_conflict(&ep2->base.bind_addr,
8440 addr, sp2, sp)) {
8455 * if sk->sk_reuse is too (that is, if the caller requested
8456 * SO_REUSEADDR on this socket -sk-).
8458 if (hlist_empty(&pp->owner)) {
8459 if (reuse && sk->sk_state != SCTP_SS_LISTENING)
8460 pp->fastreuse = 1;
8462 pp->fastreuse = 0;
8464 if (sk->sk_reuseport) {
8465 pp->fastreuseport = 1;
8466 pp->fastuid = uid;
8468 pp->fastreuseport = 0;
8471 if (pp->fastreuse &&
8472 (!reuse || sk->sk_state == SCTP_SS_LISTENING))
8473 pp->fastreuse = 0;
8475 if (pp->fastreuseport &&
8476 (!sk->sk_reuseport || !uid_eq(pp->fastuid, uid)))
8477 pp->fastreuseport = 0;
8485 if (!sp->bind_hash) {
8486 inet_sk(sk)->inet_num = snum;
8487 sk_add_bind_node(sk, &pp->owner);
8488 sp->bind_hash = pp;
8493 spin_unlock_bh(&head->lock);
8503 struct sctp_af *af = sctp_sk(sk)->pf->af;
8506 af->from_sk(&addr, sk);
8509 /* Note: sk->sk_num gets filled in if ephemeral port request. */
8518 struct sctp_sock *sp = sctp_sk(sk);
8519 struct sctp_endpoint *ep = sp->ep;
8534 if (!ep->base.bind_addr.port) {
8536 err = -EAGAIN;
8540 if (sctp_get_port(sk, inet_sk(sk)->inet_num)) {
8541 err = -EADDRINUSE;
8546 WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8573 struct sock *sk = sock->sk;
8574 struct sctp_endpoint *ep = sctp_sk(sk)->ep;
8575 int err = -EINVAL;
8582 /* Peeled-off sockets are not allowed to listen(). */
8586 if (sock->state != SS_UNCONNECTED)
8599 sk->sk_state = SCTP_SS_CLOSED;
8600 if (sk->sk_reuse || sctp_sk(sk)->reuse)
8601 sctp_sk(sk)->bind_hash->fastreuse = 1;
8607 WRITE_ONCE(sk->sk_max_ack_backlog, backlog);
8635 struct sock *sk = sock->sk;
8636 struct sctp_sock *sp = sctp_sk(sk);
8643 /* A TCP-style listening socket becomes readable when the accept queue
8647 return (!list_empty(&sp->ep->asocs)) ?
8653 if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
8656 if (sk->sk_shutdown & RCV_SHUTDOWN)
8658 if (sk->sk_shutdown == SHUTDOWN_MASK)
8661 /* Is it readable? Reconsider this code with TCP-style support. */
8662 if (!skb_queue_empty_lockless(&sk->sk_receive_queue))
8700 pp->port = snum;
8701 pp->fastreuse = 0;
8702 INIT_HLIST_HEAD(&pp->owner);
8703 pp->net = net;
8704 hlist_add_head(&pp->node, &head->chain);
8712 if (pp && hlist_empty(&pp->owner)) {
8713 __hlist_del(&pp->node);
8724 inet_sk(sk)->inet_num)];
8727 spin_lock(&head->lock);
8728 pp = sctp_sk(sk)->bind_hash;
8730 sctp_sk(sk)->bind_hash = NULL;
8731 inet_sk(sk)->inet_num = 0;
8733 spin_unlock(&head->lock);
8756 af = sctp_sk(sk)->pf->af;
8758 port = htons(inet_sk(sk)->inet_num);
8759 af->inaddr_any(&autoaddr, port);
8761 return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
8773 * Historically Berkeley-derived implementations have passed only one object
8778 * |<--------------------------- msg_controllen -------------------------->|
8781 * |<----- ancillary data object ----->|<----- ancillary data object ----->|
8783 * |<---------- CMSG_SPACE() --------->|<---------- CMSG_SPACE() --------->|
8786 * |<---------- cmsg_len ---------->| |<--------- cmsg_len ----------->| |
8788 * |<--------- CMSG_LEN() --------->| |<-------- CMSG_LEN() ---------->| |
8791 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8796 * +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
8810 return -EINVAL;
8813 if (cmsg->cmsg_level != IPPROTO_SCTP)
8817 switch (cmsg->cmsg_type) {
8829 * ------------ ------------ ----------------------
8832 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_initmsg)))
8833 return -EINVAL;
8835 cmsgs->init = CMSG_DATA(cmsg);
8847 * ------------ ------------ ----------------------
8850 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
8851 return -EINVAL;
8853 cmsgs->srinfo = CMSG_DATA(cmsg);
8855 if (cmsgs->srinfo->sinfo_flags &
8859 return -EINVAL;
8871 * ------------ ------------ ---------------------
8874 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_sndinfo)))
8875 return -EINVAL;
8877 cmsgs->sinfo = CMSG_DATA(cmsg);
8879 if (cmsgs->sinfo->snd_flags &
8883 return -EINVAL;
8887 * 5.3.7 SCTP PR-SCTP Information Structure (SCTP_PRINFO)
8892 * ------------ ------------ ---------------------
8895 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_prinfo)))
8896 return -EINVAL;
8898 cmsgs->prinfo = CMSG_DATA(cmsg);
8899 if (cmsgs->prinfo->pr_policy & ~SCTP_PR_SCTP_MASK)
8900 return -EINVAL;
8902 if (cmsgs->prinfo->pr_policy == SCTP_PR_SCTP_NONE)
8903 cmsgs->prinfo->pr_value = 0;
8912 * ------------ ------------ ---------------------
8915 if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct sctp_authinfo)))
8916 return -EINVAL;
8918 cmsgs->authinfo = CMSG_DATA(cmsg);
8928 * ------------ ------------ ---------------------
8930 * ------------ ------------ ---------------------
8933 cmsgs->addrs_msg = my_msg;
8936 return -EINVAL;
8960 if (!skb_queue_empty(&sk->sk_receive_queue))
8964 if (sk->sk_shutdown & RCV_SHUTDOWN)
8970 error = -ENOTCONN;
8973 if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
9026 skb = skb_peek(&sk->sk_receive_queue);
9028 refcount_inc(&skb->users);
9030 skb = __skb_dequeue(&sk->sk_receive_queue);
9036 /* Caller is allowed not to check sk->sk_err before calling. */
9041 if (sk->sk_shutdown & RCV_SHUTDOWN)
9046 error = -EAGAIN;
9061 struct sock *sk = asoc->base.sk;
9066 if (waitqueue_active(&asoc->wait))
9067 wake_up_interruptible(&asoc->wait);
9073 wq = rcu_dereference(sk->sk_wq);
9075 if (waitqueue_active(&wq->wait))
9076 wake_up_interruptible_poll(&wq->wait, EPOLLOUT |
9083 if (!(sk->sk_shutdown & SEND_SHUTDOWN))
9098 if (asoc->ep->sndbuf_policy)
9104 if (asoc->base.dead)
9120 if (&tmp->asocs == &((sctp_sk(sk))->ep->asocs))
9136 struct sctp_chunk *chunk = skb_shinfo(skb)->destructor_arg;
9137 struct sctp_association *asoc = chunk->asoc;
9138 struct sock *sk = asoc->base.sk;
9140 sk_mem_uncharge(sk, skb->truesize);
9141 sk_wmem_queued_add(sk, -(skb->truesize + sizeof(struct sctp_chunk)));
9142 asoc->sndbuf_used -= skb->truesize + sizeof(struct sctp_chunk);
9144 &sk->sk_wmem_alloc));
9146 if (chunk->shkey) {
9147 struct sctp_shared_key *shkey = chunk->shkey;
9153 if (shkey->deactivated && !list_empty(&shkey->key_list) &&
9154 refcount_read(&shkey->refcnt) == 2) {
9157 ev = sctp_ulpevent_make_authkey(asoc, shkey->key_id,
9161 asoc->stream.si->enqueue_event(&asoc->ulpq, ev);
9163 sctp_auth_shkey_release(chunk->shkey);
9179 struct sock *sk = skb->sk;
9182 atomic_sub(event->rmem_len, &sk->sk_rmem_alloc);
9187 sk_mem_uncharge(sk, event->rmem_len);
9196 struct sock *sk = asoc->base.sk;
9211 prepare_to_wait_exclusive(&asoc->wait, &wait,
9213 if (asoc->base.dead)
9215 if ((!*timeo_p) || (transport && transport->dead))
9217 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING)
9231 if (sk != asoc->base.sk)
9238 finish_wait(&asoc->wait, &wait);
9248 err = -ESRCH;
9252 err = -EPIPE;
9260 err = -EAGAIN;
9271 wq = rcu_dereference(sk->sk_wq);
9273 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN |
9285 list_for_each_entry(asoc, &((sctp_sk(sk))->ep->asocs), asocs) {
9293 * associations on the same socket. For a UDP-style socket with
9297 * would cause an unwanted block under certain circumstances. For the 1-1
9298 * UDP-style sockets or TCP-style sockets, this code should work.
9299 * - Daisy
9303 return READ_ONCE(sk->sk_sndbuf) > READ_ONCE(sk->sk_wmem_queued);
9311 struct sock *sk = asoc->base.sk;
9322 prepare_to_wait_exclusive(&asoc->wait, &wait,
9326 if (sk->sk_shutdown & RCV_SHUTDOWN)
9328 if (sk->sk_err || asoc->state >= SCTP_STATE_SHUTDOWN_PENDING ||
9329 asoc->base.dead)
9348 finish_wait(&asoc->wait, &wait);
9356 if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
9357 err = -ETIMEDOUT;
9359 err = -ECONNREFUSED;
9367 err = -EINPROGRESS;
9377 ep = sctp_sk(sk)->ep;
9384 if (list_empty(&ep->asocs)) {
9390 err = -EINVAL;
9392 (sk->sk_shutdown & RCV_SHUTDOWN))
9396 if (!list_empty(&ep->asocs))
9403 err = -EAGAIN;
9419 if (list_empty(&sctp_sk(sk)->ep->asocs))
9433 if (!skb->data_len)
9449 struct sctp_sock *sp = sctp_sk(sk);
9451 newsk->sk_type = sk->sk_type;
9452 newsk->sk_bound_dev_if = sk->sk_bound_dev_if;
9453 newsk->sk_flags = sk->sk_flags;
9454 newsk->sk_tsflags = sk->sk_tsflags;
9455 newsk->sk_no_check_tx = sk->sk_no_check_tx;
9456 newsk->sk_no_check_rx = sk->sk_no_check_rx;
9457 newsk->sk_reuse = sk->sk_reuse;
9458 sctp_sk(newsk)->reuse = sp->reuse;
9460 newsk->sk_shutdown = sk->sk_shutdown;
9461 newsk->sk_destruct = sk->sk_destruct;
9462 newsk->sk_family = sk->sk_family;
9463 newsk->sk_protocol = IPPROTO_SCTP;
9464 newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
9465 newsk->sk_sndbuf = sk->sk_sndbuf;
9466 newsk->sk_rcvbuf = sk->sk_rcvbuf;
9467 newsk->sk_lingertime = sk->sk_lingertime;
9468 newsk->sk_rcvtimeo = READ_ONCE(sk->sk_rcvtimeo);
9469 newsk->sk_sndtimeo = READ_ONCE(sk->sk_sndtimeo);
9470 newsk->sk_rxhash = sk->sk_rxhash;
9477 newinet->inet_sport = inet->inet_sport;
9478 newinet->inet_saddr = inet->inet_saddr;
9479 newinet->inet_rcv_saddr = inet->inet_rcv_saddr;
9480 newinet->inet_dport = htons(asoc->peer.port);
9481 newinet->pmtudisc = inet->pmtudisc;
9482 atomic_set(&newinet->inet_id, get_random_u16());
9484 newinet->uc_ttl = inet->uc_ttl;
9486 newinet->mc_ttl = 1;
9487 newinet->mc_index = 0;
9488 newinet->mc_list = NULL;
9490 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
9504 ancestor_size += sk_from->sk_prot->obj_size;
9505 ancestor_size -= offsetof(struct sctp_sock, pd_lobby);
9519 struct sctp_endpoint *newep = newsp->ep;
9528 newsk->sk_sndbuf = oldsk->sk_sndbuf;
9529 newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
9536 newsp->ep = newep;
9540 inet_sk(oldsk)->inet_num)];
9541 spin_lock_bh(&head->lock);
9542 pp = sctp_sk(oldsk)->bind_hash;
9543 sk_add_bind_node(newsk, &pp->owner);
9544 sctp_sk(newsk)->bind_hash = pp;
9545 inet_sk(newsk)->inet_num = inet_sk(oldsk)->inet_num;
9546 spin_unlock_bh(&head->lock);
9551 err = sctp_bind_addr_dup(&newsp->ep->base.bind_addr,
9552 &oldsp->ep->base.bind_addr, GFP_KERNEL);
9561 sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
9563 if (event->asoc == assoc) {
9564 __skb_unlink(skb, &oldsk->sk_receive_queue);
9565 __skb_queue_tail(&newsk->sk_receive_queue, skb);
9574 * 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
9576 atomic_set(&sctp_sk(newsk)->pd_mode, assoc->ulpq.pd_mode);
9578 if (atomic_read(&sctp_sk(oldsk)->pd_mode)) {
9582 if (assoc->ulpq.pd_mode) {
9583 queue = &newsp->pd_lobby;
9585 queue = &newsk->sk_receive_queue;
9590 sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
9592 if (event->asoc == assoc) {
9593 __skb_unlink(skb, &oldsp->pd_lobby);
9602 if (assoc->ulpq.pd_mode)
9610 * original UDP-style socket or created with the accept() call on a
9611 * TCP-style socket..
9613 newsp->type = type;
9615 /* Mark the new socket "in-use" by the user so that any packets
9618 * backlog processing on the old socket and new-packet processing
9634 newsk->sk_shutdown |= RCV_SHUTDOWN;
9669 .usersize = offsetof(struct sctp_sock, initmsg) -
9696 sk->sk_destruct = sctp_v6_destruct_sock;
9725 .usersize = offsetof(struct sctp6_sock, sctp.initmsg) -