/* SCTP kernel implementation * Copyright (c) 1999-2000 Cisco, Inc. * Copyright (c) 1999-2001 Motorola, Inc. * Copyright (c) 2001-2003 International Business Machines, Corp. * Copyright (c) 2001 Intel Corp. * Copyright (c) 2001 Nokia, Inc. * Copyright (c) 2001 La Monte H.P. Yarroll * * This file is part of the SCTP kernel implementation * * These functions handle all input from the IP layer into SCTP. * * This SCTP implementation is free software; * you can redistribute it and/or modify it under the terms of * the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This SCTP implementation is distributed in the hope that it * will be useful, but WITHOUT ANY WARRANTY; without even the implied *                 ************************ * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with GNU CC; see the file COPYING.  If not, write to * the Free Software Foundation, 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * * Please send any bug reports or fixes you make to the * email address(es): *    lksctp developers <lksctp-developers@lists.sourceforge.net> * * Or submit a bug report through the following website: *    http://www.sf.net/projects/lksctp * * Written or modified by: *    La Monte H.P. Yarroll <piggy@acm.org> *    Karl Knutson <karl@athena.chicago.il.us> *    Xingang Guo <xingang.guo@intel.com> *    Jon Grimm <jgrimm@us.ibm.com> *    Hui Huang <hui.huang@nokia.com> *    Daisy Chang <daisyc@us.ibm.com> *    Sridhar Samudrala <sri@us.ibm.com> *    Ardelle Fan <ardelle.fan@intel.com> * * Any bugs reported given to us we will try to fix... any fixes shared will * be incorporated into the next SCTP release. */ #include <linux/types.h>#include <linux/list.h> /* For struct list_head */#include <linux/socket.h>#include <linux/ip.h>#include <linux/time.h> /* For struct timeval */#include <linux/slab.h>#include <net/ip.h>#include <net/icmp.h>#include <net/snmp.h>#include <net/sock.h>#include <net/xfrm.h>#include <net/sctp/sctp.h>#include <net/sctp/sm.h>#include <net/sctp/checksum.h>#include <net/net_namespace.h> /* Forward declarations for internal helpers. */static int sctp_rcv_ootb(struct sk_buff *);static struct sctp_association *__sctp_rcv_lookup(struct sk_buff *skb,				      const union sctp_addr *laddr,				      const union sctp_addr *paddr,				      struct sctp_transport **transportp);static struct sctp_endpoint *__sctp_rcv_lookup_endpoint(const union sctp_addr *laddr);static struct sctp_association *__sctp_lookup_association(					const union sctp_addr *local,					const union sctp_addr *peer,					struct sctp_transport **pt); static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb);  /* Calculate the SCTP checksum of an SCTP packet.  */static inline int sctp_rcv_checksum(struct sk_buff *skb){	struct sctphdr *sh = sctp_hdr(skb);	__le32 cmp = sh->checksum;	struct sk_buff *list;	__le32 val;	__u32 tmp = sctp_start_cksum((__u8 *)sh, skb_headlen(skb)); 	skb_walk_frags(skb, list)		tmp = sctp_update_cksum((__u8 *)list->data, skb_headlen(list),					tmp); 	val = sctp_end_cksum(tmp); 	if (val != cmp) {		/* CRC failure, dump it. */		SCTP_INC_STATS_BH(SCTP_MIB_CHECKSUMERRORS);		return -1;	}	return 0;} struct sctp_input_cb {	union {		struct inet_skb_parm	h4;#if IS_ENABLED(CONFIG_IPV6)		struct inet6_skb_parm	h6;#endif	} header;	struct sctp_chunk *chunk;};#define SCTP_INPUT_CB(__skb)	((struct sctp_input_cb *)&((__skb)->cb[0])) /* * This is the routine which IP calls when receiving an SCTP packet. */int sctp_rcv(struct sk_buff *skb){	struct sock *sk;	struct sctp_association *asoc;	struct sctp_endpoint *ep = NULL;	struct sctp_ep_common *rcvr;	struct sctp_transport *transport = NULL;	struct sctp_chunk *chunk;	struct sctphdr *sh;	union sctp_addr src;	union sctp_addr dest;	int family;	struct sctp_af *af; 	if (skb->pkt_type!=PACKET_HOST)		goto discard_it; 	SCTP_INC_STATS_BH(SCTP_MIB_INSCTPPACKS); 	if (skb_linearize(skb))		goto discard_it; 	sh = sctp_hdr(skb); 	/* Pull up the IP and SCTP headers. */	__skb_pull(skb, skb_transport_offset(skb));	if (skb->len < sizeof(struct sctphdr))		goto discard_it;	if (!sctp_checksum_disable && !skb_csum_unnecessary(skb) &&		  sctp_rcv_checksum(skb) < 0)		goto discard_it; 	skb_pull(skb, sizeof(struct sctphdr)); 	/* Make sure we at least have chunk headers worth of data left. */	if (skb->len < sizeof(struct sctp_chunkhdr))		goto discard_it; 	family = ipver2af(ip_hdr(skb)->version);	af = sctp_get_af_specific(family);	if (unlikely(!af))		goto discard_it; 	/* Initialize local addresses for lookups. */	af->from_skb(&src, skb, 1);	af->from_skb(&dest, skb, 0); 	/* If the packet is to or from a non-unicast address,	 * silently discard the packet.	 *	 * This is not clearly defined in the RFC except in section	 * 8.4 - OOTB handling.  However, based on the book "Stream Control	 * Transmission Protocol" 2.1, "It is important to note that the	 * IP address of an SCTP transport address must be a routable	 * unicast address.  In other words, IP multicast addresses and	 * IP broadcast addresses cannot be used in an SCTP transport	 * address."	 */	if (!af->addr_valid(&src, NULL, skb) ||	    !af->addr_valid(&dest, NULL, skb))		goto discard_it; 	asoc = __sctp_rcv_lookup(skb, &src, &dest, &transport); 	if (!asoc)		ep = __sctp_rcv_lookup_endpoint(&dest); 	/* Retrieve the common input handling substructure. */	rcvr = asoc ? &asoc->base : &ep->base;	sk = rcvr->sk; 	/*	 * If a frame arrives on an interface and the receiving socket is	 * bound to another interface, via SO_BINDTODEVICE, treat it as OOTB	 */	if (sk->sk_bound_dev_if && (sk->sk_bound_dev_if != af->skb_iif(skb)))	{		if (asoc) {			sctp_association_put(asoc);			asoc = NULL;		} else {			sctp_endpoint_put(ep);			ep = NULL;		}		sk = sctp_get_ctl_sock();		ep = sctp_sk(sk)->ep;		sctp_endpoint_hold(ep);		rcvr = &ep->base;	} 	/*	 * RFC 2960, 8.4 - Handle "Out of the blue" Packets.	 * An SCTP packet is called an "out of the blue" (OOTB)	 * packet if it is correctly formed, i.e., passed the	 * receiver's checksum check, but the receiver is not	 * able to identify the association to which this	 * packet belongs.	 */	if (!asoc) {		if (sctp_rcv_ootb(skb)) {			SCTP_INC_STATS_BH(SCTP_MIB_OUTOFBLUES);			goto discard_release;		}	} 	if (!xfrm_policy_check(sk, XFRM_POLICY_IN, skb, family))		goto discard_release;	nf_reset(skb); 	if (sk_filter(sk, skb))		goto discard_release; 	/* Create an SCTP packet structure. */	chunk = sctp_chunkify(skb, asoc, sk);	if (!chunk)		goto discard_release;	SCTP_INPUT_CB(skb)->chunk = chunk; 	/* Remember what endpoint is to handle this packet. */	chunk->rcvr = rcvr; 	/* Remember the SCTP header. */	chunk->sctp_hdr = sh; 	/* Set the source and destination addresses of the incoming chunk.  */	sctp_init_addrs(chunk, &src, &dest); 	/* Remember where we came from.  */	chunk->transport = transport; 	/* Acquire access to the sock lock. Note: We are safe from other	 * bottom halves on this lock, but a user may be in the lock too,	 * so check if it is busy.	 */	sctp_bh_lock_sock(sk); 	if (sk != rcvr->sk) {		/* Our cached sk is different from the rcvr->sk.  This is		 * because migrate()/accept() may have moved the association		 * to a new socket and released all the sockets.  So now we		 * are holding a lock on the old socket while the user may		 * be doing something with the new socket.  Switch our veiw		 * of the current sk.		 */		sctp_bh_unlock_sock(sk);		sk = rcvr->sk;		sctp_bh_lock_sock(sk);	} 	if (sock_owned_by_user(sk)) {		if (sctp_add_backlog(sk, skb)) {			sctp_bh_unlock_sock(sk);			sctp_chunk_free(chunk);			skb = NULL; /* sctp_chunk_free already freed the skb */			goto discard_release;		}		SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_BACKLOG);	} else {		SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_SOFTIRQ);		sctp_inq_push(&chunk->rcvr->inqueue, chunk);	} 	sctp_bh_unlock_sock(sk); 	/* Release the asoc/ep ref we took in the lookup calls. */	if (asoc)		sctp_association_put(asoc);	else		sctp_endpoint_put(ep); 	return 0; discard_it:	SCTP_INC_STATS_BH(SCTP_MIB_IN_PKT_DISCARDS);	kfree_skb(skb);	return 0; discard_release:	/* Release the asoc/ep ref we took in the lookup calls. */	if (asoc)		sctp_association_put(asoc);	else		sctp_endpoint_put(ep); 	goto discard_it;} /* Process the backlog queue of the socket.  Every skb on * the backlog holds a ref on an association or endpoint. * We hold this ref throughout the state machine to make * sure that the structure we need is still around. */int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb){	struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;	struct sctp_inq *inqueue = &chunk->rcvr->inqueue;	struct sctp_ep_common *rcvr = NULL;	int backloged = 0; 	rcvr = chunk->rcvr; 	/* If the rcvr is dead then the association or endpoint	 * has been deleted and we can safely drop the chunk	 * and refs that we are holding.	 */	if (rcvr->dead) {		sctp_chunk_free(chunk);		goto done;	} 	if (unlikely(rcvr->sk != sk)) {		/* In this case, the association moved from one socket to		 * another.  We are currently sitting on the backlog of the		 * old socket, so we need to move.		 * However, since we are here in the process context we		 * need to take make sure that the user doesn't own		 * the new socket when we process the packet.		 * If the new socket is user-owned, queue the chunk to the		 * backlog of the new socket without dropping any refs.		 * Otherwise, we can safely push the chunk on the inqueue.		 */ 		sk = rcvr->sk;		sctp_bh_lock_sock(sk); 		if (sock_owned_by_user(sk)) {			if (sk_add_backlog(sk, skb, sk->sk_rcvbuf))				sctp_chunk_free(chunk);			else				backloged = 1;		} else			sctp_inq_push(inqueue, chunk); 		sctp_bh_unlock_sock(sk); 		/* If the chunk was backloged again, don't drop refs */		if (backloged)			return 0;	} else {		sctp_inq_push(inqueue, chunk);	} done:	/* Release the refs we took in sctp_add_backlog */	if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)		sctp_association_put(sctp_assoc(rcvr));	else if (SCTP_EP_TYPE_SOCKET == rcvr->type)		sctp_endpoint_put(sctp_ep(rcvr));	else		BUG(); 	return 0;} static int sctp_add_backlog(struct sock *sk, struct sk_buff *skb){	struct sctp_chunk *chunk = SCTP_INPUT_CB(skb)->chunk;	struct sctp_ep_common *rcvr = chunk->rcvr;	int ret; 	ret = sk_add_backlog(sk, skb, sk->sk_rcvbuf);	if (!ret) {		/* Hold the assoc/ep while hanging on the backlog queue.		 * This way, we know structures we need will not disappear		 * from us		 */		if (SCTP_EP_TYPE_ASSOCIATION == rcvr->type)			sctp_association_hold(sctp_assoc(rcvr));		else if (SCTP_EP_TYPE_SOCKET == rcvr->type)			sctp_endpoint_hold(sctp_ep(rcvr));		else			BUG();	}	return ret; } /* Handle icmp frag needed error. */void sctp_icmp_frag_needed(struct sock *sk, struct sctp_association *asoc,			   struct sctp_transport *t, __u32 pmtu){	if (!t || (t->pathmtu <= pmtu))		return; 	if (sock_owned_by_user(sk)) {		asoc->pmtu_pending = 1;		t->pmtu_pending = 1;		return;	} 	if (t->param_flags & SPP_PMTUD_ENABLE) {		/* Update transports view of the MTU */		sctp_transport_update_pmtu(t, pmtu); 		/* Update association pmtu. */		sctp_assoc_sync_pmtu(asoc);	} 	/* Retransmit with the new pmtu setting.	 * Normally, if PMTU discovery is disabled, an ICMP Fragmentation	 * Needed will never be sent, but if a message was sent before	 * PMTU discovery was disabled that was larger than the PMTU, it	 * would not be fragmented, so it must be re-transmitted fragmented.	 */	sctp_retransmit(&asoc->outqueue, t, SCTP_RTXR_PMTUD);} /* * SCTP Implementer's Guide, 2.37 ICMP handling procedures * * ICMP8) If the ICMP code is a "Unrecognized next header type encountered" *        or a "Protocol Unreachable" treat this message as an abort *        with the T bit set. * * This function sends an event to the state machine, which will abort the * association. * */void sctp_icmp_proto_unreachable(struct sock *sk,			   struct sctp_association *asoc,			   struct sctp_transport *t){	SCTP_DEBUG_PRINTK("%s\n",  __func__); 	if (sock_owned_by_user(sk)) {		if (timer_pending(&t->proto_unreach_timer))			return;		else {			if (!mod_timer(&t->proto_unreach_timer,						jiffies + (HZ/20)))				sctp_association_hold(asoc);		}				} else {		if (timer_pending(&t->proto_unreach_timer) &&		    del_timer(&t->proto_unreach_timer))			sctp_association_put(asoc); 		sctp_do_sm(SCTP_EVENT_T_OTHER,			   SCTP_ST_OTHER(SCTP_EVENT_ICMP_PROTO_UNREACH),			   asoc->state, asoc->ep, asoc, t,			   GFP_ATOMIC);	}} /* Common lookup code for icmp/icmpv6 error handler. */struct sock *sctp_err_lookup(int family, struct sk_buff *skb,			     struct sctphdr *sctphdr,			     struct sctp_association **app,			     struct sctp_transport **tpp){	union sctp_addr saddr;	union sctp_addr daddr;	struct sctp_af *af;	struct sock *sk = NULL;	struct sctp_association *asoc;	struct sctp_transport *transport = NULL;	struct sctp_init_chunk *chunkhdr;	__u32 vtag = ntohl(sctphdr->vtag);	int len = skb->len - ((void *)sctphdr - (void *)skb->data); 	*app = NULL; *tpp = NULL; 	af = sctp_get_af_specific(family);	if (unlikely(!af)) {		return NULL;	} 	/* Initialize local addresses for lookups. */	af->from_skb(&saddr, skb, 1);	af->from_skb(&daddr, skb, 0); 	/* Look for an association that matches the incoming ICMP error	 * packet.	 */	asoc = __sctp_lookup_association(&saddr, &daddr, &transport);	if (!asoc)		return NULL; 	sk = asoc->base.sk; 	/* RFC 4960, Appendix C. ICMP Handling

Lines 1–500 of 1138. Load more