Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 161643660129dd7d98f0b12418c0a2710ffa7db6

Authored by Adrian Bunk 2006-09-18 15:40:38 +0800

Committed by David S. Miller 2006-09-23 06:19:03 +0800

Exists in master and in 7 other branches

[SCTP]: Cleanups

This patch contains the following cleanups:
- make the following needlessly global function static:
  - socket.c: sctp_apply_peer_addr_params()
- add proper prototypes for the several global functions in
  include/net/sctp/sctp.h

Note that this fixes wrong prototypes for the following functions:
- sctp_snmp_proc_exit()
- sctp_eps_proc_exit()
- sctp_assocs_proc_exit()

The latter was spotted by the GNU C compiler and reported
by David Woodhouse.

Signed-off-by: Adrian Bunk <bunk@stusta.de>
Acked-by: Sridhar Samudrala <sri@us.ibm.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 4 changed files with 20 additions and 15 deletions Inline Diff

include/net/sctp/sctp.h
net/sctp/ipv6.c
net/sctp/protocol.c
net/sctp/socket.c

include/net/sctp/sctp.h

Diff comments View file @ 1616436

 /* SCTP kernel reference Implementation
  * (C) Copyright IBM Corp. 2001, 2004
  * Copyright (c) 1999-2000 Cisco, Inc.
  * Copyright (c) 1999-2001 Motorola, Inc.
  * Copyright (c) 2001-2003 Intel Corp.
  *
  * This file is part of the SCTP kernel reference Implementation
  *
  * The base lksctp header.
  *
  * The SCTP reference 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.
  *
  * The SCTP reference 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>
  *    Xingang Guo           <xingang.guo@intel.com>
  *    Jon Grimm             <jgrimm@us.ibm.com>
  *    Daisy Chang           <daisyc@us.ibm.com>
  *    Sridhar Samudrala     <sri@us.ibm.com>
  *    Ardelle Fan           <ardelle.fan@intel.com>
  *    Ryan Layer            <rmlayer@us.ibm.com>
  *    Kevin Gao             <kevin.gao@intel.com>
  *
  * Any bugs reported given to us we will try to fix... any fixes shared will
  * be incorporated into the next SCTP release.
  */
 #ifndef __net_sctp_h__
 #define __net_sctp_h__
 /* Header Strategy.
  *    Start getting some control over the header file depencies:
  *       includes
  *       constants
  *       structs
  *       prototypes
  *       macros, externs, and inlines
  *
  *   Move test_frame specific items out of the kernel headers
  *   and into the test frame headers.   This is not perfect in any sense
  *   and will continue to evolve.
  */
 #ifdef TEST_FRAME
 #undef CONFIG_PROC_FS
 #undef CONFIG_SCTP_DBG_OBJCNT
 #undef CONFIG_SYSCTL
 #endif /* TEST_FRAME */
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/in.h>
 #include <linux/tty.h>
 #include <linux/proc_fs.h>
 #include <linux/spinlock.h>
 #include <linux/jiffies.h>
 #include <linux/idr.h>
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 #include <net/ipv6.h>
 #include <net/ip6_route.h>
 #endif
 #include <asm/uaccess.h>
 #include <asm/page.h>
 #include <net/sock.h>
 #include <net/snmp.h>
 #include <net/sctp/structs.h>
 #include <net/sctp/constants.h>
 /* Set SCTP_DEBUG flag via config if not already set. */
 #ifndef SCTP_DEBUG
 #ifdef CONFIG_SCTP_DBG_MSG
 #define SCTP_DEBUG	1
 #else
 #define SCTP_DEBUG      0
 #endif /* CONFIG_SCTP_DBG */
 #endif /* SCTP_DEBUG */
 #ifdef CONFIG_IP_SCTP_MODULE
 #define SCTP_PROTOSW_FLAG 0
 #else /* static! */
 #define SCTP_PROTOSW_FLAG INET_PROTOSW_PERMANENT
 #endif
 /* Certain internal static functions need to be exported when
  * compiled into the test frame.
  */
 #ifndef SCTP_STATIC
 #define SCTP_STATIC static
 #endif
 /*
  * Function declarations.
  */
 /*
  * sctp/protocol.c
  */
 extern struct sock *sctp_get_ctl_sock(void);
 extern int sctp_copy_local_addr_list(struct sctp_bind_addr *,
 				     sctp_scope_t, gfp_t gfp,
 				     int flags);
 extern struct sctp_pf *sctp_get_pf_specific(sa_family_t family);
 extern int sctp_register_pf(struct sctp_pf *, sa_family_t);
+int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
+                        void *ptr);
 /*
  * sctp/socket.c
  */
 int sctp_backlog_rcv(struct sock *sk, struct sk_buff *skb);
 int sctp_inet_listen(struct socket *sock, int backlog);
 void sctp_write_space(struct sock *sk);
 unsigned int sctp_poll(struct file *file, struct socket *sock,
 		poll_table *wait);
 /*
  * sctp/primitive.c
  */
 int sctp_primitive_ASSOCIATE(struct sctp_association *, void *arg);
 int sctp_primitive_SHUTDOWN(struct sctp_association *, void *arg);
 int sctp_primitive_ABORT(struct sctp_association *, void *arg);
 int sctp_primitive_SEND(struct sctp_association *, void *arg);
 int sctp_primitive_REQUESTHEARTBEAT(struct sctp_association *, void *arg);
 int sctp_primitive_ASCONF(struct sctp_association *, void *arg);
 /*
  * sctp/crc32c.c
  */
 __u32 sctp_start_cksum(__u8 *ptr, __u16 count);
 __u32 sctp_update_cksum(__u8 *ptr, __u16 count, __u32 cksum);
 __u32 sctp_end_cksum(__u32 cksum);
 __u32 sctp_update_copy_cksum(__u8 *, __u8 *, __u16 count, __u32 cksum);
 /*
  * sctp/input.c
  */
 int sctp_rcv(struct sk_buff *skb);
 void sctp_v4_err(struct sk_buff *skb, u32 info);
 void sctp_hash_established(struct sctp_association *);
 void sctp_unhash_established(struct sctp_association *);
 void sctp_hash_endpoint(struct sctp_endpoint *);
 void sctp_unhash_endpoint(struct sctp_endpoint *);
 struct sock *sctp_err_lookup(int family, struct sk_buff *,
 			     struct sctphdr *, struct sctp_association **,
 			     struct sctp_transport **);
 void sctp_err_finish(struct sock *, struct sctp_association *);
 void sctp_icmp_frag_needed(struct sock *, struct sctp_association *,
 			   struct sctp_transport *t, __u32 pmtu);
 void sctp_icmp_proto_unreachable(struct sock *sk,
 				 struct sctp_association *asoc,
 				 struct sctp_transport *t);
 void sctp_backlog_migrate(struct sctp_association *assoc,
 			  struct sock *oldsk, struct sock *newsk);
+/*
+ * sctp/proc.c
+ */
+int sctp_snmp_proc_init(void);
+void sctp_snmp_proc_exit(void);
+int sctp_eps_proc_init(void);
+void sctp_eps_proc_exit(void);
+int sctp_assocs_proc_init(void);
+void sctp_assocs_proc_exit(void);
 /*
  *  Section:  Macros, externs, and inlines
  */
 #ifdef TEST_FRAME
 #include <test_frame.h>
 #else
 /* spin lock wrappers. */
 #define sctp_spin_lock_irqsave(lock, flags) spin_lock_irqsave(lock, flags)
 #define sctp_spin_unlock_irqrestore(lock, flags)  \
        spin_unlock_irqrestore(lock, flags)
 #define sctp_local_bh_disable() local_bh_disable()
 #define sctp_local_bh_enable()  local_bh_enable()
 #define sctp_spin_lock(lock)    spin_lock(lock)
 #define sctp_spin_unlock(lock)  spin_unlock(lock)
 #define sctp_write_lock(lock)   write_lock(lock)
 #define sctp_write_unlock(lock) write_unlock(lock)
 #define sctp_read_lock(lock)    read_lock(lock)
 #define sctp_read_unlock(lock)  read_unlock(lock)
 /* sock lock wrappers. */
 #define sctp_lock_sock(sk)       lock_sock(sk)
 #define sctp_release_sock(sk)    release_sock(sk)
 #define sctp_bh_lock_sock(sk)    bh_lock_sock(sk)
 #define sctp_bh_unlock_sock(sk)  bh_unlock_sock(sk)
 #define SCTP_SOCK_SLEEP_PRE(sk)  SOCK_SLEEP_PRE(sk)
 #define SCTP_SOCK_SLEEP_POST(sk) SOCK_SLEEP_POST(sk)
 /* SCTP SNMP MIB stats handlers */
 DECLARE_SNMP_STAT(struct sctp_mib, sctp_statistics);
 #define SCTP_INC_STATS(field)      SNMP_INC_STATS(sctp_statistics, field)
 #define SCTP_INC_STATS_BH(field)   SNMP_INC_STATS_BH(sctp_statistics, field)
 #define SCTP_INC_STATS_USER(field) SNMP_INC_STATS_USER(sctp_statistics, field)
 #define SCTP_DEC_STATS(field)      SNMP_DEC_STATS(sctp_statistics, field)
 #endif /* !TEST_FRAME */
 /* sctp mib definitions */
 enum
 {
 	SCTP_MIB_NUM = 0,
 	SCTP_MIB_CURRESTAB,			/* CurrEstab */
 	SCTP_MIB_ACTIVEESTABS,			/* ActiveEstabs */
 	SCTP_MIB_PASSIVEESTABS,			/* PassiveEstabs */
 	SCTP_MIB_ABORTEDS,			/* Aborteds */
 	SCTP_MIB_SHUTDOWNS,			/* Shutdowns */
 	SCTP_MIB_OUTOFBLUES,			/* OutOfBlues */
 	SCTP_MIB_CHECKSUMERRORS,		/* ChecksumErrors */
 	SCTP_MIB_OUTCTRLCHUNKS,			/* OutCtrlChunks */
 	SCTP_MIB_OUTORDERCHUNKS,		/* OutOrderChunks */
 	SCTP_MIB_OUTUNORDERCHUNKS,		/* OutUnorderChunks */
 	SCTP_MIB_INCTRLCHUNKS,			/* InCtrlChunks */
 	SCTP_MIB_INORDERCHUNKS,			/* InOrderChunks */
 	SCTP_MIB_INUNORDERCHUNKS,		/* InUnorderChunks */
 	SCTP_MIB_FRAGUSRMSGS,			/* FragUsrMsgs */
 	SCTP_MIB_REASMUSRMSGS,			/* ReasmUsrMsgs */
 	SCTP_MIB_OUTSCTPPACKS,			/* OutSCTPPacks */
 	SCTP_MIB_INSCTPPACKS,			/* InSCTPPacks */
 	SCTP_MIB_T1_INIT_EXPIREDS,
 	SCTP_MIB_T1_COOKIE_EXPIREDS,
 	SCTP_MIB_T2_SHUTDOWN_EXPIREDS,
 	SCTP_MIB_T3_RTX_EXPIREDS,
 	SCTP_MIB_T4_RTO_EXPIREDS,
 	SCTP_MIB_T5_SHUTDOWN_GUARD_EXPIREDS,
 	SCTP_MIB_DELAY_SACK_EXPIREDS,
 	SCTP_MIB_AUTOCLOSE_EXPIREDS,
 	SCTP_MIB_T3_RETRANSMITS,
 	SCTP_MIB_PMTUD_RETRANSMITS,
 	SCTP_MIB_FAST_RETRANSMITS,
 	SCTP_MIB_IN_PKT_SOFTIRQ,
 	SCTP_MIB_IN_PKT_BACKLOG,
 	SCTP_MIB_IN_PKT_DISCARDS,
 	SCTP_MIB_IN_DATA_CHUNK_DISCARDS,
 	__SCTP_MIB_MAX
 };
 #define SCTP_MIB_MAX    __SCTP_MIB_MAX
 struct sctp_mib {
         unsigned long   mibs[SCTP_MIB_MAX];
 } __SNMP_MIB_ALIGN__;
 /* Print debugging messages.  */
 #if SCTP_DEBUG
 extern int sctp_debug_flag;
 #define SCTP_DEBUG_PRINTK(whatever...) \
 	((void) (sctp_debug_flag && printk(KERN_DEBUG whatever)))
 #define SCTP_DEBUG_PRINTK_IPADDR(lead, trail, leadparm, saddr, otherparms...) \
 	if (sctp_debug_flag) { \
 		if (saddr->sa.sa_family == AF_INET6) { \
 			printk(KERN_DEBUG \
 			       lead NIP6_FMT trail, \
 			       leadparm, \
 			       NIP6(saddr->v6.sin6_addr), \
 			       otherparms); \
 		} else { \
 			printk(KERN_DEBUG \
 			       lead NIPQUAD_FMT trail, \
 			       leadparm, \
 			       NIPQUAD(saddr->v4.sin_addr.s_addr), \
 			       otherparms); \
 		} \
 	}
 #define SCTP_ENABLE_DEBUG { sctp_debug_flag = 1; }
 #define SCTP_DISABLE_DEBUG { sctp_debug_flag = 0; }
 #define SCTP_ASSERT(expr, str, func) \
 	if (!(expr)) { \
 		SCTP_DEBUG_PRINTK("Assertion Failed: %s(%s) at %s:%s:%d\n", \
 			str, (#expr), __FILE__, __FUNCTION__, __LINE__); \
 		func; \
 	}
 #else	/* SCTP_DEBUG */
 #define SCTP_DEBUG_PRINTK(whatever...)
 #define SCTP_DEBUG_PRINTK_IPADDR(whatever...)
 #define SCTP_ENABLE_DEBUG
 #define SCTP_DISABLE_DEBUG
 #define SCTP_ASSERT(expr, str, func)
 #endif /* SCTP_DEBUG */
 /*
  * Macros for keeping a global reference of object allocations.
  */
 #ifdef CONFIG_SCTP_DBG_OBJCNT
 extern atomic_t sctp_dbg_objcnt_sock;
 extern atomic_t sctp_dbg_objcnt_ep;
 extern atomic_t sctp_dbg_objcnt_assoc;
 extern atomic_t sctp_dbg_objcnt_transport;
 extern atomic_t sctp_dbg_objcnt_chunk;
 extern atomic_t sctp_dbg_objcnt_bind_addr;
 extern atomic_t sctp_dbg_objcnt_bind_bucket;
 extern atomic_t sctp_dbg_objcnt_addr;
 extern atomic_t sctp_dbg_objcnt_ssnmap;
 extern atomic_t sctp_dbg_objcnt_datamsg;
 /* Macros to atomically increment/decrement objcnt counters.  */
 #define SCTP_DBG_OBJCNT_INC(name) \
 atomic_inc(&sctp_dbg_objcnt_## name)
 #define SCTP_DBG_OBJCNT_DEC(name) \
 atomic_dec(&sctp_dbg_objcnt_## name)
 #define SCTP_DBG_OBJCNT(name) \
 atomic_t sctp_dbg_objcnt_## name = ATOMIC_INIT(0)
 /* Macro to help create new entries in in the global array of
  * objcnt counters.
  */
 #define SCTP_DBG_OBJCNT_ENTRY(name) \
 {.label= #name, .counter= &sctp_dbg_objcnt_## name}
 void sctp_dbg_objcnt_init(void);
 void sctp_dbg_objcnt_exit(void);
 #else
 #define SCTP_DBG_OBJCNT_INC(name)
 #define SCTP_DBG_OBJCNT_DEC(name)
 static inline void sctp_dbg_objcnt_init(void) { return; }
 static inline void sctp_dbg_objcnt_exit(void) { return; }
 #endif /* CONFIG_SCTP_DBG_OBJCOUNT */
 #if defined CONFIG_SYSCTL
 void sctp_sysctl_register(void);
 void sctp_sysctl_unregister(void);
 #else
 static inline void sctp_sysctl_register(void) { return; }
 static inline void sctp_sysctl_unregister(void) { return; }
 static inline int sctp_sysctl_jiffies_ms(ctl_table *table, int __user *name, int nlen,
 		void __user *oldval, size_t __user *oldlenp,
 		void __user *newval, size_t newlen, void **context) {
 	return -ENOSYS;
 }
 #endif
 /* Size of Supported Address Parameter for 'x' address types. */
 #define SCTP_SAT_LEN(x) (sizeof(struct sctp_paramhdr) + (x) * sizeof(__u16))
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 int sctp_v6_init(void);
 void sctp_v6_exit(void);
 #else /* #ifdef defined(CONFIG_IPV6) */
 static inline int sctp_v6_init(void) { return 0; }
 static inline void sctp_v6_exit(void) { return; }
 #endif /* #if defined(CONFIG_IPV6) */
 /* Map an association to an assoc_id. */
 static inline sctp_assoc_t sctp_assoc2id(const struct sctp_association *asoc)
 {
 	return (asoc?asoc->assoc_id:0);
 }
 /* Look up the association by its id.  */
 struct sctp_association *sctp_id2assoc(struct sock *sk, sctp_assoc_t id);
 /* A macro to walk a list of skbs.  */
 #define sctp_skb_for_each(pos, head, tmp) \
 for (pos = (head)->next;\
      tmp = (pos)->next, pos != ((struct sk_buff *)(head));\
      pos = tmp)
 /* A helper to append an entire skb list (list) to another (head). */
 static inline void sctp_skb_list_tail(struct sk_buff_head *list,
 				      struct sk_buff_head *head)
 {
 	unsigned long flags;
 	sctp_spin_lock_irqsave(&head->lock, flags);
 	sctp_spin_lock(&list->lock);
 	list_splice((struct list_head *)list, (struct list_head *)head->prev);
 	head->qlen += list->qlen;
 	list->qlen = 0;
 	sctp_spin_unlock(&list->lock);
 	sctp_spin_unlock_irqrestore(&head->lock, flags);
 }
 /**
  *	sctp_list_dequeue - remove from the head of the queue
  *	@list: list to dequeue from
  *
  *	Remove the head of the list. The head item is
  *	returned or %NULL if the list is empty.
  */
 static inline struct list_head *sctp_list_dequeue(struct list_head *list)
 {
 	struct list_head *result = NULL;
 	if (list->next != list) {
 		result = list->next;
 		list->next = result->next;
 		list->next->prev = list;
 		INIT_LIST_HEAD(result);
 	}
 	return result;
 }
 /* Tests if the list has one and only one entry. */
 static inline int sctp_list_single_entry(struct list_head *head)
 {
 	return ((head->next != head) && (head->next == head->prev));
 }
 /* Generate a random jitter in the range of -50% ~ +50% of input RTO. */
 static inline __s32 sctp_jitter(__u32 rto)
 {
 	static __u32 sctp_rand;
 	__s32 ret;
 	/* Avoid divide by zero. */
 	if (!rto)
 		rto = 1;
 	sctp_rand += jiffies;
 	sctp_rand ^= (sctp_rand << 12);
 	sctp_rand ^= (sctp_rand >> 20);
 	/* Choose random number from 0 to rto, then move to -50% ~ +50%
 	 * of rto.
 	 */
 	ret = sctp_rand % rto - (rto >> 1);
 	return ret;
 }
 /* Break down data chunks at this point.  */
 static inline int sctp_frag_point(const struct sctp_sock *sp, int pmtu)
 {
 	int frag = pmtu;
 	frag -= sp->pf->af->net_header_len;
 	frag -= sizeof(struct sctphdr) + sizeof(struct sctp_data_chunk);
 	if (sp->user_frag)
 		frag = min_t(int, frag, sp->user_frag);
 	frag = min_t(int, frag, SCTP_MAX_CHUNK_LEN);
 	return frag;
 }
 /* Walk through a list of TLV parameters.  Don't trust the
  * individual parameter lengths and instead depend on
  * the chunk length to indicate when to stop.  Make sure
  * there is room for a param header too.
  */
 #define sctp_walk_params(pos, chunk, member)\
 _sctp_walk_params((pos), (chunk), ntohs((chunk)->chunk_hdr.length), member)
 #define _sctp_walk_params(pos, chunk, end, member)\
 for (pos.v = chunk->member;\
      pos.v <= (void *)chunk + end - sizeof(sctp_paramhdr_t) &&\
      pos.v <= (void *)chunk + end - ntohs(pos.p->length) &&\
      ntohs(pos.p->length) >= sizeof(sctp_paramhdr_t);\
      pos.v += WORD_ROUND(ntohs(pos.p->length)))
 #define sctp_walk_errors(err, chunk_hdr)\
 _sctp_walk_errors((err), (chunk_hdr), ntohs((chunk_hdr)->length))
 #define _sctp_walk_errors(err, chunk_hdr, end)\
 for (err = (sctp_errhdr_t *)((void *)chunk_hdr + \
 	    sizeof(sctp_chunkhdr_t));\
      (void *)err <= (void *)chunk_hdr + end - sizeof(sctp_errhdr_t) &&\
      (void *)err <= (void *)chunk_hdr + end - ntohs(err->length) &&\
      ntohs(err->length) >= sizeof(sctp_errhdr_t); \
      err = (sctp_errhdr_t *)((void *)err + WORD_ROUND(ntohs(err->length))))
 #define sctp_walk_fwdtsn(pos, chunk)\
 _sctp_walk_fwdtsn((pos), (chunk), ntohs((chunk)->chunk_hdr->length) - sizeof(struct sctp_fwdtsn_chunk))
 #define _sctp_walk_fwdtsn(pos, chunk, end)\
 for (pos = chunk->subh.fwdtsn_hdr->skip;\
      (void *)pos <= (void *)chunk->subh.fwdtsn_hdr->skip + end - sizeof(struct sctp_fwdtsn_skip);\
      pos++)
 /* Round an int up to the next multiple of 4.  */
 #define WORD_ROUND(s) (((s)+3)&~3)
 /* Make a new instance of type.  */
 #define t_new(type, flags)	(type *)kmalloc(sizeof(type), flags)
 /* Compare two timevals.  */
 #define tv_lt(s, t) \
    (s.tv_sec < t.tv_sec || (s.tv_sec == t.tv_sec && s.tv_usec < t.tv_usec))
 /* Add tv1 to tv2. */
 #define TIMEVAL_ADD(tv1, tv2) \
 ({ \
         suseconds_t usecs = (tv2).tv_usec + (tv1).tv_usec; \
         time_t secs = (tv2).tv_sec + (tv1).tv_sec; \
 \
         if (usecs >= 1000000) { \
                 usecs -= 1000000; \
                 secs++; \
         } \
         (tv2).tv_sec = secs; \
         (tv2).tv_usec = usecs; \
 })
 /* External references. */
 extern struct proto sctp_prot;
 extern struct proto sctpv6_prot;
 extern struct proc_dir_entry *proc_net_sctp;
 void sctp_put_port(struct sock *sk);
 extern struct idr sctp_assocs_id;
 extern spinlock_t sctp_assocs_id_lock;
 /* Static inline functions. */
 /* Convert from an IP version number to an Address Family symbol.  */
 static inline int ipver2af(__u8 ipver)
 {
 	switch (ipver) {
 	case 4:
 	        return  AF_INET;
 	case 6:
 		return AF_INET6;
 	default:
 		return 0;
 	};
 }
 /* Convert from an address parameter type to an address family.  */
 static inline int param_type2af(__u16 type)
 {
 	switch (type) {
 	case SCTP_PARAM_IPV4_ADDRESS:
 	        return  AF_INET;
 	case SCTP_PARAM_IPV6_ADDRESS:
 		return AF_INET6;
 	default:
 		return 0;
 	};
 }
 /* Perform some sanity checks. */
 static inline int sctp_sanity_check(void)
 {
 	SCTP_ASSERT(sizeof(struct sctp_ulpevent) <=
 		    sizeof(((struct sk_buff *)0)->cb),
 		    "SCTP: ulpevent does not fit in skb!\n", return 0);
 	return 1;
 }
 /* Warning: The following hash functions assume a power of two 'size'. */
 /* This is the hash function for the SCTP port hash table. */
 static inline int sctp_phashfn(__u16 lport)
 {
 	return (lport & (sctp_port_hashsize - 1));
 }
 /* This is the hash function for the endpoint hash table. */
 static inline int sctp_ep_hashfn(__u16 lport)
 {
 	return (lport & (sctp_ep_hashsize - 1));
 }
 /* This is the hash function for the association hash table. */
 static inline int sctp_assoc_hashfn(__u16 lport, __u16 rport)
 {
 	int h = (lport << 16) + rport;
 	h ^= h>>8;
 	return (h & (sctp_assoc_hashsize - 1));
 }
 /* This is the hash function for the association hash table.  This is
  * not used yet, but could be used as a better hash function when
  * we have a vtag.
  */
 static inline int sctp_vtag_hashfn(__u16 lport, __u16 rport, __u32 vtag)
 {
 	int h = (lport << 16) + rport;
 	h ^= vtag;
 	return (h & (sctp_assoc_hashsize-1));
 }
 /* Is a socket of this style? */
 #define sctp_style(sk, style) __sctp_style((sk), (SCTP_SOCKET_##style))
 static inline int __sctp_style(const struct sock *sk, sctp_socket_type_t style)
 {
 	return sctp_sk(sk)->type == style;
 }
 /* Is the association in this state? */
 #define sctp_state(asoc, state) __sctp_state((asoc), (SCTP_STATE_##state))
 static inline int __sctp_state(const struct sctp_association *asoc,
 			       sctp_state_t state)
 {
 	return asoc->state == state;
 }
 /* Is the socket in this state? */
 #define sctp_sstate(sk, state) __sctp_sstate((sk), (SCTP_SS_##state))
 static inline int __sctp_sstate(const struct sock *sk, sctp_sock_state_t state)
 {
 	return sk->sk_state == state;
 }
 /* Map v4-mapped v6 address back to v4 address */
 static inline void sctp_v6_map_v4(union sctp_addr *addr)
 {
 	addr->v4.sin_family = AF_INET;
 	addr->v4.sin_port = addr->v6.sin6_port;
 	addr->v4.sin_addr.s_addr = addr->v6.sin6_addr.s6_addr32[3];
 }
 /* Map v4 address to v4-mapped v6 address */
 static inline void sctp_v4_map_v6(union sctp_addr *addr)
 {
 	addr->v6.sin6_family = AF_INET6;
 	addr->v6.sin6_port = addr->v4.sin_port;
 	addr->v6.sin6_addr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
 	addr->v6.sin6_addr.s6_addr32[0] = 0;
 	addr->v6.sin6_addr.s6_addr32[1] = 0;
 	addr->v6.sin6_addr.s6_addr32[2] = htonl(0x0000ffff);
 }
 #endif /* __net_sctp_h__ */

net/sctp/ipv6.c

Diff comments View file @ 1616436

 /* SCTP kernel reference Implementation
  * (C) Copyright IBM Corp. 2002, 2004
  * Copyright (c) 2001 Nokia, Inc.
  * Copyright (c) 2001 La Monte H.P. Yarroll
  * Copyright (c) 2002-2003 Intel Corp.
  *
  * This file is part of the SCTP kernel reference Implementation
  *
  * SCTP over IPv6.
  *
  * The SCTP reference 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.
  *
  * The SCTP reference 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:
  *    Le Yanqun		    <yanqun.le@nokia.com>
  *    Hui Huang		    <hui.huang@nokia.com>
  *    La Monte H.P. Yarroll <piggy@acm.org>
  *    Sridhar Samudrala	    <sri@us.ibm.com>
  *    Jon Grimm		    <jgrimm@us.ibm.com>
  *    Ardelle Fan	    <ardelle.fan@intel.com>
  *
  * Based on:
  *	linux/net/ipv6/tcp_ipv6.c
  *
  * Any bugs reported given to us we will try to fix... any fixes shared will
  * be incorporated into the next SCTP release.
  */
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/net.h>
 #include <linux/sched.h>
 #include <linux/in.h>
 #include <linux/in6.h>
 #include <linux/netdevice.h>
 #include <linux/init.h>
 #include <linux/ipsec.h>
 #include <linux/ipv6.h>
 #include <linux/icmpv6.h>
 #include <linux/random.h>
 #include <linux/seq_file.h>
 #include <net/protocol.h>
 #include <net/ndisc.h>
 #include <net/ip.h>
 #include <net/ipv6.h>
 #include <net/transp_v6.h>
 #include <net/addrconf.h>
 #include <net/ip6_route.h>
 #include <net/inet_common.h>
 #include <net/inet_ecn.h>
 #include <net/sctp/sctp.h>
 #include <asm/uaccess.h>
-extern int sctp_inetaddr_event(struct notifier_block *, unsigned long, void *);
 static struct notifier_block sctp_inet6addr_notifier = {
 	.notifier_call = sctp_inetaddr_event,
 };
 /* ICMP error handler. */
 SCTP_STATIC void sctp_v6_err(struct sk_buff *skb, struct inet6_skb_parm *opt,
 			     int type, int code, int offset, __u32 info)
 {
 	struct inet6_dev *idev;
 	struct ipv6hdr *iph = (struct ipv6hdr *)skb->data;
 	struct sctphdr *sh = (struct sctphdr *)(skb->data + offset);
 	struct sock *sk;
 	struct sctp_association *asoc;
 	struct sctp_transport *transport;
 	struct ipv6_pinfo *np;
 	char *saveip, *savesctp;
 	int err;
 	idev = in6_dev_get(skb->dev);
 	/* Fix up skb to look at the embedded net header. */
 	saveip = skb->nh.raw;
 	savesctp  = skb->h.raw;
 	skb->nh.ipv6h = iph;
 	skb->h.raw = (char *)sh;
 	sk = sctp_err_lookup(AF_INET6, skb, sh, &asoc, &transport);
 	/* Put back, the original pointers. */
 	skb->nh.raw = saveip;
 	skb->h.raw = savesctp;
 	if (!sk) {
 		ICMP6_INC_STATS_BH(idev, ICMP6_MIB_INERRORS);
 		goto out;
 	}
 	/* Warning:  The sock lock is held.  Remember to call
 	 * sctp_err_finish!
 	 */
 	switch (type) {
 	case ICMPV6_PKT_TOOBIG:
 		sctp_icmp_frag_needed(sk, asoc, transport, ntohl(info));
 		goto out_unlock;
 	case ICMPV6_PARAMPROB:
 		if (ICMPV6_UNK_NEXTHDR == code) {
 			sctp_icmp_proto_unreachable(sk, asoc, transport);
 			goto out_unlock;
 		}
 		break;
 	default:
 		break;
 	}
 	np = inet6_sk(sk);
 	icmpv6_err_convert(type, code, &err);
 	if (!sock_owned_by_user(sk) && np->recverr) {
 		sk->sk_err = err;
 		sk->sk_error_report(sk);
 	} else {  /* Only an error on timeout */
 		sk->sk_err_soft = err;
 	}
 out_unlock:
 	sctp_err_finish(sk, asoc);
 out:
 	if (likely(idev != NULL))
 		in6_dev_put(idev);
 }
 /* Based on tcp_v6_xmit() in tcp_ipv6.c. */
 static int sctp_v6_xmit(struct sk_buff *skb, struct sctp_transport *transport,
 			int ipfragok)
 {
 	struct sock *sk = skb->sk;
 	struct ipv6_pinfo *np = inet6_sk(sk);
 	struct flowi fl;
 	memset(&fl, 0, sizeof(fl));
 	fl.proto = sk->sk_protocol;
 	/* Fill in the dest address from the route entry passed with the skb
 	 * and the source address from the transport.
 	 */
 	ipv6_addr_copy(&fl.fl6_dst, &transport->ipaddr.v6.sin6_addr);
 	ipv6_addr_copy(&fl.fl6_src, &transport->saddr.v6.sin6_addr);
 	fl.fl6_flowlabel = np->flow_label;
 	IP6_ECN_flow_xmit(sk, fl.fl6_flowlabel);
 	if (ipv6_addr_type(&fl.fl6_src) & IPV6_ADDR_LINKLOCAL)
 		fl.oif = transport->saddr.v6.sin6_scope_id;
 	else
 		fl.oif = sk->sk_bound_dev_if;
 	fl.fl_ip_sport = inet_sk(sk)->sport;
 	fl.fl_ip_dport = transport->ipaddr.v6.sin6_port;
 	if (np->opt && np->opt->srcrt) {
 		struct rt0_hdr *rt0 = (struct rt0_hdr *) np->opt->srcrt;
 		ipv6_addr_copy(&fl.fl6_dst, rt0->addr);
 	}
 	SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, "
 			  "src:" NIP6_FMT " dst:" NIP6_FMT "\n",
 			  __FUNCTION__, skb, skb->len,
 			  NIP6(fl.fl6_src), NIP6(fl.fl6_dst));
 	SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
 	return ip6_xmit(sk, skb, &fl, np->opt, ipfragok);
 }
 /* Returns the dst cache entry for the given source and destination ip
  * addresses.
  */
 static struct dst_entry *sctp_v6_get_dst(struct sctp_association *asoc,
 					 union sctp_addr *daddr,
 					 union sctp_addr *saddr)
 {
 	struct dst_entry *dst;
 	struct flowi fl;
 	memset(&fl, 0, sizeof(fl));
 	ipv6_addr_copy(&fl.fl6_dst, &daddr->v6.sin6_addr);
 	if (ipv6_addr_type(&daddr->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
 		fl.oif = daddr->v6.sin6_scope_id;
 	SCTP_DEBUG_PRINTK("%s: DST=" NIP6_FMT " ",
 			  __FUNCTION__, NIP6(fl.fl6_dst));
 	if (saddr) {
 		ipv6_addr_copy(&fl.fl6_src, &saddr->v6.sin6_addr);
 		SCTP_DEBUG_PRINTK(
 			"SRC=" NIP6_FMT " - ",
 			NIP6(fl.fl6_src));
 	}
 	dst = ip6_route_output(NULL, &fl);
 	if (dst) {
 		struct rt6_info *rt;
 		rt = (struct rt6_info *)dst;
 		SCTP_DEBUG_PRINTK(
 			"rt6_dst:" NIP6_FMT " rt6_src:" NIP6_FMT "\n",
 			NIP6(rt->rt6i_dst.addr), NIP6(rt->rt6i_src.addr));
 	} else {
 		SCTP_DEBUG_PRINTK("NO ROUTE\n");
 	}
 	return dst;
 }
 /* Returns the number of consecutive initial bits that match in the 2 ipv6
  * addresses.
  */
 static inline int sctp_v6_addr_match_len(union sctp_addr *s1,
 					 union sctp_addr *s2)
 {
 	struct in6_addr *a1 = &s1->v6.sin6_addr;
 	struct in6_addr *a2 = &s2->v6.sin6_addr;
 	int i, j;
 	for (i = 0; i < 4 ; i++) {
 		__u32 a1xora2;
 		a1xora2 = a1->s6_addr32[i] ^ a2->s6_addr32[i];
 		if ((j = fls(ntohl(a1xora2))))
 			return (i * 32 + 32 - j);
 	}
 	return (i*32);
 }
 /* Fills in the source address(saddr) based on the destination address(daddr)
  * and asoc's bind address list.
  */
 static void sctp_v6_get_saddr(struct sctp_association *asoc,
 			      struct dst_entry *dst,
 			      union sctp_addr *daddr,
 			      union sctp_addr *saddr)
 {
 	struct sctp_bind_addr *bp;
 	rwlock_t *addr_lock;
 	struct sctp_sockaddr_entry *laddr;
 	struct list_head *pos;
 	sctp_scope_t scope;
 	union sctp_addr *baddr = NULL;
 	__u8 matchlen = 0;
 	__u8 bmatchlen;
 	SCTP_DEBUG_PRINTK("%s: asoc:%p dst:%p "
 			  "daddr:" NIP6_FMT " ",
 			  __FUNCTION__, asoc, dst, NIP6(daddr->v6.sin6_addr));
 	if (!asoc) {
 		ipv6_get_saddr(dst, &daddr->v6.sin6_addr,&saddr->v6.sin6_addr);
 		SCTP_DEBUG_PRINTK("saddr from ipv6_get_saddr: " NIP6_FMT "\n",
 				  NIP6(saddr->v6.sin6_addr));
 		return;
 	}
 	scope = sctp_scope(daddr);
 	bp = &asoc->base.bind_addr;
 	addr_lock = &asoc->base.addr_lock;
 	/* Go through the bind address list and find the best source address
 	 * that matches the scope of the destination address.
 	 */
 	sctp_read_lock(addr_lock);
 	list_for_each(pos, &bp->address_list) {
 		laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
 		if ((laddr->use_as_src) &&
 		    (laddr->a.sa.sa_family == AF_INET6) &&
 		    (scope <= sctp_scope(&laddr->a))) {
 			bmatchlen = sctp_v6_addr_match_len(daddr, &laddr->a);
 			if (!baddr || (matchlen < bmatchlen)) {
 				baddr = &laddr->a;
 				matchlen = bmatchlen;
 			}
 		}
 	}
 	if (baddr) {
 		memcpy(saddr, baddr, sizeof(union sctp_addr));
 		SCTP_DEBUG_PRINTK("saddr: " NIP6_FMT "\n",
 				  NIP6(saddr->v6.sin6_addr));
 	} else {
 		printk(KERN_ERR "%s: asoc:%p Could not find a valid source "
 		       "address for the dest:" NIP6_FMT "\n",
 		       __FUNCTION__, asoc, NIP6(daddr->v6.sin6_addr));
 	}
 	sctp_read_unlock(addr_lock);
 }
 /* Make a copy of all potential local addresses. */
 static void sctp_v6_copy_addrlist(struct list_head *addrlist,
 				  struct net_device *dev)
 {
 	struct inet6_dev *in6_dev;
 	struct inet6_ifaddr *ifp;
 	struct sctp_sockaddr_entry *addr;
 	read_lock(&addrconf_lock);
 	if ((in6_dev = __in6_dev_get(dev)) == NULL) {
 		read_unlock(&addrconf_lock);
 		return;
 	}
 	read_lock(&in6_dev->lock);
 	for (ifp = in6_dev->addr_list; ifp; ifp = ifp->if_next) {
 		/* Add the address to the local list.  */
 		addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
 		if (addr) {
 			addr->a.v6.sin6_family = AF_INET6;
 			addr->a.v6.sin6_port = 0;
 			addr->a.v6.sin6_addr = ifp->addr;
 			addr->a.v6.sin6_scope_id = dev->ifindex;
 			INIT_LIST_HEAD(&addr->list);
 			list_add_tail(&addr->list, addrlist);
 		}
 	}
 	read_unlock(&in6_dev->lock);
 	read_unlock(&addrconf_lock);
 }
 /* Initialize a sockaddr_storage from in incoming skb. */
 static void sctp_v6_from_skb(union sctp_addr *addr,struct sk_buff *skb,
 			     int is_saddr)
 {
 	void *from;
 	__u16 *port;
 	struct sctphdr *sh;
 	port = &addr->v6.sin6_port;
 	addr->v6.sin6_family = AF_INET6;
 	addr->v6.sin6_flowinfo = 0; /* FIXME */
 	addr->v6.sin6_scope_id = ((struct inet6_skb_parm *)skb->cb)->iif;
 	sh = (struct sctphdr *) skb->h.raw;
 	if (is_saddr) {
 		*port  = ntohs(sh->source);
 		from = &skb->nh.ipv6h->saddr;
 	} else {
 		*port = ntohs(sh->dest);
 		from = &skb->nh.ipv6h->daddr;
 	}
 	ipv6_addr_copy(&addr->v6.sin6_addr, from);
 }
 /* Initialize an sctp_addr from a socket. */
 static void sctp_v6_from_sk(union sctp_addr *addr, struct sock *sk)
 {
 	addr->v6.sin6_family = AF_INET6;
 	addr->v6.sin6_port = inet_sk(sk)->num;
 	addr->v6.sin6_addr = inet6_sk(sk)->rcv_saddr;
 }
 /* Initialize sk->sk_rcv_saddr from sctp_addr. */
 static void sctp_v6_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
 {
 	if (addr->sa.sa_family == AF_INET && sctp_sk(sk)->v4mapped) {
 		inet6_sk(sk)->rcv_saddr.s6_addr32[0] = 0;
 		inet6_sk(sk)->rcv_saddr.s6_addr32[1] = 0;
 		inet6_sk(sk)->rcv_saddr.s6_addr32[2] = htonl(0x0000ffff);
 		inet6_sk(sk)->rcv_saddr.s6_addr32[3] =
 			addr->v4.sin_addr.s_addr;
 	} else {
 		inet6_sk(sk)->rcv_saddr = addr->v6.sin6_addr;
 	}
 }
 /* Initialize sk->sk_daddr from sctp_addr. */
 static void sctp_v6_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
 {
 	if (addr->sa.sa_family == AF_INET && sctp_sk(sk)->v4mapped) {
 		inet6_sk(sk)->daddr.s6_addr32[0] = 0;
 		inet6_sk(sk)->daddr.s6_addr32[1] = 0;
 		inet6_sk(sk)->daddr.s6_addr32[2] = htonl(0x0000ffff);
 		inet6_sk(sk)->daddr.s6_addr32[3] = addr->v4.sin_addr.s_addr;
 	} else {
 		inet6_sk(sk)->daddr = addr->v6.sin6_addr;
 	}
 }
 /* Initialize a sctp_addr from an address parameter. */
 static void sctp_v6_from_addr_param(union sctp_addr *addr,
 				    union sctp_addr_param *param,
 				    __u16 port, int iif)
 {
 	addr->v6.sin6_family = AF_INET6;
 	addr->v6.sin6_port = port;
 	addr->v6.sin6_flowinfo = 0; /* BUG */
 	ipv6_addr_copy(&addr->v6.sin6_addr, &param->v6.addr);
 	addr->v6.sin6_scope_id = iif;
 }
 /* Initialize an address parameter from a sctp_addr and return the length
  * of the address parameter.
  */
 static int sctp_v6_to_addr_param(const union sctp_addr *addr,
 				 union sctp_addr_param *param)
 {
 	int length = sizeof(sctp_ipv6addr_param_t);
 	param->v6.param_hdr.type = SCTP_PARAM_IPV6_ADDRESS;
 	param->v6.param_hdr.length = ntohs(length);
 	ipv6_addr_copy(&param->v6.addr, &addr->v6.sin6_addr);
 	return length;
 }
 /* Initialize a sctp_addr from a dst_entry. */
 static void sctp_v6_dst_saddr(union sctp_addr *addr, struct dst_entry *dst,
 			      unsigned short port)
 {
 	struct rt6_info *rt = (struct rt6_info *)dst;
 	addr->sa.sa_family = AF_INET6;
 	addr->v6.sin6_port = port;
 	ipv6_addr_copy(&addr->v6.sin6_addr, &rt->rt6i_src.addr);
 }
 /* Compare addresses exactly.
  * v4-mapped-v6 is also in consideration.
  */
 static int sctp_v6_cmp_addr(const union sctp_addr *addr1,
 			    const union sctp_addr *addr2)
 {
 	if (addr1->sa.sa_family != addr2->sa.sa_family) {
 		if (addr1->sa.sa_family == AF_INET &&
 		    addr2->sa.sa_family == AF_INET6 &&
 		    IPV6_ADDR_MAPPED == ipv6_addr_type(&addr2->v6.sin6_addr)) {
 			if (addr2->v6.sin6_port == addr1->v4.sin_port &&
 			    addr2->v6.sin6_addr.s6_addr32[3] ==
 			    addr1->v4.sin_addr.s_addr)
 				return 1;
 		}
 		if (addr2->sa.sa_family == AF_INET &&
 		    addr1->sa.sa_family == AF_INET6 &&
 		    IPV6_ADDR_MAPPED == ipv6_addr_type(&addr1->v6.sin6_addr)) {
 			if (addr1->v6.sin6_port == addr2->v4.sin_port &&
 			    addr1->v6.sin6_addr.s6_addr32[3] ==
 			    addr2->v4.sin_addr.s_addr)
 				return 1;
 		}
 		return 0;
 	}
 	if (!ipv6_addr_equal(&addr1->v6.sin6_addr, &addr2->v6.sin6_addr))
 		return 0;
 	/* If this is a linklocal address, compare the scope_id. */
 	if (ipv6_addr_type(&addr1->v6.sin6_addr) & IPV6_ADDR_LINKLOCAL) {
 		if (addr1->v6.sin6_scope_id && addr2->v6.sin6_scope_id &&
 		    (addr1->v6.sin6_scope_id != addr2->v6.sin6_scope_id)) {
 			return 0;
 		}
 	}
 	return 1;
 }
 /* Initialize addr struct to INADDR_ANY. */
 static void sctp_v6_inaddr_any(union sctp_addr *addr, unsigned short port)
 {
 	memset(addr, 0x00, sizeof(union sctp_addr));
 	addr->v6.sin6_family = AF_INET6;
 	addr->v6.sin6_port = port;
 }
 /* Is this a wildcard address? */
 static int sctp_v6_is_any(const union sctp_addr *addr)
 {
 	return ipv6_addr_any(&addr->v6.sin6_addr);
 }
 /* Should this be available for binding?   */
 static int sctp_v6_available(union sctp_addr *addr, struct sctp_sock *sp)
 {
 	int type;
 	struct in6_addr *in6 = (struct in6_addr *)&addr->v6.sin6_addr;
 	type = ipv6_addr_type(in6);
 	if (IPV6_ADDR_ANY == type)
 		return 1;
 	if (type == IPV6_ADDR_MAPPED) {
 		if (sp && !sp->v4mapped)
 			return 0;
 		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 			return 0;
 		sctp_v6_map_v4(addr);
 		return sctp_get_af_specific(AF_INET)->available(addr, sp);
 	}
 	if (!(type & IPV6_ADDR_UNICAST))
 		return 0;
 	return ipv6_chk_addr(in6, NULL, 0);
 }
 /* This function checks if the address is a valid address to be used for
  * SCTP.
  *
  * Output:
  * Return 0 - If the address is a non-unicast or an illegal address.
  * Return 1 - If the address is a unicast.
  */
 static int sctp_v6_addr_valid(union sctp_addr *addr,
 			      struct sctp_sock *sp,
 			      const struct sk_buff *skb)
 {
 	int ret = ipv6_addr_type(&addr->v6.sin6_addr);
 	/* Support v4-mapped-v6 address. */
 	if (ret == IPV6_ADDR_MAPPED) {
 		/* Note: This routine is used in input, so v4-mapped-v6
 		 * are disallowed here when there is no sctp_sock.
 		 */
 		if (!sp || !sp->v4mapped)
 			return 0;
 		if (sp && ipv6_only_sock(sctp_opt2sk(sp)))
 			return 0;
 		sctp_v6_map_v4(addr);
 		return sctp_get_af_specific(AF_INET)->addr_valid(addr, sp, skb);
 	}
 	/* Is this a non-unicast address */
 	if (!(ret & IPV6_ADDR_UNICAST))
 		return 0;
 	return 1;
 }
 /* What is the scope of 'addr'?  */
 static sctp_scope_t sctp_v6_scope(union sctp_addr *addr)
 {
 	int v6scope;
 	sctp_scope_t retval;
 	/* The IPv6 scope is really a set of bit fields.
 	 * See IFA_* in <net/if_inet6.h>.  Map to a generic SCTP scope.
 	 */
 	v6scope = ipv6_addr_scope(&addr->v6.sin6_addr);
 	switch (v6scope) {
 	case IFA_HOST:
 		retval = SCTP_SCOPE_LOOPBACK;
 		break;
 	case IFA_LINK:
 		retval = SCTP_SCOPE_LINK;
 		break;
 	case IFA_SITE:
 		retval = SCTP_SCOPE_PRIVATE;
 		break;
 	default:
 		retval = SCTP_SCOPE_GLOBAL;
 		break;
 	};
 	return retval;
 }
 /* Create and initialize a new sk for the socket to be returned by accept(). */
 static struct sock *sctp_v6_create_accept_sk(struct sock *sk,
 					     struct sctp_association *asoc)
 {
 	struct inet_sock *inet = inet_sk(sk);
 	struct sock *newsk;
 	struct inet_sock *newinet;
 	struct ipv6_pinfo *newnp, *np = inet6_sk(sk);
 	struct sctp6_sock *newsctp6sk;
 	newsk = sk_alloc(PF_INET6, GFP_KERNEL, sk->sk_prot, 1);
 	if (!newsk)
 		goto out;
 	sock_init_data(NULL, newsk);
 	newsk->sk_type = SOCK_STREAM;
 	newsk->sk_prot = sk->sk_prot;
 	newsk->sk_no_check = sk->sk_no_check;
 	newsk->sk_reuse = sk->sk_reuse;
 	newsk->sk_destruct = inet_sock_destruct;
 	newsk->sk_family = PF_INET6;
 	newsk->sk_protocol = IPPROTO_SCTP;
 	newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
 	newsk->sk_shutdown = sk->sk_shutdown;
 	sock_reset_flag(sk, SOCK_ZAPPED);
 	newsctp6sk = (struct sctp6_sock *)newsk;
 	inet_sk(newsk)->pinet6 = &newsctp6sk->inet6;
 	newinet = inet_sk(newsk);
 	newnp = inet6_sk(newsk);
 	memcpy(newnp, np, sizeof(struct ipv6_pinfo));
 	/* Initialize sk's sport, dport, rcv_saddr and daddr for getsockname()
 	 * and getpeername().
 	 */
 	newinet->sport = inet->sport;
 	newnp->saddr = np->saddr;
 	newnp->rcv_saddr = np->rcv_saddr;
 	newinet->dport = htons(asoc->peer.port);
 	sctp_v6_to_sk_daddr(&asoc->peer.primary_addr, newsk);
 	/* Init the ipv4 part of the socket since we can have sockets
 	 * using v6 API for ipv4.
 	 */
 	newinet->uc_ttl = -1;
 	newinet->mc_loop = 1;
 	newinet->mc_ttl = 1;
 	newinet->mc_index = 0;
 	newinet->mc_list = NULL;
 	if (ipv4_config.no_pmtu_disc)
 		newinet->pmtudisc = IP_PMTUDISC_DONT;
 	else
 		newinet->pmtudisc = IP_PMTUDISC_WANT;
 	sk_refcnt_debug_inc(newsk);
 	if (newsk->sk_prot->init(newsk)) {
 		sk_common_release(newsk);
 		newsk = NULL;
 	}
 out:
 	return newsk;
 }
 /* Map v4 address to mapped v6 address */
 static void sctp_v6_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
 {
 	if (sp->v4mapped && AF_INET == addr->sa.sa_family)
 		sctp_v4_map_v6(addr);
 }
 /* Where did this skb come from?  */
 static int sctp_v6_skb_iif(const struct sk_buff *skb)
 {
 	struct inet6_skb_parm *opt = (struct inet6_skb_parm *) skb->cb;
 	return opt->iif;
 }
 /* Was this packet marked by Explicit Congestion Notification? */
 static int sctp_v6_is_ce(const struct sk_buff *skb)
 {
 	return *((__u32 *)(skb->nh.ipv6h)) & htonl(1<<20);
 }
 /* Dump the v6 addr to the seq file. */
 static void sctp_v6_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
 {
 	seq_printf(seq, NIP6_FMT " ", NIP6(addr->v6.sin6_addr));
 }
 /* Initialize a PF_INET6 socket msg_name. */
 static void sctp_inet6_msgname(char *msgname, int *addr_len)
 {
 	struct sockaddr_in6 *sin6;
 	sin6 = (struct sockaddr_in6 *)msgname;
 	sin6->sin6_family = AF_INET6;
 	sin6->sin6_flowinfo = 0;
 	sin6->sin6_scope_id = 0; /*FIXME */
 	*addr_len = sizeof(struct sockaddr_in6);
 }
 /* Initialize a PF_INET msgname from a ulpevent. */
 static void sctp_inet6_event_msgname(struct sctp_ulpevent *event,
 				     char *msgname, int *addrlen)
 {
 	struct sockaddr_in6 *sin6, *sin6from;
 	if (msgname) {
 		union sctp_addr *addr;
 		struct sctp_association *asoc;
 		asoc = event->asoc;
 		sctp_inet6_msgname(msgname, addrlen);
 		sin6 = (struct sockaddr_in6 *)msgname;
 		sin6->sin6_port = htons(asoc->peer.port);
 		addr = &asoc->peer.primary_addr;
 		/* Note: If we go to a common v6 format, this code
 		 * will change.
 		 */
 		/* Map ipv4 address into v4-mapped-on-v6 address.  */
 		if (sctp_sk(asoc->base.sk)->v4mapped &&
 		    AF_INET == addr->sa.sa_family) {
 			sctp_v4_map_v6((union sctp_addr *)sin6);
 			sin6->sin6_addr.s6_addr32[3] =
 				addr->v4.sin_addr.s_addr;
 			return;
 		}
 		sin6from = &asoc->peer.primary_addr.v6;
 		ipv6_addr_copy(&sin6->sin6_addr, &sin6from->sin6_addr);
 		if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
 			sin6->sin6_scope_id = sin6from->sin6_scope_id;
 	}
 }
 /* Initialize a msg_name from an inbound skb. */
 static void sctp_inet6_skb_msgname(struct sk_buff *skb, char *msgname,
 				   int *addr_len)
 {
 	struct sctphdr *sh;
 	struct sockaddr_in6 *sin6;
 	if (msgname) {
 		sctp_inet6_msgname(msgname, addr_len);
 		sin6 = (struct sockaddr_in6 *)msgname;
 		sh = (struct sctphdr *)skb->h.raw;
 		sin6->sin6_port = sh->source;
 		/* Map ipv4 address into v4-mapped-on-v6 address. */
 		if (sctp_sk(skb->sk)->v4mapped &&
 		    skb->nh.iph->version == 4) {
 			sctp_v4_map_v6((union sctp_addr *)sin6);
 			sin6->sin6_addr.s6_addr32[3] = skb->nh.iph->saddr;
 			return;
 		}
 		/* Otherwise, just copy the v6 address. */
 		ipv6_addr_copy(&sin6->sin6_addr, &skb->nh.ipv6h->saddr);
 		if (ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL) {
 			struct sctp_ulpevent *ev = sctp_skb2event(skb);
 			sin6->sin6_scope_id = ev->iif;
 		}
 	}
 }
 /* Do we support this AF? */
 static int sctp_inet6_af_supported(sa_family_t family, struct sctp_sock *sp)
 {
 	switch (family) {
 	case AF_INET6:
 		return 1;
 	/* v4-mapped-v6 addresses */
 	case AF_INET:
 		if (!__ipv6_only_sock(sctp_opt2sk(sp)) && sp->v4mapped)
 			return 1;
 	default:
 		return 0;
 	}
 }
 /* Address matching with wildcards allowed.  This extra level
  * of indirection lets us choose whether a PF_INET6 should
  * disallow any v4 addresses if we so choose.
  */
 static int sctp_inet6_cmp_addr(const union sctp_addr *addr1,
 			       const union sctp_addr *addr2,
 			       struct sctp_sock *opt)
 {
 	struct sctp_af *af1, *af2;
 	af1 = sctp_get_af_specific(addr1->sa.sa_family);
 	af2 = sctp_get_af_specific(addr2->sa.sa_family);
 	if (!af1 || !af2)
 		return 0;
 	/* Today, wildcard AF_INET/AF_INET6. */
 	if (sctp_is_any(addr1) || sctp_is_any(addr2))
 		return 1;
 	if (addr1->sa.sa_family != addr2->sa.sa_family)
 		return 0;
 	return af1->cmp_addr(addr1, addr2);
 }
 /* Verify that the provided sockaddr looks bindable.   Common verification,
  * has already been taken care of.
  */
 static int sctp_inet6_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
 {
 	struct sctp_af *af;
 	/* ASSERT: address family has already been verified. */
 	if (addr->sa.sa_family != AF_INET6)
 		af = sctp_get_af_specific(addr->sa.sa_family);
 	else {
 		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 		struct net_device *dev;
 		if (type & IPV6_ADDR_LINKLOCAL) {
 			if (!addr->v6.sin6_scope_id)
 				return 0;
 			dev = dev_get_by_index(addr->v6.sin6_scope_id);
 			if (!dev)
 				return 0;
 			dev_put(dev);
 		}
 		af = opt->pf->af;
 	}
 	return af->available(addr, opt);
 }
 /* Verify that the provided sockaddr looks sendable.   Common verification,
  * has already been taken care of.
  */
 static int sctp_inet6_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
 {
 	struct sctp_af *af = NULL;
 	/* ASSERT: address family has already been verified. */
 	if (addr->sa.sa_family != AF_INET6)
 		af = sctp_get_af_specific(addr->sa.sa_family);
 	else {
 		int type = ipv6_addr_type(&addr->v6.sin6_addr);
 		struct net_device *dev;
 		if (type & IPV6_ADDR_LINKLOCAL) {
 			if (!addr->v6.sin6_scope_id)
 				return 0;
 			dev = dev_get_by_index(addr->v6.sin6_scope_id);
 			if (!dev)
 				return 0;
 			dev_put(dev);
 		}
 		af = opt->pf->af;
 	}
 	return af != NULL;
 }
 /* Fill in Supported Address Type information for INIT and INIT-ACK
  * chunks.   Note: In the future, we may want to look at sock options
  * to determine whether a PF_INET6 socket really wants to have IPV4
  * addresses.
  * Returns number of addresses supported.
  */
 static int sctp_inet6_supported_addrs(const struct sctp_sock *opt,
 				      __u16 *types)
 {
 	types[0] = SCTP_PARAM_IPV4_ADDRESS;
 	types[1] = SCTP_PARAM_IPV6_ADDRESS;
 	return 2;
 }
 static const struct proto_ops inet6_seqpacket_ops = {
 	.family		   = PF_INET6,
 	.owner		   = THIS_MODULE,
 	.release	   = inet6_release,
 	.bind		   = inet6_bind,
 	.connect	   = inet_dgram_connect,
 	.socketpair	   = sock_no_socketpair,
 	.accept		   = inet_accept,
 	.getname	   = inet6_getname,
 	.poll		   = sctp_poll,
 	.ioctl		   = inet6_ioctl,
 	.listen		   = sctp_inet_listen,
 	.shutdown	   = inet_shutdown,
 	.setsockopt	   = sock_common_setsockopt,
 	.getsockopt	   = sock_common_getsockopt,
 	.sendmsg	   = inet_sendmsg,
 	.recvmsg	   = sock_common_recvmsg,
 	.mmap		   = sock_no_mmap,
 #ifdef CONFIG_COMPAT
 	.compat_setsockopt = compat_sock_common_setsockopt,
 	.compat_getsockopt = compat_sock_common_getsockopt,
 #endif
 };
 static struct inet_protosw sctpv6_seqpacket_protosw = {
 	.type          = SOCK_SEQPACKET,
 	.protocol      = IPPROTO_SCTP,
 	.prot 	       = &sctpv6_prot,
 	.ops           = &inet6_seqpacket_ops,
 	.capability    = -1,
 	.no_check      = 0,
 	.flags         = SCTP_PROTOSW_FLAG
 };
 static struct inet_protosw sctpv6_stream_protosw = {
 	.type          = SOCK_STREAM,
 	.protocol      = IPPROTO_SCTP,
 	.prot 	       = &sctpv6_prot,
 	.ops           = &inet6_seqpacket_ops,
 	.capability    = -1,
 	.no_check      = 0,
 	.flags         = SCTP_PROTOSW_FLAG,
 };
 static int sctp6_rcv(struct sk_buff **pskb)
 {
 	return sctp_rcv(*pskb) ? -1 : 0;
 }
 static struct inet6_protocol sctpv6_protocol = {
 	.handler      = sctp6_rcv,
 	.err_handler  = sctp_v6_err,
 	.flags        = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
 };
 static struct sctp_af sctp_ipv6_specific = {
 	.sa_family	   = AF_INET6,
 	.sctp_xmit	   = sctp_v6_xmit,
 	.setsockopt	   = ipv6_setsockopt,
 	.getsockopt	   = ipv6_getsockopt,
 	.get_dst	   = sctp_v6_get_dst,
 	.get_saddr	   = sctp_v6_get_saddr,
 	.copy_addrlist	   = sctp_v6_copy_addrlist,
 	.from_skb	   = sctp_v6_from_skb,
 	.from_sk	   = sctp_v6_from_sk,
 	.to_sk_saddr	   = sctp_v6_to_sk_saddr,
 	.to_sk_daddr	   = sctp_v6_to_sk_daddr,
 	.from_addr_param   = sctp_v6_from_addr_param,
 	.to_addr_param	   = sctp_v6_to_addr_param,
 	.dst_saddr	   = sctp_v6_dst_saddr,
 	.cmp_addr	   = sctp_v6_cmp_addr,
 	.scope		   = sctp_v6_scope,
 	.addr_valid	   = sctp_v6_addr_valid,
 	.inaddr_any	   = sctp_v6_inaddr_any,
 	.is_any		   = sctp_v6_is_any,
 	.available	   = sctp_v6_available,
 	.skb_iif	   = sctp_v6_skb_iif,
 	.is_ce		   = sctp_v6_is_ce,
 	.seq_dump_addr	   = sctp_v6_seq_dump_addr,
 	.net_header_len	   = sizeof(struct ipv6hdr),
 	.sockaddr_len	   = sizeof(struct sockaddr_in6),
 #ifdef CONFIG_COMPAT
 	.compat_setsockopt = compat_ipv6_setsockopt,
 	.compat_getsockopt = compat_ipv6_getsockopt,
 #endif
 };
 static struct sctp_pf sctp_pf_inet6_specific = {
 	.event_msgname = sctp_inet6_event_msgname,
 	.skb_msgname   = sctp_inet6_skb_msgname,
 	.af_supported  = sctp_inet6_af_supported,
 	.cmp_addr      = sctp_inet6_cmp_addr,
 	.bind_verify   = sctp_inet6_bind_verify,
 	.send_verify   = sctp_inet6_send_verify,
 	.supported_addrs = sctp_inet6_supported_addrs,
 	.create_accept_sk = sctp_v6_create_accept_sk,
 	.addr_v4map    = sctp_v6_addr_v4map,
 	.af            = &sctp_ipv6_specific,
 };
 /* Initialize IPv6 support and register with inet6 stack.  */
 int sctp_v6_init(void)
 {
 	int rc = proto_register(&sctpv6_prot, 1);
 	if (rc)
 		goto out;
 	/* Register inet6 protocol. */
 	rc = -EAGAIN;
 	if (inet6_add_protocol(&sctpv6_protocol, IPPROTO_SCTP) < 0)
 		goto out_unregister_sctp_proto;
 	/* Add SCTPv6(UDP and TCP style) to inetsw6 linked list. */
 	inet6_register_protosw(&sctpv6_seqpacket_protosw);
 	inet6_register_protosw(&sctpv6_stream_protosw);
 	/* Register the SCTP specific PF_INET6 functions. */
 	sctp_register_pf(&sctp_pf_inet6_specific, PF_INET6);
 	/* Register the SCTP specific AF_INET6 functions. */
 	sctp_register_af(&sctp_ipv6_specific);
 	/* Register notifier for inet6 address additions/deletions. */
 	register_inet6addr_notifier(&sctp_inet6addr_notifier);
 	rc = 0;
 out:
 	return rc;
 out_unregister_sctp_proto:
 	proto_unregister(&sctpv6_prot);
 	goto out;
 }
 /* IPv6 specific exit support. */
 void sctp_v6_exit(void)
 {
 	list_del(&sctp_ipv6_specific.list);
 	inet6_del_protocol(&sctpv6_protocol, IPPROTO_SCTP);
 	inet6_unregister_protosw(&sctpv6_seqpacket_protosw);
 	inet6_unregister_protosw(&sctpv6_stream_protosw);
 	unregister_inet6addr_notifier(&sctp_inet6addr_notifier);
 	proto_unregister(&sctpv6_prot);
 }

net/sctp/protocol.c

Diff comments View file @ 1616436

 /* SCTP kernel reference Implementation
  * (C) Copyright IBM Corp. 2001, 2004
  * Copyright (c) 1999-2000 Cisco, Inc.
  * Copyright (c) 1999-2001 Motorola, Inc.
  * 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 reference Implementation
  *
  * Initialization/cleanup for SCTP protocol support.
  *
  * The SCTP reference 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.
  *
  * The SCTP reference 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>
  *    Jon Grimm <jgrimm@us.ibm.com>
  *    Sridhar Samudrala <sri@us.ibm.com>
  *    Daisy Chang <daisyc@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/module.h>
 #include <linux/init.h>
 #include <linux/netdevice.h>
 #include <linux/inetdevice.h>
 #include <linux/seq_file.h>
 #include <net/protocol.h>
 #include <net/ip.h>
 #include <net/ipv6.h>
 #include <net/route.h>
 #include <net/sctp/sctp.h>
 #include <net/addrconf.h>
 #include <net/inet_common.h>
 #include <net/inet_ecn.h>
 /* Global data structures. */
 struct sctp_globals sctp_globals __read_mostly;
 struct proc_dir_entry	*proc_net_sctp;
 DEFINE_SNMP_STAT(struct sctp_mib, sctp_statistics) __read_mostly;
 struct idr sctp_assocs_id;
 DEFINE_SPINLOCK(sctp_assocs_id_lock);
 /* This is the global socket data structure used for responding to
  * the Out-of-the-blue (OOTB) packets.  A control sock will be created
  * for this socket at the initialization time.
  */
 static struct socket *sctp_ctl_socket;
 static struct sctp_pf *sctp_pf_inet6_specific;
 static struct sctp_pf *sctp_pf_inet_specific;
 static struct sctp_af *sctp_af_v4_specific;
 static struct sctp_af *sctp_af_v6_specific;
 kmem_cache_t *sctp_chunk_cachep __read_mostly;
 kmem_cache_t *sctp_bucket_cachep __read_mostly;
-extern int sctp_snmp_proc_init(void);
-extern int sctp_snmp_proc_exit(void);
-extern int sctp_eps_proc_init(void);
-extern int sctp_eps_proc_exit(void);
-extern int sctp_assocs_proc_init(void);
-extern int sctp_assocs_proc_exit(void);
 /* Return the address of the control sock. */
 struct sock *sctp_get_ctl_sock(void)
 {
 	return sctp_ctl_socket->sk;
 }
 /* Set up the proc fs entry for the SCTP protocol. */
 static __init int sctp_proc_init(void)
 {
 	if (!proc_net_sctp) {
 		struct proc_dir_entry *ent;
 		ent = proc_mkdir("net/sctp", NULL);
 		if (ent) {
 			ent->owner = THIS_MODULE;
 			proc_net_sctp = ent;
 		} else
 			goto out_nomem;
 	}
 	if (sctp_snmp_proc_init())
 		goto out_nomem;
 	if (sctp_eps_proc_init())
 		goto out_nomem;
 	if (sctp_assocs_proc_init())
 		goto out_nomem;
 	return 0;
 out_nomem:
 	return -ENOMEM;
 }
 /* Clean up the proc fs entry for the SCTP protocol.
  * Note: Do not make this __exit as it is used in the init error
  * path.
  */
 static void sctp_proc_exit(void)
 {
 	sctp_snmp_proc_exit();
 	sctp_eps_proc_exit();
 	sctp_assocs_proc_exit();
 	if (proc_net_sctp) {
 		proc_net_sctp = NULL;
 		remove_proc_entry("net/sctp", NULL);
 	}
 }
 /* Private helper to extract ipv4 address and stash them in
  * the protocol structure.
  */
 static void sctp_v4_copy_addrlist(struct list_head *addrlist,
 				  struct net_device *dev)
 {
 	struct in_device *in_dev;
 	struct in_ifaddr *ifa;
 	struct sctp_sockaddr_entry *addr;
 	rcu_read_lock();
 	if ((in_dev = __in_dev_get_rcu(dev)) == NULL) {
 		rcu_read_unlock();
 		return;
 	}
 	for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
 		/* Add the address to the local list.  */
 		addr = t_new(struct sctp_sockaddr_entry, GFP_ATOMIC);
 		if (addr) {
 			addr->a.v4.sin_family = AF_INET;
 			addr->a.v4.sin_port = 0;
 			addr->a.v4.sin_addr.s_addr = ifa->ifa_local;
 			list_add_tail(&addr->list, addrlist);
 		}
 	}
 	rcu_read_unlock();
 }
 /* Extract our IP addresses from the system and stash them in the
  * protocol structure.
  */
 static void __sctp_get_local_addr_list(void)
 {
 	struct net_device *dev;
 	struct list_head *pos;
 	struct sctp_af *af;
 	read_lock(&dev_base_lock);
 	for (dev = dev_base; dev; dev = dev->next) {
 		__list_for_each(pos, &sctp_address_families) {
 			af = list_entry(pos, struct sctp_af, list);
 			af->copy_addrlist(&sctp_local_addr_list, dev);
 		}
 	}
 	read_unlock(&dev_base_lock);
 }
 static void sctp_get_local_addr_list(void)
 {
 	unsigned long flags;
 	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
 	__sctp_get_local_addr_list();
 	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
 }
 /* Free the existing local addresses.  */
 static void __sctp_free_local_addr_list(void)
 {
 	struct sctp_sockaddr_entry *addr;
 	struct list_head *pos, *temp;
 	list_for_each_safe(pos, temp, &sctp_local_addr_list) {
 		addr = list_entry(pos, struct sctp_sockaddr_entry, list);
 		list_del(pos);
 		kfree(addr);
 	}
 }
 /* Free the existing local addresses.  */
 static void sctp_free_local_addr_list(void)
 {
 	unsigned long flags;
 	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
 	__sctp_free_local_addr_list();
 	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
 }
 /* Copy the local addresses which are valid for 'scope' into 'bp'.  */
 int sctp_copy_local_addr_list(struct sctp_bind_addr *bp, sctp_scope_t scope,
 			      gfp_t gfp, int copy_flags)
 {
 	struct sctp_sockaddr_entry *addr;
 	int error = 0;
 	struct list_head *pos;
 	unsigned long flags;
 	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
 	list_for_each(pos, &sctp_local_addr_list) {
 		addr = list_entry(pos, struct sctp_sockaddr_entry, list);
 		if (sctp_in_scope(&addr->a, scope)) {
 			/* Now that the address is in scope, check to see if
 			 * the address type is really supported by the local
 			 * sock as well as the remote peer.
 			 */
 			if ((((AF_INET == addr->a.sa.sa_family) &&
 			      (copy_flags & SCTP_ADDR4_PEERSUPP))) ||
 			    (((AF_INET6 == addr->a.sa.sa_family) &&
 			      (copy_flags & SCTP_ADDR6_ALLOWED) &&
 			      (copy_flags & SCTP_ADDR6_PEERSUPP)))) {
 				error = sctp_add_bind_addr(bp, &addr->a, 1,
 							   GFP_ATOMIC);
 				if (error)
 					goto end_copy;
 			}
 		}
 	}
 end_copy:
 	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
 	return error;
 }
 /* Initialize a sctp_addr from in incoming skb.  */
 static void sctp_v4_from_skb(union sctp_addr *addr, struct sk_buff *skb,
 			     int is_saddr)
 {
 	void *from;
 	__u16 *port;
 	struct sctphdr *sh;
 	port = &addr->v4.sin_port;
 	addr->v4.sin_family = AF_INET;
 	sh = (struct sctphdr *) skb->h.raw;
 	if (is_saddr) {
 		*port  = ntohs(sh->source);
 		from = &skb->nh.iph->saddr;
 	} else {
 		*port = ntohs(sh->dest);
 		from = &skb->nh.iph->daddr;
 	}
 	memcpy(&addr->v4.sin_addr.s_addr, from, sizeof(struct in_addr));
 }
 /* Initialize an sctp_addr from a socket. */
 static void sctp_v4_from_sk(union sctp_addr *addr, struct sock *sk)
 {
 	addr->v4.sin_family = AF_INET;
 	addr->v4.sin_port = inet_sk(sk)->num;
 	addr->v4.sin_addr.s_addr = inet_sk(sk)->rcv_saddr;
 }
 /* Initialize sk->sk_rcv_saddr from sctp_addr. */
 static void sctp_v4_to_sk_saddr(union sctp_addr *addr, struct sock *sk)
 {
 	inet_sk(sk)->rcv_saddr = addr->v4.sin_addr.s_addr;
 }
 /* Initialize sk->sk_daddr from sctp_addr. */
 static void sctp_v4_to_sk_daddr(union sctp_addr *addr, struct sock *sk)
 {
 	inet_sk(sk)->daddr = addr->v4.sin_addr.s_addr;
 }
 /* Initialize a sctp_addr from an address parameter. */
 static void sctp_v4_from_addr_param(union sctp_addr *addr,
 				    union sctp_addr_param *param,
 				    __u16 port, int iif)
 {
 	addr->v4.sin_family = AF_INET;
 	addr->v4.sin_port = port;
 	addr->v4.sin_addr.s_addr = param->v4.addr.s_addr;
 }
 /* Initialize an address parameter from a sctp_addr and return the length
  * of the address parameter.
  */
 static int sctp_v4_to_addr_param(const union sctp_addr *addr,
 				 union sctp_addr_param *param)
 {
 	int length = sizeof(sctp_ipv4addr_param_t);
 	param->v4.param_hdr.type = SCTP_PARAM_IPV4_ADDRESS;
 	param->v4.param_hdr.length = ntohs(length);
 	param->v4.addr.s_addr = addr->v4.sin_addr.s_addr;
 	return length;
 }
 /* Initialize a sctp_addr from a dst_entry. */
 static void sctp_v4_dst_saddr(union sctp_addr *saddr, struct dst_entry *dst,
 			      unsigned short port)
 {
 	struct rtable *rt = (struct rtable *)dst;
 	saddr->v4.sin_family = AF_INET;
 	saddr->v4.sin_port = port;
 	saddr->v4.sin_addr.s_addr = rt->rt_src;
 }
 /* Compare two addresses exactly. */
 static int sctp_v4_cmp_addr(const union sctp_addr *addr1,
 			    const union sctp_addr *addr2)
 {
 	if (addr1->sa.sa_family != addr2->sa.sa_family)
 		return 0;
 	if (addr1->v4.sin_port != addr2->v4.sin_port)
 		return 0;
 	if (addr1->v4.sin_addr.s_addr != addr2->v4.sin_addr.s_addr)
 		return 0;
 	return 1;
 }
 /* Initialize addr struct to INADDR_ANY. */
 static void sctp_v4_inaddr_any(union sctp_addr *addr, unsigned short port)
 {
 	addr->v4.sin_family = AF_INET;
 	addr->v4.sin_addr.s_addr = INADDR_ANY;
 	addr->v4.sin_port = port;
 }
 /* Is this a wildcard address? */
 static int sctp_v4_is_any(const union sctp_addr *addr)
 {
 	return INADDR_ANY == addr->v4.sin_addr.s_addr;
 }
 /* This function checks if the address is a valid address to be used for
  * SCTP binding.
  *
  * Output:
  * Return 0 - If the address is a non-unicast or an illegal address.
  * Return 1 - If the address is a unicast.
  */
 static int sctp_v4_addr_valid(union sctp_addr *addr,
 			      struct sctp_sock *sp,
 			      const struct sk_buff *skb)
 {
 	/* Is this a non-unicast address or a unusable SCTP address? */
 	if (IS_IPV4_UNUSABLE_ADDRESS(&addr->v4.sin_addr.s_addr))
 		return 0;
  	/* Is this a broadcast address? */
  	if (skb && ((struct rtable *)skb->dst)->rt_flags & RTCF_BROADCAST)
  		return 0;
 	return 1;
 }
 /* Should this be available for binding?   */
 static int sctp_v4_available(union sctp_addr *addr, struct sctp_sock *sp)
 {
 	int ret = inet_addr_type(addr->v4.sin_addr.s_addr);
 	if (addr->v4.sin_addr.s_addr != INADDR_ANY &&
 	   ret != RTN_LOCAL &&
 	   !sp->inet.freebind &&
 	   !sysctl_ip_nonlocal_bind)
 		return 0;
 	return 1;
 }
 /* Checking the loopback, private and other address scopes as defined in
  * RFC 1918.   The IPv4 scoping is based on the draft for SCTP IPv4
  * scoping <draft-stewart-tsvwg-sctp-ipv4-00.txt>.
  *
  * Level 0 - unusable SCTP addresses
  * Level 1 - loopback address
  * Level 2 - link-local addresses
  * Level 3 - private addresses.
  * Level 4 - global addresses
  * For INIT and INIT-ACK address list, let L be the level of
  * of requested destination address, sender and receiver
  * SHOULD include all of its addresses with level greater
  * than or equal to L.
  */
 static sctp_scope_t sctp_v4_scope(union sctp_addr *addr)
 {
 	sctp_scope_t retval;
 	/* Should IPv4 scoping be a sysctl configurable option
 	 * so users can turn it off (default on) for certain
 	 * unconventional networking environments?
 	 */
 	/* Check for unusable SCTP addresses. */
 	if (IS_IPV4_UNUSABLE_ADDRESS(&addr->v4.sin_addr.s_addr)) {
 		retval =  SCTP_SCOPE_UNUSABLE;
 	} else if (LOOPBACK(addr->v4.sin_addr.s_addr)) {
 		retval = SCTP_SCOPE_LOOPBACK;
 	} else if (IS_IPV4_LINK_ADDRESS(&addr->v4.sin_addr.s_addr)) {
 		retval = SCTP_SCOPE_LINK;
 	} else if (IS_IPV4_PRIVATE_ADDRESS(&addr->v4.sin_addr.s_addr)) {
 		retval = SCTP_SCOPE_PRIVATE;
 	} else {
 		retval = SCTP_SCOPE_GLOBAL;
 	}
 	return retval;
 }
 /* Returns a valid dst cache entry for the given source and destination ip
  * addresses. If an association is passed, trys to get a dst entry with a
  * source address that matches an address in the bind address list.
  */
 static struct dst_entry *sctp_v4_get_dst(struct sctp_association *asoc,
 					 union sctp_addr *daddr,
 					 union sctp_addr *saddr)
 {
 	struct rtable *rt;
 	struct flowi fl;
 	struct sctp_bind_addr *bp;
 	rwlock_t *addr_lock;
 	struct sctp_sockaddr_entry *laddr;
 	struct list_head *pos;
 	struct dst_entry *dst = NULL;
 	union sctp_addr dst_saddr;
 	memset(&fl, 0x0, sizeof(struct flowi));
 	fl.fl4_dst  = daddr->v4.sin_addr.s_addr;
 	fl.proto = IPPROTO_SCTP;
 	if (asoc) {
 		fl.fl4_tos = RT_CONN_FLAGS(asoc->base.sk);
 		fl.oif = asoc->base.sk->sk_bound_dev_if;
 	}
 	if (saddr)
 		fl.fl4_src = saddr->v4.sin_addr.s_addr;
 	SCTP_DEBUG_PRINTK("%s: DST:%u.%u.%u.%u, SRC:%u.%u.%u.%u - ",
 			  __FUNCTION__, NIPQUAD(fl.fl4_dst),
 			  NIPQUAD(fl.fl4_src));
 	if (!ip_route_output_key(&rt, &fl)) {
 		dst = &rt->u.dst;
 	}
 	/* If there is no association or if a source address is passed, no
 	 * more validation is required.
 	 */
 	if (!asoc || saddr)
 		goto out;
 	bp = &asoc->base.bind_addr;
 	addr_lock = &asoc->base.addr_lock;
 	if (dst) {
 		/* Walk through the bind address list and look for a bind
 		 * address that matches the source address of the returned dst.
 		 */
 		sctp_read_lock(addr_lock);
 		list_for_each(pos, &bp->address_list) {
 			laddr = list_entry(pos, struct sctp_sockaddr_entry,
 					   list);
 			if (!laddr->use_as_src)
 				continue;
 			sctp_v4_dst_saddr(&dst_saddr, dst, bp->port);
 			if (sctp_v4_cmp_addr(&dst_saddr, &laddr->a))
 				goto out_unlock;
 		}
 		sctp_read_unlock(addr_lock);
 		/* None of the bound addresses match the source address of the
 		 * dst. So release it.
 		 */
 		dst_release(dst);
 		dst = NULL;
 	}
 	/* Walk through the bind address list and try to get a dst that
 	 * matches a bind address as the source address.
 	 */
 	sctp_read_lock(addr_lock);
 	list_for_each(pos, &bp->address_list) {
 		laddr = list_entry(pos, struct sctp_sockaddr_entry, list);
 		if ((laddr->use_as_src) &&
 		    (AF_INET == laddr->a.sa.sa_family)) {
 			fl.fl4_src = laddr->a.v4.sin_addr.s_addr;
 			if (!ip_route_output_key(&rt, &fl)) {
 				dst = &rt->u.dst;
 				goto out_unlock;
 			}
 		}
 	}
 out_unlock:
 	sctp_read_unlock(addr_lock);
 out:
 	if (dst)
 		SCTP_DEBUG_PRINTK("rt_dst:%u.%u.%u.%u, rt_src:%u.%u.%u.%u\n",
 			  	  NIPQUAD(rt->rt_dst), NIPQUAD(rt->rt_src));
 	else
 		SCTP_DEBUG_PRINTK("NO ROUTE\n");
 	return dst;
 }
 /* For v4, the source address is cached in the route entry(dst). So no need
  * to cache it separately and hence this is an empty routine.
  */
 static void sctp_v4_get_saddr(struct sctp_association *asoc,
 			      struct dst_entry *dst,
 			      union sctp_addr *daddr,
 			      union sctp_addr *saddr)
 {
 	struct rtable *rt = (struct rtable *)dst;
 	if (!asoc)
 		return;
 	if (rt) {
 		saddr->v4.sin_family = AF_INET;
 		saddr->v4.sin_port = asoc->base.bind_addr.port;
 		saddr->v4.sin_addr.s_addr = rt->rt_src;
 	}
 }
 /* What interface did this skb arrive on? */
 static int sctp_v4_skb_iif(const struct sk_buff *skb)
 {
      	return ((struct rtable *)skb->dst)->rt_iif;
 }
 /* Was this packet marked by Explicit Congestion Notification? */
 static int sctp_v4_is_ce(const struct sk_buff *skb)
 {
 	return INET_ECN_is_ce(skb->nh.iph->tos);
 }
 /* Create and initialize a new sk for the socket returned by accept(). */
 static struct sock *sctp_v4_create_accept_sk(struct sock *sk,
 					     struct sctp_association *asoc)
 {
 	struct inet_sock *inet = inet_sk(sk);
 	struct inet_sock *newinet;
 	struct sock *newsk = sk_alloc(PF_INET, GFP_KERNEL, sk->sk_prot, 1);
 	if (!newsk)
 		goto out;
 	sock_init_data(NULL, newsk);
 	newsk->sk_type = SOCK_STREAM;
 	newsk->sk_no_check = sk->sk_no_check;
 	newsk->sk_reuse = sk->sk_reuse;
 	newsk->sk_shutdown = sk->sk_shutdown;
 	newsk->sk_destruct = inet_sock_destruct;
 	newsk->sk_family = PF_INET;
 	newsk->sk_protocol = IPPROTO_SCTP;
 	newsk->sk_backlog_rcv = sk->sk_prot->backlog_rcv;
 	sock_reset_flag(newsk, SOCK_ZAPPED);
 	newinet = inet_sk(newsk);
 	/* Initialize sk's sport, dport, rcv_saddr and daddr for
 	 * getsockname() and getpeername()
 	 */
 	newinet->sport = inet->sport;
 	newinet->saddr = inet->saddr;
 	newinet->rcv_saddr = inet->rcv_saddr;
 	newinet->dport = htons(asoc->peer.port);
 	newinet->daddr = asoc->peer.primary_addr.v4.sin_addr.s_addr;
 	newinet->pmtudisc = inet->pmtudisc;
       	newinet->id = 0;
 	newinet->uc_ttl = -1;
 	newinet->mc_loop = 1;
 	newinet->mc_ttl = 1;
 	newinet->mc_index = 0;
 	newinet->mc_list = NULL;
 	sk_refcnt_debug_inc(newsk);
 	if (newsk->sk_prot->init(newsk)) {
 		sk_common_release(newsk);
 		newsk = NULL;
 	}
 out:
 	return newsk;
 }
 /* Map address, empty for v4 family */
 static void sctp_v4_addr_v4map(struct sctp_sock *sp, union sctp_addr *addr)
 {
 	/* Empty */
 }
 /* Dump the v4 addr to the seq file. */
 static void sctp_v4_seq_dump_addr(struct seq_file *seq, union sctp_addr *addr)
 {
 	seq_printf(seq, "%d.%d.%d.%d ", NIPQUAD(addr->v4.sin_addr));
 }
 /* Event handler for inet address addition/deletion events.
  * Basically, whenever there is an event, we re-build our local address list.
  */
 int sctp_inetaddr_event(struct notifier_block *this, unsigned long ev,
                         void *ptr)
 {
 	unsigned long flags;
 	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
 	__sctp_free_local_addr_list();
 	__sctp_get_local_addr_list();
 	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
 	return NOTIFY_DONE;
 }
 /*
  * Initialize the control inode/socket with a control endpoint data
  * structure.  This endpoint is reserved exclusively for the OOTB processing.
  */
 static int sctp_ctl_sock_init(void)
 {
 	int err;
 	sa_family_t family;
 	if (sctp_get_pf_specific(PF_INET6))
 		family = PF_INET6;
 	else
 		family = PF_INET;
 	err = sock_create_kern(family, SOCK_SEQPACKET, IPPROTO_SCTP,
 			       &sctp_ctl_socket);
 	if (err < 0) {
 		printk(KERN_ERR
 		       "SCTP: Failed to create the SCTP control socket.\n");
 		return err;
 	}
 	sctp_ctl_socket->sk->sk_allocation = GFP_ATOMIC;
 	inet_sk(sctp_ctl_socket->sk)->uc_ttl = -1;
 	return 0;
 }
 /* Register address family specific functions. */
 int sctp_register_af(struct sctp_af *af)
 {
 	switch (af->sa_family) {
 	case AF_INET:
 		if (sctp_af_v4_specific)
 			return 0;
 		sctp_af_v4_specific = af;
 		break;
 	case AF_INET6:
 		if (sctp_af_v6_specific)
 			return 0;
 		sctp_af_v6_specific = af;
 		break;
 	default:
 		return 0;
 	}
 	INIT_LIST_HEAD(&af->list);
 	list_add_tail(&af->list, &sctp_address_families);
 	return 1;
 }
 /* Get the table of functions for manipulating a particular address
  * family.
  */
 struct sctp_af *sctp_get_af_specific(sa_family_t family)
 {
 	switch (family) {
 	case AF_INET:
 		return sctp_af_v4_specific;
 	case AF_INET6:
 		return sctp_af_v6_specific;
 	default:
 		return NULL;
 	}
 }
 /* Common code to initialize a AF_INET msg_name. */
 static void sctp_inet_msgname(char *msgname, int *addr_len)
 {
 	struct sockaddr_in *sin;
 	sin = (struct sockaddr_in *)msgname;
 	*addr_len = sizeof(struct sockaddr_in);
 	sin->sin_family = AF_INET;
 	memset(sin->sin_zero, 0, sizeof(sin->sin_zero));
 }
 /* Copy the primary address of the peer primary address as the msg_name. */
 static void sctp_inet_event_msgname(struct sctp_ulpevent *event, char *msgname,
 				    int *addr_len)
 {
 	struct sockaddr_in *sin, *sinfrom;
 	if (msgname) {
 		struct sctp_association *asoc;
 		asoc = event->asoc;
 		sctp_inet_msgname(msgname, addr_len);
 		sin = (struct sockaddr_in *)msgname;
 		sinfrom = &asoc->peer.primary_addr.v4;
 		sin->sin_port = htons(asoc->peer.port);
 		sin->sin_addr.s_addr = sinfrom->sin_addr.s_addr;
 	}
 }
 /* Initialize and copy out a msgname from an inbound skb. */
 static void sctp_inet_skb_msgname(struct sk_buff *skb, char *msgname, int *len)
 {
 	struct sctphdr *sh;
 	struct sockaddr_in *sin;
 	if (msgname) {
 		sctp_inet_msgname(msgname, len);
 		sin = (struct sockaddr_in *)msgname;
 		sh = (struct sctphdr *)skb->h.raw;
 		sin->sin_port = sh->source;
 		sin->sin_addr.s_addr = skb->nh.iph->saddr;
 	}
 }
 /* Do we support this AF? */
 static int sctp_inet_af_supported(sa_family_t family, struct sctp_sock *sp)
 {
 	/* PF_INET only supports AF_INET addresses. */
 	return (AF_INET == family);
 }
 /* Address matching with wildcards allowed. */
 static int sctp_inet_cmp_addr(const union sctp_addr *addr1,
 			      const union sctp_addr *addr2,
 			      struct sctp_sock *opt)
 {
 	/* PF_INET only supports AF_INET addresses. */
 	if (addr1->sa.sa_family != addr2->sa.sa_family)
 		return 0;
 	if (INADDR_ANY == addr1->v4.sin_addr.s_addr ||
 	    INADDR_ANY == addr2->v4.sin_addr.s_addr)
 		return 1;
 	if (addr1->v4.sin_addr.s_addr == addr2->v4.sin_addr.s_addr)
 		return 1;
 	return 0;
 }
 /* Verify that provided sockaddr looks bindable.  Common verification has
  * already been taken care of.
  */
 static int sctp_inet_bind_verify(struct sctp_sock *opt, union sctp_addr *addr)
 {
 	return sctp_v4_available(addr, opt);
 }
 /* Verify that sockaddr looks sendable.  Common verification has already
  * been taken care of.
  */
 static int sctp_inet_send_verify(struct sctp_sock *opt, union sctp_addr *addr)
 {
 	return 1;
 }
 /* Fill in Supported Address Type information for INIT and INIT-ACK
  * chunks.  Returns number of addresses supported.
  */
 static int sctp_inet_supported_addrs(const struct sctp_sock *opt,
 				     __u16 *types)
 {
 	types[0] = SCTP_PARAM_IPV4_ADDRESS;
 	return 1;
 }
 /* Wrapper routine that calls the ip transmit routine. */
 static inline int sctp_v4_xmit(struct sk_buff *skb,
 			       struct sctp_transport *transport, int ipfragok)
 {
 	SCTP_DEBUG_PRINTK("%s: skb:%p, len:%d, "
 			  "src:%u.%u.%u.%u, dst:%u.%u.%u.%u\n",
 			  __FUNCTION__, skb, skb->len,
 			  NIPQUAD(((struct rtable *)skb->dst)->rt_src),
 			  NIPQUAD(((struct rtable *)skb->dst)->rt_dst));
 	SCTP_INC_STATS(SCTP_MIB_OUTSCTPPACKS);
 	return ip_queue_xmit(skb, ipfragok);
 }
 static struct sctp_af sctp_ipv4_specific;
 static struct sctp_pf sctp_pf_inet = {
 	.event_msgname = sctp_inet_event_msgname,
 	.skb_msgname   = sctp_inet_skb_msgname,
 	.af_supported  = sctp_inet_af_supported,
 	.cmp_addr      = sctp_inet_cmp_addr,
 	.bind_verify   = sctp_inet_bind_verify,
 	.send_verify   = sctp_inet_send_verify,
 	.supported_addrs = sctp_inet_supported_addrs,
 	.create_accept_sk = sctp_v4_create_accept_sk,
 	.addr_v4map	= sctp_v4_addr_v4map,
 	.af            = &sctp_ipv4_specific,
 };
 /* Notifier for inetaddr addition/deletion events.  */
 static struct notifier_block sctp_inetaddr_notifier = {
 	.notifier_call = sctp_inetaddr_event,
 };
 /* Socket operations.  */
 static const struct proto_ops inet_seqpacket_ops = {
 	.family		   = PF_INET,
 	.owner		   = THIS_MODULE,
 	.release	   = inet_release,	/* Needs to be wrapped... */
 	.bind		   = inet_bind,
 	.connect	   = inet_dgram_connect,
 	.socketpair	   = sock_no_socketpair,
 	.accept		   = inet_accept,
 	.getname	   = inet_getname,	/* Semantics are different.  */
 	.poll		   = sctp_poll,
 	.ioctl		   = inet_ioctl,
 	.listen		   = sctp_inet_listen,
 	.shutdown	   = inet_shutdown,	/* Looks harmless.  */
 	.setsockopt	   = sock_common_setsockopt, /* IP_SOL IP_OPTION is a problem */
 	.getsockopt	   = sock_common_getsockopt,
 	.sendmsg	   = inet_sendmsg,
 	.recvmsg	   = sock_common_recvmsg,
 	.mmap		   = sock_no_mmap,
 	.sendpage	   = sock_no_sendpage,
 #ifdef CONFIG_COMPAT
 	.compat_setsockopt = compat_sock_common_setsockopt,
 	.compat_getsockopt = compat_sock_common_getsockopt,
 #endif
 };
 /* Registration with AF_INET family.  */
 static struct inet_protosw sctp_seqpacket_protosw = {
 	.type       = SOCK_SEQPACKET,
 	.protocol   = IPPROTO_SCTP,
 	.prot       = &sctp_prot,
 	.ops        = &inet_seqpacket_ops,
 	.capability = -1,
 	.no_check   = 0,
 	.flags      = SCTP_PROTOSW_FLAG
 };
 static struct inet_protosw sctp_stream_protosw = {
 	.type       = SOCK_STREAM,
 	.protocol   = IPPROTO_SCTP,
 	.prot       = &sctp_prot,
 	.ops        = &inet_seqpacket_ops,
 	.capability = -1,
 	.no_check   = 0,
 	.flags      = SCTP_PROTOSW_FLAG
 };
 /* Register with IP layer.  */
 static struct net_protocol sctp_protocol = {
 	.handler     = sctp_rcv,
 	.err_handler = sctp_v4_err,
 	.no_policy   = 1,
 };
 /* IPv4 address related functions.  */
 static struct sctp_af sctp_ipv4_specific = {
 	.sa_family	   = AF_INET,
 	.sctp_xmit	   = sctp_v4_xmit,
 	.setsockopt	   = ip_setsockopt,
 	.getsockopt	   = ip_getsockopt,
 	.get_dst	   = sctp_v4_get_dst,
 	.get_saddr	   = sctp_v4_get_saddr,
 	.copy_addrlist	   = sctp_v4_copy_addrlist,
 	.from_skb	   = sctp_v4_from_skb,
 	.from_sk	   = sctp_v4_from_sk,
 	.to_sk_saddr	   = sctp_v4_to_sk_saddr,
 	.to_sk_daddr	   = sctp_v4_to_sk_daddr,
 	.from_addr_param   = sctp_v4_from_addr_param,
 	.to_addr_param	   = sctp_v4_to_addr_param,
 	.dst_saddr	   = sctp_v4_dst_saddr,
 	.cmp_addr	   = sctp_v4_cmp_addr,
 	.addr_valid	   = sctp_v4_addr_valid,
 	.inaddr_any	   = sctp_v4_inaddr_any,
 	.is_any		   = sctp_v4_is_any,
 	.available	   = sctp_v4_available,
 	.scope		   = sctp_v4_scope,
 	.skb_iif	   = sctp_v4_skb_iif,
 	.is_ce		   = sctp_v4_is_ce,
 	.seq_dump_addr	   = sctp_v4_seq_dump_addr,
 	.net_header_len	   = sizeof(struct iphdr),
 	.sockaddr_len	   = sizeof(struct sockaddr_in),
 #ifdef CONFIG_COMPAT
 	.compat_setsockopt = compat_ip_setsockopt,
 	.compat_getsockopt = compat_ip_getsockopt,
 #endif
 };
 struct sctp_pf *sctp_get_pf_specific(sa_family_t family) {
 	switch (family) {
 	case PF_INET:
 		return sctp_pf_inet_specific;
 	case PF_INET6:
 		return sctp_pf_inet6_specific;
 	default:
 		return NULL;
 	}
 }
 /* Register the PF specific function table.  */
 int sctp_register_pf(struct sctp_pf *pf, sa_family_t family)
 {
 	switch (family) {
 	case PF_INET:
 		if (sctp_pf_inet_specific)
 			return 0;
 		sctp_pf_inet_specific = pf;
 		break;
 	case PF_INET6:
 		if (sctp_pf_inet6_specific)
 			return 0;
 		sctp_pf_inet6_specific = pf;
 		break;
 	default:
 		return 0;
 	}
 	return 1;
 }
 static int __init init_sctp_mibs(void)
 {
 	sctp_statistics[0] = alloc_percpu(struct sctp_mib);
 	if (!sctp_statistics[0])
 		return -ENOMEM;
 	sctp_statistics[1] = alloc_percpu(struct sctp_mib);
 	if (!sctp_statistics[1]) {
 		free_percpu(sctp_statistics[0]);
 		return -ENOMEM;
 	}
 	return 0;
 }
 static void cleanup_sctp_mibs(void)
 {
 	free_percpu(sctp_statistics[0]);
 	free_percpu(sctp_statistics[1]);
 }
 /* Initialize the universe into something sensible.  */
 SCTP_STATIC __init int sctp_init(void)
 {
 	int i;
 	int status = -EINVAL;
 	unsigned long goal;
 	int order;
 	/* SCTP_DEBUG sanity check. */
 	if (!sctp_sanity_check())
 		goto out;
 	status = proto_register(&sctp_prot, 1);
 	if (status)
 		goto out;
 	/* Add SCTP to inet_protos hash table.  */
 	status = -EAGAIN;
 	if (inet_add_protocol(&sctp_protocol, IPPROTO_SCTP) < 0)
 		goto err_add_protocol;
 	/* Add SCTP(TCP and UDP style) to inetsw linked list.  */
 	inet_register_protosw(&sctp_seqpacket_protosw);
 	inet_register_protosw(&sctp_stream_protosw);
 	/* Allocate a cache pools. */
 	status = -ENOBUFS;
 	sctp_bucket_cachep = kmem_cache_create("sctp_bind_bucket",
 					       sizeof(struct sctp_bind_bucket),
 					       0, SLAB_HWCACHE_ALIGN,
 					       NULL, NULL);
 	if (!sctp_bucket_cachep)
 		goto err_bucket_cachep;
 	sctp_chunk_cachep = kmem_cache_create("sctp_chunk",
 					       sizeof(struct sctp_chunk),
 					       0, SLAB_HWCACHE_ALIGN,
 					       NULL, NULL);
 	if (!sctp_chunk_cachep)
 		goto err_chunk_cachep;
 	/* Allocate and initialise sctp mibs.  */
 	status = init_sctp_mibs();
 	if (status)
 		goto err_init_mibs;
 	/* Initialize proc fs directory.  */
 	status = sctp_proc_init();
 	if (status)
 		goto err_init_proc;
 	/* Initialize object count debugging.  */
 	sctp_dbg_objcnt_init();
 	/* Initialize the SCTP specific PF functions. */
 	sctp_register_pf(&sctp_pf_inet, PF_INET);
 	/*
 	 * 14. Suggested SCTP Protocol Parameter Values
 	 */
 	/* The following protocol parameters are RECOMMENDED:  */
 	/* RTO.Initial              - 3  seconds */
 	sctp_rto_initial		= SCTP_RTO_INITIAL;
 	/* RTO.Min                  - 1  second */
 	sctp_rto_min	 		= SCTP_RTO_MIN;
 	/* RTO.Max                 -  60 seconds */
 	sctp_rto_max 			= SCTP_RTO_MAX;
 	/* RTO.Alpha                - 1/8 */
 	sctp_rto_alpha	        	= SCTP_RTO_ALPHA;
 	/* RTO.Beta                 - 1/4 */
 	sctp_rto_beta			= SCTP_RTO_BETA;
 	/* Valid.Cookie.Life        - 60  seconds */
 	sctp_valid_cookie_life		= SCTP_DEFAULT_COOKIE_LIFE;
 	/* Whether Cookie Preservative is enabled(1) or not(0) */
 	sctp_cookie_preserve_enable 	= 1;
 	/* Max.Burst		    - 4 */
 	sctp_max_burst 			= SCTP_MAX_BURST;
 	/* Association.Max.Retrans  - 10 attempts
 	 * Path.Max.Retrans         - 5  attempts (per destination address)
 	 * Max.Init.Retransmits     - 8  attempts
 	 */
 	sctp_max_retrans_association 	= 10;
 	sctp_max_retrans_path		= 5;
 	sctp_max_retrans_init		= 8;
 	/* Sendbuffer growth	    - do per-socket accounting */
 	sctp_sndbuf_policy		= 0;
 	/* Rcvbuffer growth	    - do per-socket accounting */
 	sctp_rcvbuf_policy		= 0;
 	/* HB.interval              - 30 seconds */
 	sctp_hb_interval		= SCTP_DEFAULT_TIMEOUT_HEARTBEAT;
 	/* delayed SACK timeout */
 	sctp_sack_timeout		= SCTP_DEFAULT_TIMEOUT_SACK;
 	/* Implementation specific variables. */
 	/* Initialize default stream count setup information. */
 	sctp_max_instreams    		= SCTP_DEFAULT_INSTREAMS;
 	sctp_max_outstreams   		= SCTP_DEFAULT_OUTSTREAMS;
 	/* Initialize handle used for association ids. */
 	idr_init(&sctp_assocs_id);
 	/* Size and allocate the association hash table.
 	 * The methodology is similar to that of the tcp hash tables.
 	 */
 	if (num_physpages >= (128 * 1024))
 		goal = num_physpages >> (22 - PAGE_SHIFT);
 	else
 		goal = num_physpages >> (24 - PAGE_SHIFT);
 	for (order = 0; (1UL << order) < goal; order++)
 		;
 	do {
 		sctp_assoc_hashsize = (1UL << order) * PAGE_SIZE /
 					sizeof(struct sctp_hashbucket);
 		if ((sctp_assoc_hashsize > (64 * 1024)) && order > 0)
 			continue;
 		sctp_assoc_hashtable = (struct sctp_hashbucket *)
 					__get_free_pages(GFP_ATOMIC, order);
 	} while (!sctp_assoc_hashtable && --order > 0);
 	if (!sctp_assoc_hashtable) {
 		printk(KERN_ERR "SCTP: Failed association hash alloc.\n");
 		status = -ENOMEM;
 		goto err_ahash_alloc;
 	}
 	for (i = 0; i < sctp_assoc_hashsize; i++) {
 		rwlock_init(&sctp_assoc_hashtable[i].lock);
 		sctp_assoc_hashtable[i].chain = NULL;
 	}
 	/* Allocate and initialize the endpoint hash table.  */
 	sctp_ep_hashsize = 64;
 	sctp_ep_hashtable = (struct sctp_hashbucket *)
 		kmalloc(64 * sizeof(struct sctp_hashbucket), GFP_KERNEL);
 	if (!sctp_ep_hashtable) {
 		printk(KERN_ERR "SCTP: Failed endpoint_hash alloc.\n");
 		status = -ENOMEM;
 		goto err_ehash_alloc;
 	}
 	for (i = 0; i < sctp_ep_hashsize; i++) {
 		rwlock_init(&sctp_ep_hashtable[i].lock);
 		sctp_ep_hashtable[i].chain = NULL;
 	}
 	/* Allocate and initialize the SCTP port hash table.  */
 	do {
 		sctp_port_hashsize = (1UL << order) * PAGE_SIZE /
 					sizeof(struct sctp_bind_hashbucket);
 		if ((sctp_port_hashsize > (64 * 1024)) && order > 0)
 			continue;
 		sctp_port_hashtable = (struct sctp_bind_hashbucket *)
 					__get_free_pages(GFP_ATOMIC, order);
 	} while (!sctp_port_hashtable && --order > 0);
 	if (!sctp_port_hashtable) {
 		printk(KERN_ERR "SCTP: Failed bind hash alloc.");
 		status = -ENOMEM;
 		goto err_bhash_alloc;
 	}
 	for (i = 0; i < sctp_port_hashsize; i++) {
 		spin_lock_init(&sctp_port_hashtable[i].lock);
 		sctp_port_hashtable[i].chain = NULL;
 	}
 	spin_lock_init(&sctp_port_alloc_lock);
 	sctp_port_rover = sysctl_local_port_range[0] - 1;
 	printk(KERN_INFO "SCTP: Hash tables configured "
 			 "(established %d bind %d)\n",
 		sctp_assoc_hashsize, sctp_port_hashsize);
 	/* Disable ADDIP by default. */
 	sctp_addip_enable = 0;
 	/* Enable PR-SCTP by default. */
 	sctp_prsctp_enable = 1;
 	sctp_sysctl_register();
 	INIT_LIST_HEAD(&sctp_address_families);
 	sctp_register_af(&sctp_ipv4_specific);
 	status = sctp_v6_init();
 	if (status)
 		goto err_v6_init;
 	/* Initialize the control inode/socket for handling OOTB packets.  */
 	if ((status = sctp_ctl_sock_init())) {
 		printk (KERN_ERR
 			"SCTP: Failed to initialize the SCTP control sock.\n");
 		goto err_ctl_sock_init;
 	}
 	/* Initialize the local address list. */
 	INIT_LIST_HEAD(&sctp_local_addr_list);
 	spin_lock_init(&sctp_local_addr_lock);
 	/* Register notifier for inet address additions/deletions. */
 	register_inetaddr_notifier(&sctp_inetaddr_notifier);
 	sctp_get_local_addr_list();
 	__unsafe(THIS_MODULE);
 	status = 0;
 out:
 	return status;
 err_ctl_sock_init:
 	sctp_v6_exit();
 err_v6_init:
 	sctp_sysctl_unregister();
 	list_del(&sctp_ipv4_specific.list);
 	free_pages((unsigned long)sctp_port_hashtable,
 		   get_order(sctp_port_hashsize *
 			     sizeof(struct sctp_bind_hashbucket)));
 err_bhash_alloc:
 	kfree(sctp_ep_hashtable);
 err_ehash_alloc:
 	free_pages((unsigned long)sctp_assoc_hashtable,
 		   get_order(sctp_assoc_hashsize *
 			     sizeof(struct sctp_hashbucket)));
 err_ahash_alloc:
 	sctp_dbg_objcnt_exit();
 err_init_proc:
 	sctp_proc_exit();
 	cleanup_sctp_mibs();
 err_init_mibs:
 	kmem_cache_destroy(sctp_chunk_cachep);
 err_chunk_cachep:
 	kmem_cache_destroy(sctp_bucket_cachep);
 err_bucket_cachep:
 	inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
 	inet_unregister_protosw(&sctp_seqpacket_protosw);
 	inet_unregister_protosw(&sctp_stream_protosw);
 err_add_protocol:
 	proto_unregister(&sctp_prot);
 	goto out;
 }
 /* Exit handler for the SCTP protocol.  */
 SCTP_STATIC __exit void sctp_exit(void)
 {
 	/* BUG.  This should probably do something useful like clean
 	 * up all the remaining associations and all that memory.
 	 */
 	/* Unregister notifier for inet address additions/deletions. */
 	unregister_inetaddr_notifier(&sctp_inetaddr_notifier);
 	/* Free the local address list.  */
 	sctp_free_local_addr_list();
 	/* Free the control endpoint.  */
 	sock_release(sctp_ctl_socket);
 	sctp_v6_exit();
 	sctp_sysctl_unregister();
 	list_del(&sctp_ipv4_specific.list);
 	free_pages((unsigned long)sctp_assoc_hashtable,
 		   get_order(sctp_assoc_hashsize *
 			     sizeof(struct sctp_hashbucket)));
 	kfree(sctp_ep_hashtable);
 	free_pages((unsigned long)sctp_port_hashtable,
 		   get_order(sctp_port_hashsize *
 			     sizeof(struct sctp_bind_hashbucket)));
 	kmem_cache_destroy(sctp_chunk_cachep);
 	kmem_cache_destroy(sctp_bucket_cachep);
 	sctp_dbg_objcnt_exit();
 	sctp_proc_exit();
 	cleanup_sctp_mibs();
 	inet_del_protocol(&sctp_protocol, IPPROTO_SCTP);
 	inet_unregister_protosw(&sctp_seqpacket_protosw);
 	inet_unregister_protosw(&sctp_stream_protosw);
 	proto_unregister(&sctp_prot);
 }
 module_init(sctp_init);
 module_exit(sctp_exit);
 /*
  * __stringify doesn't likes enums, so use IPPROTO_SCTP value (132) directly.
  */
 MODULE_ALIAS("net-pf-" __stringify(PF_INET) "-proto-132");
 MODULE_AUTHOR("Linux Kernel SCTP developers <lksctp-developers@lists.sourceforge.net>");
 MODULE_DESCRIPTION("Support for the SCTP protocol (RFC2960)");
 MODULE_LICENSE("GPL");

net/sctp/socket.c

Diff comments View file @ 1616436

1	/* SCTP kernel reference Implementation	1	/* SCTP kernel reference Implementation
2	* (C) Copyright IBM Corp. 2001, 2004	2	* (C) Copyright IBM Corp. 2001, 2004
3	* Copyright (c) 1999-2000 Cisco, Inc.	3	* Copyright (c) 1999-2000 Cisco, Inc.
4	* Copyright (c) 1999-2001 Motorola, Inc.	4	* Copyright (c) 1999-2001 Motorola, Inc.
5	* Copyright (c) 2001-2003 Intel Corp.	5	* Copyright (c) 2001-2003 Intel Corp.
6	* Copyright (c) 2001-2002 Nokia, Inc.	6	* Copyright (c) 2001-2002 Nokia, Inc.
7	* Copyright (c) 2001 La Monte H.P. Yarroll	7	* Copyright (c) 2001 La Monte H.P. Yarroll
8	*	8	*
9	* This file is part of the SCTP kernel reference Implementation	9	* This file is part of the SCTP kernel reference Implementation
10	*	10	*
11	* These functions interface with the sockets layer to implement the	11	* These functions interface with the sockets layer to implement the
12	* SCTP Extensions for the Sockets API.	12	* SCTP Extensions for the Sockets API.
13	*	13	*
14	* Note that the descriptions from the specification are USER level	14	* Note that the descriptions from the specification are USER level
15	* functions--this file is the functions which populate the struct proto	15	* functions--this file is the functions which populate the struct proto
16	* for SCTP which is the BOTTOM of the sockets interface.	16	* for SCTP which is the BOTTOM of the sockets interface.
17	*	17	*
18	* The SCTP reference implementation is free software;	18	* The SCTP reference implementation is free software;
19	* you can redistribute it and/or modify it under the terms of	19	* you can redistribute it and/or modify it under the terms of
20	* the GNU General Public License as published by	20	* the GNU General Public License as published by
21	* the Free Software Foundation; either version 2, or (at your option)	21	* the Free Software Foundation; either version 2, or (at your option)
22	* any later version.	22	* any later version.
23	*	23	*
24	* The SCTP reference implementation is distributed in the hope that it	24	* The SCTP reference implementation is distributed in the hope that it
25	* will be useful, but WITHOUT ANY WARRANTY; without even the implied	25	* will be useful, but WITHOUT ANY WARRANTY; without even the implied
26	* ************************	26	* ************************
27	* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	27	* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
28	* See the GNU General Public License for more details.	28	* See the GNU General Public License for more details.
29	*	29	*
30	* You should have received a copy of the GNU General Public License	30	* You should have received a copy of the GNU General Public License
31	* along with GNU CC; see the file COPYING. If not, write to	31	* along with GNU CC; see the file COPYING. If not, write to
32	* the Free Software Foundation, 59 Temple Place - Suite 330,	32	* the Free Software Foundation, 59 Temple Place - Suite 330,
33	* Boston, MA 02111-1307, USA.	33	* Boston, MA 02111-1307, USA.
34	*	34	*
35	* Please send any bug reports or fixes you make to the	35	* Please send any bug reports or fixes you make to the
36	* email address(es):	36	* email address(es):
37	* lksctp developers <lksctp-developers@lists.sourceforge.net>	37	* lksctp developers <lksctp-developers@lists.sourceforge.net>
38	*	38	*
39	* Or submit a bug report through the following website:	39	* Or submit a bug report through the following website:
40	* http://www.sf.net/projects/lksctp	40	* http://www.sf.net/projects/lksctp
41	*	41	*
42	* Written or modified by:	42	* Written or modified by:
43	* La Monte H.P. Yarroll <piggy@acm.org>	43	* La Monte H.P. Yarroll <piggy@acm.org>
44	* Narasimha Budihal <narsi@refcode.org>	44	* Narasimha Budihal <narsi@refcode.org>
45	* Karl Knutson <karl@athena.chicago.il.us>	45	* Karl Knutson <karl@athena.chicago.il.us>
46	* Jon Grimm <jgrimm@us.ibm.com>	46	* Jon Grimm <jgrimm@us.ibm.com>
47	* Xingang Guo <xingang.guo@intel.com>	47	* Xingang Guo <xingang.guo@intel.com>
48	* Daisy Chang <daisyc@us.ibm.com>	48	* Daisy Chang <daisyc@us.ibm.com>
49	* Sridhar Samudrala <samudrala@us.ibm.com>	49	* Sridhar Samudrala <samudrala@us.ibm.com>
50	* Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>	50	* Inaky Perez-Gonzalez <inaky.gonzalez@intel.com>
51	* Ardelle Fan <ardelle.fan@intel.com>	51	* Ardelle Fan <ardelle.fan@intel.com>
52	* Ryan Layer <rmlayer@us.ibm.com>	52	* Ryan Layer <rmlayer@us.ibm.com>
53	* Anup Pemmaiah <pemmaiah@cc.usu.edu>	53	* Anup Pemmaiah <pemmaiah@cc.usu.edu>
54	* Kevin Gao <kevin.gao@intel.com>	54	* Kevin Gao <kevin.gao@intel.com>
55	*	55	*
56	* Any bugs reported given to us we will try to fix... any fixes shared will	56	* Any bugs reported given to us we will try to fix... any fixes shared will
57	* be incorporated into the next SCTP release.	57	* be incorporated into the next SCTP release.
58	*/	58	*/
59		59
60	#include <linux/types.h>	60	#include <linux/types.h>
61	#include <linux/kernel.h>	61	#include <linux/kernel.h>
62	#include <linux/wait.h>	62	#include <linux/wait.h>
63	#include <linux/time.h>	63	#include <linux/time.h>
64	#include <linux/ip.h>	64	#include <linux/ip.h>
65	#include <linux/capability.h>	65	#include <linux/capability.h>
66	#include <linux/fcntl.h>	66	#include <linux/fcntl.h>
67	#include <linux/poll.h>	67	#include <linux/poll.h>
68	#include <linux/init.h>	68	#include <linux/init.h>
69	#include <linux/crypto.h>	69	#include <linux/crypto.h>
70		70
71	#include <net/ip.h>	71	#include <net/ip.h>
72	#include <net/icmp.h>	72	#include <net/icmp.h>
73	#include <net/route.h>	73	#include <net/route.h>
74	#include <net/ipv6.h>	74	#include <net/ipv6.h>
75	#include <net/inet_common.h>	75	#include <net/inet_common.h>
76		76
77	#include <linux/socket.h> /* for sa_family_t */	77	#include <linux/socket.h> /* for sa_family_t */
78	#include <net/sock.h>	78	#include <net/sock.h>
79	#include <net/sctp/sctp.h>	79	#include <net/sctp/sctp.h>
80	#include <net/sctp/sm.h>	80	#include <net/sctp/sm.h>
81		81
82	/* WARNING: Please do not remove the SCTP_STATIC attribute to	82	/* WARNING: Please do not remove the SCTP_STATIC attribute to
83	* any of the functions below as they are used to export functions	83	* any of the functions below as they are used to export functions
84	* used by a project regression testsuite.	84	* used by a project regression testsuite.
85	*/	85	*/
86		86
87	/* Forward declarations for internal helper functions. */	87	/* Forward declarations for internal helper functions. */
88	static int sctp_writeable(struct sock *sk);	88	static int sctp_writeable(struct sock *sk);
89	static void sctp_wfree(struct sk_buff *skb);	89	static void sctp_wfree(struct sk_buff *skb);
90	static int sctp_wait_for_sndbuf(struct sctp_association , long timeo_p,	90	static int sctp_wait_for_sndbuf(struct sctp_association , long timeo_p,
91	size_t msg_len);	91	size_t msg_len);
92	static int sctp_wait_for_packet(struct sock * sk, int err, long timeo_p);	92	static int sctp_wait_for_packet(struct sock * sk, int err, long timeo_p);
93	static int sctp_wait_for_connect(struct sctp_association , long timeo_p);	93	static int sctp_wait_for_connect(struct sctp_association , long timeo_p);
94	static int sctp_wait_for_accept(struct sock *sk, long timeo);	94	static int sctp_wait_for_accept(struct sock *sk, long timeo);
95	static void sctp_wait_for_close(struct sock *sk, long timeo);	95	static void sctp_wait_for_close(struct sock *sk, long timeo);
96	static struct sctp_af sctp_sockaddr_af(struct sctp_sock opt,	96	static struct sctp_af sctp_sockaddr_af(struct sctp_sock opt,
97	union sctp_addr *addr, int len);	97	union sctp_addr *addr, int len);
98	static int sctp_bindx_add(struct sock , struct sockaddr , int);	98	static int sctp_bindx_add(struct sock , struct sockaddr , int);
99	static int sctp_bindx_rem(struct sock , struct sockaddr , int);	99	static int sctp_bindx_rem(struct sock , struct sockaddr , int);
100	static int sctp_send_asconf_add_ip(struct sock , struct sockaddr , int);	100	static int sctp_send_asconf_add_ip(struct sock , struct sockaddr , int);
101	static int sctp_send_asconf_del_ip(struct sock , struct sockaddr , int);	101	static int sctp_send_asconf_del_ip(struct sock , struct sockaddr , int);
102	static int sctp_send_asconf(struct sctp_association *asoc,	102	static int sctp_send_asconf(struct sctp_association *asoc,
103	struct sctp_chunk *chunk);	103	struct sctp_chunk *chunk);
104	static int sctp_do_bind(struct sock , union sctp_addr , int);	104	static int sctp_do_bind(struct sock , union sctp_addr , int);
105	static int sctp_autobind(struct sock *sk);	105	static int sctp_autobind(struct sock *sk);
106	static void sctp_sock_migrate(struct sock , struct sock ,	106	static void sctp_sock_migrate(struct sock , struct sock ,
107	struct sctp_association *, sctp_socket_type_t);	107	struct sctp_association *, sctp_socket_type_t);
108	static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG;	108	static char *sctp_hmac_alg = SCTP_COOKIE_HMAC_ALG;
109		109
110	extern kmem_cache_t *sctp_bucket_cachep;	110	extern kmem_cache_t *sctp_bucket_cachep;
111		111
112	/* Get the sndbuf space available at the time on the association. */	112	/* Get the sndbuf space available at the time on the association. */
113	static inline int sctp_wspace(struct sctp_association *asoc)	113	static inline int sctp_wspace(struct sctp_association *asoc)
114	{	114	{
115	struct sock *sk = asoc->base.sk;	115	struct sock *sk = asoc->base.sk;
116	int amt = 0;	116	int amt = 0;
117		117
118	if (asoc->ep->sndbuf_policy) {	118	if (asoc->ep->sndbuf_policy) {
119	/* make sure that no association uses more than sk_sndbuf */	119	/* make sure that no association uses more than sk_sndbuf */
120	amt = sk->sk_sndbuf - asoc->sndbuf_used;	120	amt = sk->sk_sndbuf - asoc->sndbuf_used;
121	} else {	121	} else {
122	/* do socket level accounting */	122	/* do socket level accounting */
123	amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);	123	amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
124	}	124	}
125		125
126	if (amt < 0)	126	if (amt < 0)
127	amt = 0;	127	amt = 0;
128		128
129	return amt;	129	return amt;
130	}	130	}
131		131
132	/* Increment the used sndbuf space count of the corresponding association by	132	/* Increment the used sndbuf space count of the corresponding association by
133	* the size of the outgoing data chunk.	133	* the size of the outgoing data chunk.
134	* Also, set the skb destructor for sndbuf accounting later.	134	* Also, set the skb destructor for sndbuf accounting later.
135	*	135	*
136	* Since it is always 1-1 between chunk and skb, and also a new skb is always	136	* Since it is always 1-1 between chunk and skb, and also a new skb is always
137	* allocated for chunk bundling in sctp_packet_transmit(), we can use the	137	* allocated for chunk bundling in sctp_packet_transmit(), we can use the
138	* destructor in the data chunk skb for the purpose of the sndbuf space	138	* destructor in the data chunk skb for the purpose of the sndbuf space
139	* tracking.	139	* tracking.
140	*/	140	*/
141	static inline void sctp_set_owner_w(struct sctp_chunk *chunk)	141	static inline void sctp_set_owner_w(struct sctp_chunk *chunk)
142	{	142	{
143	struct sctp_association *asoc = chunk->asoc;	143	struct sctp_association *asoc = chunk->asoc;
144	struct sock *sk = asoc->base.sk;	144	struct sock *sk = asoc->base.sk;
145		145
146	/* The sndbuf space is tracked per association. */	146	/* The sndbuf space is tracked per association. */
147	sctp_association_hold(asoc);	147	sctp_association_hold(asoc);
148		148
149	skb_set_owner_w(chunk->skb, sk);	149	skb_set_owner_w(chunk->skb, sk);
150		150
151	chunk->skb->destructor = sctp_wfree;	151	chunk->skb->destructor = sctp_wfree;
152	/* Save the chunk pointer in skb for sctp_wfree to use later. */	152	/* Save the chunk pointer in skb for sctp_wfree to use later. */
153	((struct sctp_chunk *)(chunk->skb->cb)) = chunk;	153	((struct sctp_chunk *)(chunk->skb->cb)) = chunk;
154		154
155	asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +	155	asoc->sndbuf_used += SCTP_DATA_SNDSIZE(chunk) +
156	sizeof(struct sk_buff) +	156	sizeof(struct sk_buff) +
157	sizeof(struct sctp_chunk);	157	sizeof(struct sctp_chunk);
158		158
159	atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);	159	atomic_add(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
160	}	160	}
161		161
162	/* Verify that this is a valid address. */	162	/* Verify that this is a valid address. */
163	static inline int sctp_verify_addr(struct sock sk, union sctp_addr addr,	163	static inline int sctp_verify_addr(struct sock sk, union sctp_addr addr,
164	int len)	164	int len)
165	{	165	{
166	struct sctp_af *af;	166	struct sctp_af *af;
167		167
168	/* Verify basic sockaddr. */	168	/* Verify basic sockaddr. */
169	af = sctp_sockaddr_af(sctp_sk(sk), addr, len);	169	af = sctp_sockaddr_af(sctp_sk(sk), addr, len);
170	if (!af)	170	if (!af)
171	return -EINVAL;	171	return -EINVAL;
172		172
173	/* Is this a valid SCTP address? */	173	/* Is this a valid SCTP address? */
174	if (!af->addr_valid(addr, sctp_sk(sk), NULL))	174	if (!af->addr_valid(addr, sctp_sk(sk), NULL))
175	return -EINVAL;	175	return -EINVAL;
176		176
177	if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))	177	if (!sctp_sk(sk)->pf->send_verify(sctp_sk(sk), (addr)))
178	return -EINVAL;	178	return -EINVAL;
179		179
180	return 0;	180	return 0;
181	}	181	}
182		182
183	/* Look up the association by its id. If this is not a UDP-style	183	/* Look up the association by its id. If this is not a UDP-style
184	* socket, the ID field is always ignored.	184	* socket, the ID field is always ignored.
185	*/	185	*/
186	struct sctp_association sctp_id2assoc(struct sock sk, sctp_assoc_t id)	186	struct sctp_association sctp_id2assoc(struct sock sk, sctp_assoc_t id)
187	{	187	{
188	struct sctp_association *asoc = NULL;	188	struct sctp_association *asoc = NULL;
189		189
190	/* If this is not a UDP-style socket, assoc id should be ignored. */	190	/* If this is not a UDP-style socket, assoc id should be ignored. */
191	if (!sctp_style(sk, UDP)) {	191	if (!sctp_style(sk, UDP)) {
192	/* Return NULL if the socket state is not ESTABLISHED. It	192	/* Return NULL if the socket state is not ESTABLISHED. It
193	* could be a TCP-style listening socket or a socket which	193	* could be a TCP-style listening socket or a socket which
194	* hasn't yet called connect() to establish an association.	194	* hasn't yet called connect() to establish an association.
195	*/	195	*/
196	if (!sctp_sstate(sk, ESTABLISHED))	196	if (!sctp_sstate(sk, ESTABLISHED))
197	return NULL;	197	return NULL;
198		198
199	/* Get the first and the only association from the list. */	199	/* Get the first and the only association from the list. */
200	if (!list_empty(&sctp_sk(sk)->ep->asocs))	200	if (!list_empty(&sctp_sk(sk)->ep->asocs))
201	asoc = list_entry(sctp_sk(sk)->ep->asocs.next,	201	asoc = list_entry(sctp_sk(sk)->ep->asocs.next,
202	struct sctp_association, asocs);	202	struct sctp_association, asocs);
203	return asoc;	203	return asoc;
204	}	204	}
205		205
206	/* Otherwise this is a UDP-style socket. */	206	/* Otherwise this is a UDP-style socket. */
207	if (!id \|\| (id == (sctp_assoc_t)-1))	207	if (!id \|\| (id == (sctp_assoc_t)-1))
208	return NULL;	208	return NULL;
209		209
210	spin_lock_bh(&sctp_assocs_id_lock);	210	spin_lock_bh(&sctp_assocs_id_lock);
211	asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);	211	asoc = (struct sctp_association *)idr_find(&sctp_assocs_id, (int)id);
212	spin_unlock_bh(&sctp_assocs_id_lock);	212	spin_unlock_bh(&sctp_assocs_id_lock);
213		213
214	if (!asoc \|\| (asoc->base.sk != sk) \|\| asoc->base.dead)	214	if (!asoc \|\| (asoc->base.sk != sk) \|\| asoc->base.dead)
215	return NULL;	215	return NULL;
216		216
217	return asoc;	217	return asoc;
218	}	218	}
219		219
220	/* Look up the transport from an address and an assoc id. If both address and	220	/* Look up the transport from an address and an assoc id. If both address and
221	* id are specified, the associations matching the address and the id should be	221	* id are specified, the associations matching the address and the id should be
222	* the same.	222	* the same.
223	*/	223	*/
224	static struct sctp_transport sctp_addr_id2transport(struct sock sk,	224	static struct sctp_transport sctp_addr_id2transport(struct sock sk,
225	struct sockaddr_storage *addr,	225	struct sockaddr_storage *addr,
226	sctp_assoc_t id)	226	sctp_assoc_t id)
227	{	227	{
228	struct sctp_association addr_asoc = NULL, id_asoc = NULL;	228	struct sctp_association addr_asoc = NULL, id_asoc = NULL;
229	struct sctp_transport *transport;	229	struct sctp_transport *transport;
230	union sctp_addr laddr = (union sctp_addr )addr;	230	union sctp_addr laddr = (union sctp_addr )addr;
231		231
232	laddr->v4.sin_port = ntohs(laddr->v4.sin_port);	232	laddr->v4.sin_port = ntohs(laddr->v4.sin_port);
233	addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,	233	addr_asoc = sctp_endpoint_lookup_assoc(sctp_sk(sk)->ep,
234	(union sctp_addr *)addr,	234	(union sctp_addr *)addr,
235	&transport);	235	&transport);
236	laddr->v4.sin_port = htons(laddr->v4.sin_port);	236	laddr->v4.sin_port = htons(laddr->v4.sin_port);
237		237
238	if (!addr_asoc)	238	if (!addr_asoc)
239	return NULL;	239	return NULL;
240		240
241	id_asoc = sctp_id2assoc(sk, id);	241	id_asoc = sctp_id2assoc(sk, id);
242	if (id_asoc && (id_asoc != addr_asoc))	242	if (id_asoc && (id_asoc != addr_asoc))
243	return NULL;	243	return NULL;
244		244
245	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),	245	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
246	(union sctp_addr *)addr);	246	(union sctp_addr *)addr);
247		247
248	return transport;	248	return transport;
249	}	249	}
250		250
251	/* API 3.1.2 bind() - UDP Style Syntax	251	/* API 3.1.2 bind() - UDP Style Syntax
252	* The syntax of bind() is,	252	* The syntax of bind() is,
253	*	253	*
254	* ret = bind(int sd, struct sockaddr *addr, int addrlen);	254	* ret = bind(int sd, struct sockaddr *addr, int addrlen);
255	*	255	*
256	* sd - the socket descriptor returned by socket().	256	* sd - the socket descriptor returned by socket().
257	* addr - the address structure (struct sockaddr_in or struct	257	* addr - the address structure (struct sockaddr_in or struct
258	* sockaddr_in6 [RFC 2553]),	258	* sockaddr_in6 [RFC 2553]),
259	* addr_len - the size of the address structure.	259	* addr_len - the size of the address structure.
260	*/	260	*/
261	SCTP_STATIC int sctp_bind(struct sock sk, struct sockaddr addr, int addr_len)	261	SCTP_STATIC int sctp_bind(struct sock sk, struct sockaddr addr, int addr_len)
262	{	262	{
263	int retval = 0;	263	int retval = 0;
264		264
265	sctp_lock_sock(sk);	265	sctp_lock_sock(sk);
266		266
267	SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n",	267	SCTP_DEBUG_PRINTK("sctp_bind(sk: %p, addr: %p, addr_len: %d)\n",
268	sk, addr, addr_len);	268	sk, addr, addr_len);
269		269
270	/* Disallow binding twice. */	270	/* Disallow binding twice. */
271	if (!sctp_sk(sk)->ep->base.bind_addr.port)	271	if (!sctp_sk(sk)->ep->base.bind_addr.port)
272	retval = sctp_do_bind(sk, (union sctp_addr *)addr,	272	retval = sctp_do_bind(sk, (union sctp_addr *)addr,
273	addr_len);	273	addr_len);
274	else	274	else
275	retval = -EINVAL;	275	retval = -EINVAL;
276		276
277	sctp_release_sock(sk);	277	sctp_release_sock(sk);
278		278
279	return retval;	279	return retval;
280	}	280	}
281		281
282	static long sctp_get_port_local(struct sock , union sctp_addr );	282	static long sctp_get_port_local(struct sock , union sctp_addr );
283		283
284	/* Verify this is a valid sockaddr. */	284	/* Verify this is a valid sockaddr. */
285	static struct sctp_af sctp_sockaddr_af(struct sctp_sock opt,	285	static struct sctp_af sctp_sockaddr_af(struct sctp_sock opt,
286	union sctp_addr *addr, int len)	286	union sctp_addr *addr, int len)
287	{	287	{
288	struct sctp_af *af;	288	struct sctp_af *af;
289		289
290	/* Check minimum size. */	290	/* Check minimum size. */
291	if (len < sizeof (struct sockaddr))	291	if (len < sizeof (struct sockaddr))
292	return NULL;	292	return NULL;
293		293
294	/* Does this PF support this AF? */	294	/* Does this PF support this AF? */
295	if (!opt->pf->af_supported(addr->sa.sa_family, opt))	295	if (!opt->pf->af_supported(addr->sa.sa_family, opt))
296	return NULL;	296	return NULL;
297		297
298	/* If we get this far, af is valid. */	298	/* If we get this far, af is valid. */
299	af = sctp_get_af_specific(addr->sa.sa_family);	299	af = sctp_get_af_specific(addr->sa.sa_family);
300		300
301	if (len < af->sockaddr_len)	301	if (len < af->sockaddr_len)
302	return NULL;	302	return NULL;
303		303
304	return af;	304	return af;
305	}	305	}
306		306
307	/* Bind a local address either to an endpoint or to an association. */	307	/* Bind a local address either to an endpoint or to an association. */
308	SCTP_STATIC int sctp_do_bind(struct sock sk, union sctp_addr addr, int len)	308	SCTP_STATIC int sctp_do_bind(struct sock sk, union sctp_addr addr, int len)
309	{	309	{
310	struct sctp_sock *sp = sctp_sk(sk);	310	struct sctp_sock *sp = sctp_sk(sk);
311	struct sctp_endpoint *ep = sp->ep;	311	struct sctp_endpoint *ep = sp->ep;
312	struct sctp_bind_addr *bp = &ep->base.bind_addr;	312	struct sctp_bind_addr *bp = &ep->base.bind_addr;
313	struct sctp_af *af;	313	struct sctp_af *af;
314	unsigned short snum;	314	unsigned short snum;
315	int ret = 0;	315	int ret = 0;
316		316
317	/* Common sockaddr verification. */	317	/* Common sockaddr verification. */
318	af = sctp_sockaddr_af(sp, addr, len);	318	af = sctp_sockaddr_af(sp, addr, len);
319	if (!af) {	319	if (!af) {
320	SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n",	320	SCTP_DEBUG_PRINTK("sctp_do_bind(sk: %p, newaddr: %p, len: %d) EINVAL\n",
321	sk, addr, len);	321	sk, addr, len);
322	return -EINVAL;	322	return -EINVAL;
323	}	323	}
324		324
325	snum = ntohs(addr->v4.sin_port);	325	snum = ntohs(addr->v4.sin_port);
326		326
327	SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ",	327	SCTP_DEBUG_PRINTK_IPADDR("sctp_do_bind(sk: %p, new addr: ",
328	", port: %d, new port: %d, len: %d)\n",	328	", port: %d, new port: %d, len: %d)\n",
329	sk,	329	sk,
330	addr,	330	addr,
331	bp->port, snum,	331	bp->port, snum,
332	len);	332	len);
333		333
334	/* PF specific bind() address verification. */	334	/* PF specific bind() address verification. */
335	if (!sp->pf->bind_verify(sp, addr))	335	if (!sp->pf->bind_verify(sp, addr))
336	return -EADDRNOTAVAIL;	336	return -EADDRNOTAVAIL;
337		337
338	/* We must either be unbound, or bind to the same port. */	338	/* We must either be unbound, or bind to the same port. */
339	if (bp->port && (snum != bp->port)) {	339	if (bp->port && (snum != bp->port)) {
340	SCTP_DEBUG_PRINTK("sctp_do_bind:"	340	SCTP_DEBUG_PRINTK("sctp_do_bind:"
341	" New port %d does not match existing port "	341	" New port %d does not match existing port "
342	"%d.\n", snum, bp->port);	342	"%d.\n", snum, bp->port);
343	return -EINVAL;	343	return -EINVAL;
344	}	344	}
345		345
346	if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))	346	if (snum && snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
347	return -EACCES;	347	return -EACCES;
348		348
349	/* Make sure we are allowed to bind here.	349	/* Make sure we are allowed to bind here.
350	* The function sctp_get_port_local() does duplicate address	350	* The function sctp_get_port_local() does duplicate address
351	* detection.	351	* detection.
352	*/	352	*/
353	if ((ret = sctp_get_port_local(sk, addr))) {	353	if ((ret = sctp_get_port_local(sk, addr))) {
354	if (ret == (long) sk) {	354	if (ret == (long) sk) {
355	/* This endpoint has a conflicting address. */	355	/* This endpoint has a conflicting address. */
356	return -EINVAL;	356	return -EINVAL;
357	} else {	357	} else {
358	return -EADDRINUSE;	358	return -EADDRINUSE;
359	}	359	}
360	}	360	}
361		361
362	/* Refresh ephemeral port. */	362	/* Refresh ephemeral port. */
363	if (!bp->port)	363	if (!bp->port)
364	bp->port = inet_sk(sk)->num;	364	bp->port = inet_sk(sk)->num;
365		365
366	/* Add the address to the bind address list. */	366	/* Add the address to the bind address list. */
367	sctp_local_bh_disable();	367	sctp_local_bh_disable();
368	sctp_write_lock(&ep->base.addr_lock);	368	sctp_write_lock(&ep->base.addr_lock);
369		369
370	/* Use GFP_ATOMIC since BHs are disabled. */	370	/* Use GFP_ATOMIC since BHs are disabled. */
371	addr->v4.sin_port = ntohs(addr->v4.sin_port);	371	addr->v4.sin_port = ntohs(addr->v4.sin_port);
372	ret = sctp_add_bind_addr(bp, addr, 1, GFP_ATOMIC);	372	ret = sctp_add_bind_addr(bp, addr, 1, GFP_ATOMIC);
373	addr->v4.sin_port = htons(addr->v4.sin_port);	373	addr->v4.sin_port = htons(addr->v4.sin_port);
374	sctp_write_unlock(&ep->base.addr_lock);	374	sctp_write_unlock(&ep->base.addr_lock);
375	sctp_local_bh_enable();	375	sctp_local_bh_enable();
376		376
377	/* Copy back into socket for getsockname() use. */	377	/* Copy back into socket for getsockname() use. */
378	if (!ret) {	378	if (!ret) {
379	inet_sk(sk)->sport = htons(inet_sk(sk)->num);	379	inet_sk(sk)->sport = htons(inet_sk(sk)->num);
380	af->to_sk_saddr(addr, sk);	380	af->to_sk_saddr(addr, sk);
381	}	381	}
382		382
383	return ret;	383	return ret;
384	}	384	}
385		385
386	/* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks	386	/* ADDIP Section 4.1.1 Congestion Control of ASCONF Chunks
387	*	387	*
388	* R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged	388	* R1) One and only one ASCONF Chunk MAY be in transit and unacknowledged
389	* at any one time. If a sender, after sending an ASCONF chunk, decides	389	* at any one time. If a sender, after sending an ASCONF chunk, decides
390	* it needs to transfer another ASCONF Chunk, it MUST wait until the	390	* it needs to transfer another ASCONF Chunk, it MUST wait until the
391	* ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a	391	* ASCONF-ACK Chunk returns from the previous ASCONF Chunk before sending a
392	* subsequent ASCONF. Note this restriction binds each side, so at any	392	* subsequent ASCONF. Note this restriction binds each side, so at any
393	* time two ASCONF may be in-transit on any given association (one sent	393	* time two ASCONF may be in-transit on any given association (one sent
394	* from each endpoint).	394	* from each endpoint).
395	*/	395	*/
396	static int sctp_send_asconf(struct sctp_association *asoc,	396	static int sctp_send_asconf(struct sctp_association *asoc,
397	struct sctp_chunk *chunk)	397	struct sctp_chunk *chunk)
398	{	398	{
399	int retval = 0;	399	int retval = 0;
400		400
401	/* If there is an outstanding ASCONF chunk, queue it for later	401	/* If there is an outstanding ASCONF chunk, queue it for later
402	* transmission.	402	* transmission.
403	*/	403	*/
404	if (asoc->addip_last_asconf) {	404	if (asoc->addip_last_asconf) {
405	list_add_tail(&chunk->list, &asoc->addip_chunk_list);	405	list_add_tail(&chunk->list, &asoc->addip_chunk_list);
406	goto out;	406	goto out;
407	}	407	}
408		408
409	/* Hold the chunk until an ASCONF_ACK is received. */	409	/* Hold the chunk until an ASCONF_ACK is received. */
410	sctp_chunk_hold(chunk);	410	sctp_chunk_hold(chunk);
411	retval = sctp_primitive_ASCONF(asoc, chunk);	411	retval = sctp_primitive_ASCONF(asoc, chunk);
412	if (retval)	412	if (retval)
413	sctp_chunk_free(chunk);	413	sctp_chunk_free(chunk);
414	else	414	else
415	asoc->addip_last_asconf = chunk;	415	asoc->addip_last_asconf = chunk;
416		416
417	out:	417	out:
418	return retval;	418	return retval;
419	}	419	}
420		420
421	/* Add a list of addresses as bind addresses to local endpoint or	421	/* Add a list of addresses as bind addresses to local endpoint or
422	* association.	422	* association.
423	*	423	*
424	* Basically run through each address specified in the addrs/addrcnt	424	* Basically run through each address specified in the addrs/addrcnt
425	* array/length pair, determine if it is IPv6 or IPv4 and call	425	* array/length pair, determine if it is IPv6 or IPv4 and call
426	* sctp_do_bind() on it.	426	* sctp_do_bind() on it.
427	*	427	*
428	* If any of them fails, then the operation will be reversed and the	428	* If any of them fails, then the operation will be reversed and the
429	* ones that were added will be removed.	429	* ones that were added will be removed.
430	*	430	*
431	* Only sctp_setsockopt_bindx() is supposed to call this function.	431	* Only sctp_setsockopt_bindx() is supposed to call this function.
432	*/	432	*/
433	int sctp_bindx_add(struct sock sk, struct sockaddr addrs, int addrcnt)	433	int sctp_bindx_add(struct sock sk, struct sockaddr addrs, int addrcnt)
434	{	434	{
435	int cnt;	435	int cnt;
436	int retval = 0;	436	int retval = 0;
437	void *addr_buf;	437	void *addr_buf;
438	struct sockaddr *sa_addr;	438	struct sockaddr *sa_addr;
439	struct sctp_af *af;	439	struct sctp_af *af;
440		440
441	SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n",	441	SCTP_DEBUG_PRINTK("sctp_bindx_add (sk: %p, addrs: %p, addrcnt: %d)\n",
442	sk, addrs, addrcnt);	442	sk, addrs, addrcnt);
443		443
444	addr_buf = addrs;	444	addr_buf = addrs;
445	for (cnt = 0; cnt < addrcnt; cnt++) {	445	for (cnt = 0; cnt < addrcnt; cnt++) {
446	/* The list may contain either IPv4 or IPv6 address;	446	/* The list may contain either IPv4 or IPv6 address;
447	* determine the address length for walking thru the list.	447	* determine the address length for walking thru the list.
448	*/	448	*/
449	sa_addr = (struct sockaddr *)addr_buf;	449	sa_addr = (struct sockaddr *)addr_buf;
450	af = sctp_get_af_specific(sa_addr->sa_family);	450	af = sctp_get_af_specific(sa_addr->sa_family);
451	if (!af) {	451	if (!af) {
452	retval = -EINVAL;	452	retval = -EINVAL;
453	goto err_bindx_add;	453	goto err_bindx_add;
454	}	454	}
455		455
456	retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,	456	retval = sctp_do_bind(sk, (union sctp_addr *)sa_addr,
457	af->sockaddr_len);	457	af->sockaddr_len);
458		458
459	addr_buf += af->sockaddr_len;	459	addr_buf += af->sockaddr_len;
460		460
461	err_bindx_add:	461	err_bindx_add:
462	if (retval < 0) {	462	if (retval < 0) {
463	/* Failed. Cleanup the ones that have been added */	463	/* Failed. Cleanup the ones that have been added */
464	if (cnt > 0)	464	if (cnt > 0)
465	sctp_bindx_rem(sk, addrs, cnt);	465	sctp_bindx_rem(sk, addrs, cnt);
466	return retval;	466	return retval;
467	}	467	}
468	}	468	}
469		469
470	return retval;	470	return retval;
471	}	471	}
472		472
473	/* Send an ASCONF chunk with Add IP address parameters to all the peers of the	473	/* Send an ASCONF chunk with Add IP address parameters to all the peers of the
474	* associations that are part of the endpoint indicating that a list of local	474	* associations that are part of the endpoint indicating that a list of local
475	* addresses are added to the endpoint.	475	* addresses are added to the endpoint.
476	*	476	*
477	* If any of the addresses is already in the bind address list of the	477	* If any of the addresses is already in the bind address list of the
478	* association, we do not send the chunk for that association. But it will not	478	* association, we do not send the chunk for that association. But it will not
479	* affect other associations.	479	* affect other associations.
480	*	480	*
481	* Only sctp_setsockopt_bindx() is supposed to call this function.	481	* Only sctp_setsockopt_bindx() is supposed to call this function.
482	*/	482	*/
483	static int sctp_send_asconf_add_ip(struct sock *sk,	483	static int sctp_send_asconf_add_ip(struct sock *sk,
484	struct sockaddr *addrs,	484	struct sockaddr *addrs,
485	int addrcnt)	485	int addrcnt)
486	{	486	{
487	struct sctp_sock *sp;	487	struct sctp_sock *sp;
488	struct sctp_endpoint *ep;	488	struct sctp_endpoint *ep;
489	struct sctp_association *asoc;	489	struct sctp_association *asoc;
490	struct sctp_bind_addr *bp;	490	struct sctp_bind_addr *bp;
491	struct sctp_chunk *chunk;	491	struct sctp_chunk *chunk;
492	struct sctp_sockaddr_entry *laddr;	492	struct sctp_sockaddr_entry *laddr;
493	union sctp_addr *addr;	493	union sctp_addr *addr;
494	union sctp_addr saveaddr;	494	union sctp_addr saveaddr;
495	void *addr_buf;	495	void *addr_buf;
496	struct sctp_af *af;	496	struct sctp_af *af;
497	struct list_head *pos;	497	struct list_head *pos;
498	struct list_head *p;	498	struct list_head *p;
499	int i;	499	int i;
500	int retval = 0;	500	int retval = 0;
501		501
502	if (!sctp_addip_enable)	502	if (!sctp_addip_enable)
503	return retval;	503	return retval;
504		504
505	sp = sctp_sk(sk);	505	sp = sctp_sk(sk);
506	ep = sp->ep;	506	ep = sp->ep;
507		507
508	SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",	508	SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
509	__FUNCTION__, sk, addrs, addrcnt);	509	__FUNCTION__, sk, addrs, addrcnt);
510		510
511	list_for_each(pos, &ep->asocs) {	511	list_for_each(pos, &ep->asocs) {
512	asoc = list_entry(pos, struct sctp_association, asocs);	512	asoc = list_entry(pos, struct sctp_association, asocs);
513		513
514	if (!asoc->peer.asconf_capable)	514	if (!asoc->peer.asconf_capable)
515	continue;	515	continue;
516		516
517	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)	517	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_ADD_IP)
518	continue;	518	continue;
519		519
520	if (!sctp_state(asoc, ESTABLISHED))	520	if (!sctp_state(asoc, ESTABLISHED))
521	continue;	521	continue;
522		522
523	/* Check if any address in the packed array of addresses is	523	/* Check if any address in the packed array of addresses is
524	* in the bind address list of the association. If so,	524	* in the bind address list of the association. If so,
525	* do not send the asconf chunk to its peer, but continue with	525	* do not send the asconf chunk to its peer, but continue with
526	* other associations.	526	* other associations.
527	*/	527	*/
528	addr_buf = addrs;	528	addr_buf = addrs;
529	for (i = 0; i < addrcnt; i++) {	529	for (i = 0; i < addrcnt; i++) {
530	addr = (union sctp_addr *)addr_buf;	530	addr = (union sctp_addr *)addr_buf;
531	af = sctp_get_af_specific(addr->v4.sin_family);	531	af = sctp_get_af_specific(addr->v4.sin_family);
532	if (!af) {	532	if (!af) {
533	retval = -EINVAL;	533	retval = -EINVAL;
534	goto out;	534	goto out;
535	}	535	}
536		536
537	if (sctp_assoc_lookup_laddr(asoc, addr))	537	if (sctp_assoc_lookup_laddr(asoc, addr))
538	break;	538	break;
539		539
540	addr_buf += af->sockaddr_len;	540	addr_buf += af->sockaddr_len;
541	}	541	}
542	if (i < addrcnt)	542	if (i < addrcnt)
543	continue;	543	continue;
544		544
545	/* Use the first address in bind addr list of association as	545	/* Use the first address in bind addr list of association as
546	* Address Parameter of ASCONF CHUNK.	546	* Address Parameter of ASCONF CHUNK.
547	*/	547	*/
548	sctp_read_lock(&asoc->base.addr_lock);	548	sctp_read_lock(&asoc->base.addr_lock);
549	bp = &asoc->base.bind_addr;	549	bp = &asoc->base.bind_addr;
550	p = bp->address_list.next;	550	p = bp->address_list.next;
551	laddr = list_entry(p, struct sctp_sockaddr_entry, list);	551	laddr = list_entry(p, struct sctp_sockaddr_entry, list);
552	sctp_read_unlock(&asoc->base.addr_lock);	552	sctp_read_unlock(&asoc->base.addr_lock);
553		553
554	chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,	554	chunk = sctp_make_asconf_update_ip(asoc, &laddr->a, addrs,
555	addrcnt, SCTP_PARAM_ADD_IP);	555	addrcnt, SCTP_PARAM_ADD_IP);
556	if (!chunk) {	556	if (!chunk) {
557	retval = -ENOMEM;	557	retval = -ENOMEM;
558	goto out;	558	goto out;
559	}	559	}
560		560
561	retval = sctp_send_asconf(asoc, chunk);	561	retval = sctp_send_asconf(asoc, chunk);
562	if (retval)	562	if (retval)
563	goto out;	563	goto out;
564		564
565	/* Add the new addresses to the bind address list with	565	/* Add the new addresses to the bind address list with
566	* use_as_src set to 0.	566	* use_as_src set to 0.
567	*/	567	*/
568	sctp_local_bh_disable();	568	sctp_local_bh_disable();
569	sctp_write_lock(&asoc->base.addr_lock);	569	sctp_write_lock(&asoc->base.addr_lock);
570	addr_buf = addrs;	570	addr_buf = addrs;
571	for (i = 0; i < addrcnt; i++) {	571	for (i = 0; i < addrcnt; i++) {
572	addr = (union sctp_addr *)addr_buf;	572	addr = (union sctp_addr *)addr_buf;
573	af = sctp_get_af_specific(addr->v4.sin_family);	573	af = sctp_get_af_specific(addr->v4.sin_family);
574	memcpy(&saveaddr, addr, af->sockaddr_len);	574	memcpy(&saveaddr, addr, af->sockaddr_len);
575	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);	575	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);
576	retval = sctp_add_bind_addr(bp, &saveaddr, 0,	576	retval = sctp_add_bind_addr(bp, &saveaddr, 0,
577	GFP_ATOMIC);	577	GFP_ATOMIC);
578	addr_buf += af->sockaddr_len;	578	addr_buf += af->sockaddr_len;
579	}	579	}
580	sctp_write_unlock(&asoc->base.addr_lock);	580	sctp_write_unlock(&asoc->base.addr_lock);
581	sctp_local_bh_enable();	581	sctp_local_bh_enable();
582	}	582	}
583		583
584	out:	584	out:
585	return retval;	585	return retval;
586	}	586	}
587		587
588	/* Remove a list of addresses from bind addresses list. Do not remove the	588	/* Remove a list of addresses from bind addresses list. Do not remove the
589	* last address.	589	* last address.
590	*	590	*
591	* Basically run through each address specified in the addrs/addrcnt	591	* Basically run through each address specified in the addrs/addrcnt
592	* array/length pair, determine if it is IPv6 or IPv4 and call	592	* array/length pair, determine if it is IPv6 or IPv4 and call
593	* sctp_del_bind() on it.	593	* sctp_del_bind() on it.
594	*	594	*
595	* If any of them fails, then the operation will be reversed and the	595	* If any of them fails, then the operation will be reversed and the
596	* ones that were removed will be added back.	596	* ones that were removed will be added back.
597	*	597	*
598	* At least one address has to be left; if only one address is	598	* At least one address has to be left; if only one address is
599	* available, the operation will return -EBUSY.	599	* available, the operation will return -EBUSY.
600	*	600	*
601	* Only sctp_setsockopt_bindx() is supposed to call this function.	601	* Only sctp_setsockopt_bindx() is supposed to call this function.
602	*/	602	*/
603	int sctp_bindx_rem(struct sock sk, struct sockaddr addrs, int addrcnt)	603	int sctp_bindx_rem(struct sock sk, struct sockaddr addrs, int addrcnt)
604	{	604	{
605	struct sctp_sock *sp = sctp_sk(sk);	605	struct sctp_sock *sp = sctp_sk(sk);
606	struct sctp_endpoint *ep = sp->ep;	606	struct sctp_endpoint *ep = sp->ep;
607	int cnt;	607	int cnt;
608	struct sctp_bind_addr *bp = &ep->base.bind_addr;	608	struct sctp_bind_addr *bp = &ep->base.bind_addr;
609	int retval = 0;	609	int retval = 0;
610	union sctp_addr saveaddr;	610	union sctp_addr saveaddr;
611	void *addr_buf;	611	void *addr_buf;
612	struct sockaddr *sa_addr;	612	struct sockaddr *sa_addr;
613	struct sctp_af *af;	613	struct sctp_af *af;
614		614
615	SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n",	615	SCTP_DEBUG_PRINTK("sctp_bindx_rem (sk: %p, addrs: %p, addrcnt: %d)\n",
616	sk, addrs, addrcnt);	616	sk, addrs, addrcnt);
617		617
618	addr_buf = addrs;	618	addr_buf = addrs;
619	for (cnt = 0; cnt < addrcnt; cnt++) {	619	for (cnt = 0; cnt < addrcnt; cnt++) {
620	/* If the bind address list is empty or if there is only one	620	/* If the bind address list is empty or if there is only one
621	* bind address, there is nothing more to be removed (we need	621	* bind address, there is nothing more to be removed (we need
622	* at least one address here).	622	* at least one address here).
623	*/	623	*/
624	if (list_empty(&bp->address_list) \|\|	624	if (list_empty(&bp->address_list) \|\|
625	(sctp_list_single_entry(&bp->address_list))) {	625	(sctp_list_single_entry(&bp->address_list))) {
626	retval = -EBUSY;	626	retval = -EBUSY;
627	goto err_bindx_rem;	627	goto err_bindx_rem;
628	}	628	}
629		629
630	/* The list may contain either IPv4 or IPv6 address;	630	/* The list may contain either IPv4 or IPv6 address;
631	* determine the address length to copy the address to	631	* determine the address length to copy the address to
632	* saveaddr.	632	* saveaddr.
633	*/	633	*/
634	sa_addr = (struct sockaddr *)addr_buf;	634	sa_addr = (struct sockaddr *)addr_buf;
635	af = sctp_get_af_specific(sa_addr->sa_family);	635	af = sctp_get_af_specific(sa_addr->sa_family);
636	if (!af) {	636	if (!af) {
637	retval = -EINVAL;	637	retval = -EINVAL;
638	goto err_bindx_rem;	638	goto err_bindx_rem;
639	}	639	}
640	memcpy(&saveaddr, sa_addr, af->sockaddr_len);	640	memcpy(&saveaddr, sa_addr, af->sockaddr_len);
641	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);	641	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);
642	if (saveaddr.v4.sin_port != bp->port) {	642	if (saveaddr.v4.sin_port != bp->port) {
643	retval = -EINVAL;	643	retval = -EINVAL;
644	goto err_bindx_rem;	644	goto err_bindx_rem;
645	}	645	}
646		646
647	/* FIXME - There is probably a need to check if sk->sk_saddr and	647	/* FIXME - There is probably a need to check if sk->sk_saddr and
648	* sk->sk_rcv_addr are currently set to one of the addresses to	648	* sk->sk_rcv_addr are currently set to one of the addresses to
649	* be removed. This is something which needs to be looked into	649	* be removed. This is something which needs to be looked into
650	* when we are fixing the outstanding issues with multi-homing	650	* when we are fixing the outstanding issues with multi-homing
651	* socket routing and failover schemes. Refer to comments in	651	* socket routing and failover schemes. Refer to comments in
652	* sctp_do_bind(). -daisy	652	* sctp_do_bind(). -daisy
653	*/	653	*/
654	sctp_local_bh_disable();	654	sctp_local_bh_disable();
655	sctp_write_lock(&ep->base.addr_lock);	655	sctp_write_lock(&ep->base.addr_lock);
656		656
657	retval = sctp_del_bind_addr(bp, &saveaddr);	657	retval = sctp_del_bind_addr(bp, &saveaddr);
658		658
659	sctp_write_unlock(&ep->base.addr_lock);	659	sctp_write_unlock(&ep->base.addr_lock);
660	sctp_local_bh_enable();	660	sctp_local_bh_enable();
661		661
662	addr_buf += af->sockaddr_len;	662	addr_buf += af->sockaddr_len;
663	err_bindx_rem:	663	err_bindx_rem:
664	if (retval < 0) {	664	if (retval < 0) {
665	/* Failed. Add the ones that has been removed back */	665	/* Failed. Add the ones that has been removed back */
666	if (cnt > 0)	666	if (cnt > 0)
667	sctp_bindx_add(sk, addrs, cnt);	667	sctp_bindx_add(sk, addrs, cnt);
668	return retval;	668	return retval;
669	}	669	}
670	}	670	}
671		671
672	return retval;	672	return retval;
673	}	673	}
674		674
675	/* Send an ASCONF chunk with Delete IP address parameters to all the peers of	675	/* Send an ASCONF chunk with Delete IP address parameters to all the peers of
676	* the associations that are part of the endpoint indicating that a list of	676	* the associations that are part of the endpoint indicating that a list of
677	* local addresses are removed from the endpoint.	677	* local addresses are removed from the endpoint.
678	*	678	*
679	* If any of the addresses is already in the bind address list of the	679	* If any of the addresses is already in the bind address list of the
680	* association, we do not send the chunk for that association. But it will not	680	* association, we do not send the chunk for that association. But it will not
681	* affect other associations.	681	* affect other associations.
682	*	682	*
683	* Only sctp_setsockopt_bindx() is supposed to call this function.	683	* Only sctp_setsockopt_bindx() is supposed to call this function.
684	*/	684	*/
685	static int sctp_send_asconf_del_ip(struct sock *sk,	685	static int sctp_send_asconf_del_ip(struct sock *sk,
686	struct sockaddr *addrs,	686	struct sockaddr *addrs,
687	int addrcnt)	687	int addrcnt)
688	{	688	{
689	struct sctp_sock *sp;	689	struct sctp_sock *sp;
690	struct sctp_endpoint *ep;	690	struct sctp_endpoint *ep;
691	struct sctp_association *asoc;	691	struct sctp_association *asoc;
692	struct sctp_transport *transport;	692	struct sctp_transport *transport;
693	struct sctp_bind_addr *bp;	693	struct sctp_bind_addr *bp;
694	struct sctp_chunk *chunk;	694	struct sctp_chunk *chunk;
695	union sctp_addr *laddr;	695	union sctp_addr *laddr;
696	union sctp_addr saveaddr;	696	union sctp_addr saveaddr;
697	void *addr_buf;	697	void *addr_buf;
698	struct sctp_af *af;	698	struct sctp_af *af;
699	struct list_head pos, pos1;	699	struct list_head pos, pos1;
700	struct sctp_sockaddr_entry *saddr;	700	struct sctp_sockaddr_entry *saddr;
701	int i;	701	int i;
702	int retval = 0;	702	int retval = 0;
703		703
704	if (!sctp_addip_enable)	704	if (!sctp_addip_enable)
705	return retval;	705	return retval;
706		706
707	sp = sctp_sk(sk);	707	sp = sctp_sk(sk);
708	ep = sp->ep;	708	ep = sp->ep;
709		709
710	SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",	710	SCTP_DEBUG_PRINTK("%s: (sk: %p, addrs: %p, addrcnt: %d)\n",
711	__FUNCTION__, sk, addrs, addrcnt);	711	__FUNCTION__, sk, addrs, addrcnt);
712		712
713	list_for_each(pos, &ep->asocs) {	713	list_for_each(pos, &ep->asocs) {
714	asoc = list_entry(pos, struct sctp_association, asocs);	714	asoc = list_entry(pos, struct sctp_association, asocs);
715		715
716	if (!asoc->peer.asconf_capable)	716	if (!asoc->peer.asconf_capable)
717	continue;	717	continue;
718		718
719	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)	719	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_DEL_IP)
720	continue;	720	continue;
721		721
722	if (!sctp_state(asoc, ESTABLISHED))	722	if (!sctp_state(asoc, ESTABLISHED))
723	continue;	723	continue;
724		724
725	/* Check if any address in the packed array of addresses is	725	/* Check if any address in the packed array of addresses is
726	* not present in the bind address list of the association.	726	* not present in the bind address list of the association.
727	* If so, do not send the asconf chunk to its peer, but	727	* If so, do not send the asconf chunk to its peer, but
728	* continue with other associations.	728	* continue with other associations.
729	*/	729	*/
730	addr_buf = addrs;	730	addr_buf = addrs;
731	for (i = 0; i < addrcnt; i++) {	731	for (i = 0; i < addrcnt; i++) {
732	laddr = (union sctp_addr *)addr_buf;	732	laddr = (union sctp_addr *)addr_buf;
733	af = sctp_get_af_specific(laddr->v4.sin_family);	733	af = sctp_get_af_specific(laddr->v4.sin_family);
734	if (!af) {	734	if (!af) {
735	retval = -EINVAL;	735	retval = -EINVAL;
736	goto out;	736	goto out;
737	}	737	}
738		738
739	if (!sctp_assoc_lookup_laddr(asoc, laddr))	739	if (!sctp_assoc_lookup_laddr(asoc, laddr))
740	break;	740	break;
741		741
742	addr_buf += af->sockaddr_len;	742	addr_buf += af->sockaddr_len;
743	}	743	}
744	if (i < addrcnt)	744	if (i < addrcnt)
745	continue;	745	continue;
746		746
747	/* Find one address in the association's bind address list	747	/* Find one address in the association's bind address list
748	* that is not in the packed array of addresses. This is to	748	* that is not in the packed array of addresses. This is to
749	* make sure that we do not delete all the addresses in the	749	* make sure that we do not delete all the addresses in the
750	* association.	750	* association.
751	*/	751	*/
752	sctp_read_lock(&asoc->base.addr_lock);	752	sctp_read_lock(&asoc->base.addr_lock);
753	bp = &asoc->base.bind_addr;	753	bp = &asoc->base.bind_addr;
754	laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,	754	laddr = sctp_find_unmatch_addr(bp, (union sctp_addr *)addrs,
755	addrcnt, sp);	755	addrcnt, sp);
756	sctp_read_unlock(&asoc->base.addr_lock);	756	sctp_read_unlock(&asoc->base.addr_lock);
757	if (!laddr)	757	if (!laddr)
758	continue;	758	continue;
759		759
760	chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,	760	chunk = sctp_make_asconf_update_ip(asoc, laddr, addrs, addrcnt,
761	SCTP_PARAM_DEL_IP);	761	SCTP_PARAM_DEL_IP);
762	if (!chunk) {	762	if (!chunk) {
763	retval = -ENOMEM;	763	retval = -ENOMEM;
764	goto out;	764	goto out;
765	}	765	}
766		766
767	/* Reset use_as_src flag for the addresses in the bind address	767	/* Reset use_as_src flag for the addresses in the bind address
768	* list that are to be deleted.	768	* list that are to be deleted.
769	*/	769	*/
770	sctp_local_bh_disable();	770	sctp_local_bh_disable();
771	sctp_write_lock(&asoc->base.addr_lock);	771	sctp_write_lock(&asoc->base.addr_lock);
772	addr_buf = addrs;	772	addr_buf = addrs;
773	for (i = 0; i < addrcnt; i++) {	773	for (i = 0; i < addrcnt; i++) {
774	laddr = (union sctp_addr *)addr_buf;	774	laddr = (union sctp_addr *)addr_buf;
775	af = sctp_get_af_specific(laddr->v4.sin_family);	775	af = sctp_get_af_specific(laddr->v4.sin_family);
776	memcpy(&saveaddr, laddr, af->sockaddr_len);	776	memcpy(&saveaddr, laddr, af->sockaddr_len);
777	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);	777	saveaddr.v4.sin_port = ntohs(saveaddr.v4.sin_port);
778	list_for_each(pos1, &bp->address_list) {	778	list_for_each(pos1, &bp->address_list) {
779	saddr = list_entry(pos1,	779	saddr = list_entry(pos1,
780	struct sctp_sockaddr_entry,	780	struct sctp_sockaddr_entry,
781	list);	781	list);
782	if (sctp_cmp_addr_exact(&saddr->a, &saveaddr))	782	if (sctp_cmp_addr_exact(&saddr->a, &saveaddr))
783	saddr->use_as_src = 0;	783	saddr->use_as_src = 0;
784	}	784	}
785	addr_buf += af->sockaddr_len;	785	addr_buf += af->sockaddr_len;
786	}	786	}
787	sctp_write_unlock(&asoc->base.addr_lock);	787	sctp_write_unlock(&asoc->base.addr_lock);
788	sctp_local_bh_enable();	788	sctp_local_bh_enable();
789		789
790	/* Update the route and saddr entries for all the transports	790	/* Update the route and saddr entries for all the transports
791	* as some of the addresses in the bind address list are	791	* as some of the addresses in the bind address list are
792	* about to be deleted and cannot be used as source addresses.	792	* about to be deleted and cannot be used as source addresses.
793	*/	793	*/
794	list_for_each(pos1, &asoc->peer.transport_addr_list) {	794	list_for_each(pos1, &asoc->peer.transport_addr_list) {
795	transport = list_entry(pos1, struct sctp_transport,	795	transport = list_entry(pos1, struct sctp_transport,
796	transports);	796	transports);
797	dst_release(transport->dst);	797	dst_release(transport->dst);
798	sctp_transport_route(transport, NULL,	798	sctp_transport_route(transport, NULL,
799	sctp_sk(asoc->base.sk));	799	sctp_sk(asoc->base.sk));
800	}	800	}
801		801
802	retval = sctp_send_asconf(asoc, chunk);	802	retval = sctp_send_asconf(asoc, chunk);
803	}	803	}
804	out:	804	out:
805	return retval;	805	return retval;
806	}	806	}
807		807
808	/* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()	808	/* Helper for tunneling sctp_bindx() requests through sctp_setsockopt()
809	*	809	*
810	* API 8.1	810	* API 8.1
811	* int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,	811	* int sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt,
812	* int flags);	812	* int flags);
813	*	813	*
814	* If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.	814	* If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
815	* If the sd is an IPv6 socket, the addresses passed can either be IPv4	815	* If the sd is an IPv6 socket, the addresses passed can either be IPv4
816	* or IPv6 addresses.	816	* or IPv6 addresses.
817	*	817	*
818	* A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see	818	* A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
819	* Section 3.1.2 for this usage.	819	* Section 3.1.2 for this usage.
820	*	820	*
821	* addrs is a pointer to an array of one or more socket addresses. Each	821	* addrs is a pointer to an array of one or more socket addresses. Each
822	* address is contained in its appropriate structure (i.e. struct	822	* address is contained in its appropriate structure (i.e. struct
823	* sockaddr_in or struct sockaddr_in6) the family of the address type	823	* sockaddr_in or struct sockaddr_in6) the family of the address type
824	* must be used to distengish the address length (note that this	824	* must be used to distengish the address length (note that this
825	* representation is termed a "packed array" of addresses). The caller	825	* representation is termed a "packed array" of addresses). The caller
826	* specifies the number of addresses in the array with addrcnt.	826	* specifies the number of addresses in the array with addrcnt.
827	*	827	*
828	* On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns	828	* On success, sctp_bindx() returns 0. On failure, sctp_bindx() returns
829	* -1, and sets errno to the appropriate error code.	829	* -1, and sets errno to the appropriate error code.
830	*	830	*
831	* For SCTP, the port given in each socket address must be the same, or	831	* For SCTP, the port given in each socket address must be the same, or
832	* sctp_bindx() will fail, setting errno to EINVAL.	832	* sctp_bindx() will fail, setting errno to EINVAL.
833	*	833	*
834	* The flags parameter is formed from the bitwise OR of zero or more of	834	* The flags parameter is formed from the bitwise OR of zero or more of
835	* the following currently defined flags:	835	* the following currently defined flags:
836	*	836	*
837	* SCTP_BINDX_ADD_ADDR	837	* SCTP_BINDX_ADD_ADDR
838	*	838	*
839	* SCTP_BINDX_REM_ADDR	839	* SCTP_BINDX_REM_ADDR
840	*	840	*
841	* SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the	841	* SCTP_BINDX_ADD_ADDR directs SCTP to add the given addresses to the
842	* association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given	842	* association, and SCTP_BINDX_REM_ADDR directs SCTP to remove the given
843	* addresses from the association. The two flags are mutually exclusive;	843	* addresses from the association. The two flags are mutually exclusive;
844	* if both are given, sctp_bindx() will fail with EINVAL. A caller may	844	* if both are given, sctp_bindx() will fail with EINVAL. A caller may
845	* not remove all addresses from an association; sctp_bindx() will	845	* not remove all addresses from an association; sctp_bindx() will
846	* reject such an attempt with EINVAL.	846	* reject such an attempt with EINVAL.
847	*	847	*
848	* An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate	848	* An application can use sctp_bindx(SCTP_BINDX_ADD_ADDR) to associate
849	* additional addresses with an endpoint after calling bind(). Or use	849	* additional addresses with an endpoint after calling bind(). Or use
850	* sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening	850	* sctp_bindx(SCTP_BINDX_REM_ADDR) to remove some addresses a listening
851	* socket is associated with so that no new association accepted will be	851	* socket is associated with so that no new association accepted will be
852	* associated with those addresses. If the endpoint supports dynamic	852	* associated with those addresses. If the endpoint supports dynamic
853	* address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a	853	* address a SCTP_BINDX_REM_ADDR or SCTP_BINDX_ADD_ADDR may cause a
854	* endpoint to send the appropriate message to the peer to change the	854	* endpoint to send the appropriate message to the peer to change the
855	* peers address lists.	855	* peers address lists.
856	*	856	*
857	* Adding and removing addresses from a connected association is	857	* Adding and removing addresses from a connected association is
858	* optional functionality. Implementations that do not support this	858	* optional functionality. Implementations that do not support this
859	* functionality should return EOPNOTSUPP.	859	* functionality should return EOPNOTSUPP.
860	*	860	*
861	* Basically do nothing but copying the addresses from user to kernel	861	* Basically do nothing but copying the addresses from user to kernel
862	* land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.	862	* land and invoking either sctp_bindx_add() or sctp_bindx_rem() on the sk.
863	* This is used for tunneling the sctp_bindx() request through sctp_setsockopt()	863	* This is used for tunneling the sctp_bindx() request through sctp_setsockopt()
864	* from userspace.	864	* from userspace.
865	*	865	*
866	* We don't use copy_from_user() for optimization: we first do the	866	* We don't use copy_from_user() for optimization: we first do the
867	* sanity checks (buffer size -fast- and access check-healthy	867	* sanity checks (buffer size -fast- and access check-healthy
868	* pointer); if all of those succeed, then we can alloc the memory	868	* pointer); if all of those succeed, then we can alloc the memory
869	* (expensive operation) needed to copy the data to kernel. Then we do	869	* (expensive operation) needed to copy the data to kernel. Then we do
870	* the copying without checking the user space area	870	* the copying without checking the user space area
871	* (__copy_from_user()).	871	* (__copy_from_user()).
872	*	872	*
873	* On exit there is no need to do sockfd_put(), sys_setsockopt() does	873	* On exit there is no need to do sockfd_put(), sys_setsockopt() does
874	* it.	874	* it.
875	*	875	*
876	* sk The sk of the socket	876	* sk The sk of the socket
877	* addrs The pointer to the addresses in user land	877	* addrs The pointer to the addresses in user land
878	* addrssize Size of the addrs buffer	878	* addrssize Size of the addrs buffer
879	* op Operation to perform (add or remove, see the flags of	879	* op Operation to perform (add or remove, see the flags of
880	* sctp_bindx)	880	* sctp_bindx)
881	*	881	*
882	* Returns 0 if ok, <0 errno code on error.	882	* Returns 0 if ok, <0 errno code on error.
883	*/	883	*/
884	SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk,	884	SCTP_STATIC int sctp_setsockopt_bindx(struct sock* sk,
885	struct sockaddr __user *addrs,	885	struct sockaddr __user *addrs,
886	int addrs_size, int op)	886	int addrs_size, int op)
887	{	887	{
888	struct sockaddr *kaddrs;	888	struct sockaddr *kaddrs;
889	int err;	889	int err;
890	int addrcnt = 0;	890	int addrcnt = 0;
891	int walk_size = 0;	891	int walk_size = 0;
892	struct sockaddr *sa_addr;	892	struct sockaddr *sa_addr;
893	void *addr_buf;	893	void *addr_buf;
894	struct sctp_af *af;	894	struct sctp_af *af;
895		895
896	SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"	896	SCTP_DEBUG_PRINTK("sctp_setsocktopt_bindx: sk %p addrs %p"
897	" addrs_size %d opt %d\n", sk, addrs, addrs_size, op);	897	" addrs_size %d opt %d\n", sk, addrs, addrs_size, op);
898		898
899	if (unlikely(addrs_size <= 0))	899	if (unlikely(addrs_size <= 0))
900	return -EINVAL;	900	return -EINVAL;
901		901
902	/* Check the user passed a healthy pointer. */	902	/* Check the user passed a healthy pointer. */
903	if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))	903	if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
904	return -EFAULT;	904	return -EFAULT;
905		905
906	/* Alloc space for the address array in kernel memory. */	906	/* Alloc space for the address array in kernel memory. */
907	kaddrs = kmalloc(addrs_size, GFP_KERNEL);	907	kaddrs = kmalloc(addrs_size, GFP_KERNEL);
908	if (unlikely(!kaddrs))	908	if (unlikely(!kaddrs))
909	return -ENOMEM;	909	return -ENOMEM;
910		910
911	if (__copy_from_user(kaddrs, addrs, addrs_size)) {	911	if (__copy_from_user(kaddrs, addrs, addrs_size)) {
912	kfree(kaddrs);	912	kfree(kaddrs);
913	return -EFAULT;	913	return -EFAULT;
914	}	914	}
915		915
916	/* Walk through the addrs buffer and count the number of addresses. */	916	/* Walk through the addrs buffer and count the number of addresses. */
917	addr_buf = kaddrs;	917	addr_buf = kaddrs;
918	while (walk_size < addrs_size) {	918	while (walk_size < addrs_size) {
919	sa_addr = (struct sockaddr *)addr_buf;	919	sa_addr = (struct sockaddr *)addr_buf;
920	af = sctp_get_af_specific(sa_addr->sa_family);	920	af = sctp_get_af_specific(sa_addr->sa_family);
921		921
922	/* If the address family is not supported or if this address	922	/* If the address family is not supported or if this address
923	* causes the address buffer to overflow return EINVAL.	923	* causes the address buffer to overflow return EINVAL.
924	*/	924	*/
925	if (!af \|\| (walk_size + af->sockaddr_len) > addrs_size) {	925	if (!af \|\| (walk_size + af->sockaddr_len) > addrs_size) {
926	kfree(kaddrs);	926	kfree(kaddrs);
927	return -EINVAL;	927	return -EINVAL;
928	}	928	}
929	addrcnt++;	929	addrcnt++;
930	addr_buf += af->sockaddr_len;	930	addr_buf += af->sockaddr_len;
931	walk_size += af->sockaddr_len;	931	walk_size += af->sockaddr_len;
932	}	932	}
933		933
934	/* Do the work. */	934	/* Do the work. */
935	switch (op) {	935	switch (op) {
936	case SCTP_BINDX_ADD_ADDR:	936	case SCTP_BINDX_ADD_ADDR:
937	err = sctp_bindx_add(sk, kaddrs, addrcnt);	937	err = sctp_bindx_add(sk, kaddrs, addrcnt);
938	if (err)	938	if (err)
939	goto out;	939	goto out;
940	err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);	940	err = sctp_send_asconf_add_ip(sk, kaddrs, addrcnt);
941	break;	941	break;
942		942
943	case SCTP_BINDX_REM_ADDR:	943	case SCTP_BINDX_REM_ADDR:
944	err = sctp_bindx_rem(sk, kaddrs, addrcnt);	944	err = sctp_bindx_rem(sk, kaddrs, addrcnt);
945	if (err)	945	if (err)
946	goto out;	946	goto out;
947	err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);	947	err = sctp_send_asconf_del_ip(sk, kaddrs, addrcnt);
948	break;	948	break;
949		949
950	default:	950	default:
951	err = -EINVAL;	951	err = -EINVAL;
952	break;	952	break;
953	};	953	};
954		954
955	out:	955	out:
956	kfree(kaddrs);	956	kfree(kaddrs);
957		957
958	return err;	958	return err;
959	}	959	}
960		960
961	/* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)	961	/* __sctp_connect(struct sock* sk, struct sockaddr *kaddrs, int addrs_size)
962	*	962	*
963	* Common routine for handling connect() and sctp_connectx().	963	* Common routine for handling connect() and sctp_connectx().
964	* Connect will come in with just a single address.	964	* Connect will come in with just a single address.
965	*/	965	*/
966	static int __sctp_connect(struct sock* sk,	966	static int __sctp_connect(struct sock* sk,
967	struct sockaddr *kaddrs,	967	struct sockaddr *kaddrs,
968	int addrs_size)	968	int addrs_size)
969	{	969	{
970	struct sctp_sock *sp;	970	struct sctp_sock *sp;
971	struct sctp_endpoint *ep;	971	struct sctp_endpoint *ep;
972	struct sctp_association *asoc = NULL;	972	struct sctp_association *asoc = NULL;
973	struct sctp_association *asoc2;	973	struct sctp_association *asoc2;
974	struct sctp_transport *transport;	974	struct sctp_transport *transport;
975	union sctp_addr to;	975	union sctp_addr to;
976	struct sctp_af *af;	976	struct sctp_af *af;
977	sctp_scope_t scope;	977	sctp_scope_t scope;
978	long timeo;	978	long timeo;
979	int err = 0;	979	int err = 0;
980	int addrcnt = 0;	980	int addrcnt = 0;
981	int walk_size = 0;	981	int walk_size = 0;
982	struct sockaddr *sa_addr;	982	struct sockaddr *sa_addr;
983	void *addr_buf;	983	void *addr_buf;
984		984
985	sp = sctp_sk(sk);	985	sp = sctp_sk(sk);
986	ep = sp->ep;	986	ep = sp->ep;
987		987
988	/* connect() cannot be done on a socket that is already in ESTABLISHED	988	/* connect() cannot be done on a socket that is already in ESTABLISHED
989	* state - UDP-style peeled off socket or a TCP-style socket that	989	* state - UDP-style peeled off socket or a TCP-style socket that
990	* is already connected.	990	* is already connected.
991	* It cannot be done even on a TCP-style listening socket.	991	* It cannot be done even on a TCP-style listening socket.
992	*/	992	*/
993	if (sctp_sstate(sk, ESTABLISHED) \|\|	993	if (sctp_sstate(sk, ESTABLISHED) \|\|
994	(sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {	994	(sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))) {
995	err = -EISCONN;	995	err = -EISCONN;
996	goto out_free;	996	goto out_free;
997	}	997	}
998		998
999	/* Walk through the addrs buffer and count the number of addresses. */	999	/* Walk through the addrs buffer and count the number of addresses. */
1000	addr_buf = kaddrs;	1000	addr_buf = kaddrs;
1001	while (walk_size < addrs_size) {	1001	while (walk_size < addrs_size) {
1002	sa_addr = (struct sockaddr *)addr_buf;	1002	sa_addr = (struct sockaddr *)addr_buf;
1003	af = sctp_get_af_specific(sa_addr->sa_family);	1003	af = sctp_get_af_specific(sa_addr->sa_family);
1004		1004
1005	/* If the address family is not supported or if this address	1005	/* If the address family is not supported or if this address
1006	* causes the address buffer to overflow return EINVAL.	1006	* causes the address buffer to overflow return EINVAL.
1007	*/	1007	*/
1008	if (!af \|\| (walk_size + af->sockaddr_len) > addrs_size) {	1008	if (!af \|\| (walk_size + af->sockaddr_len) > addrs_size) {
1009	err = -EINVAL;	1009	err = -EINVAL;
1010	goto out_free;	1010	goto out_free;
1011	}	1011	}
1012		1012
1013	err = sctp_verify_addr(sk, (union sctp_addr *)sa_addr,	1013	err = sctp_verify_addr(sk, (union sctp_addr *)sa_addr,
1014	af->sockaddr_len);	1014	af->sockaddr_len);
1015	if (err)	1015	if (err)
1016	goto out_free;	1016	goto out_free;
1017		1017
1018	memcpy(&to, sa_addr, af->sockaddr_len);	1018	memcpy(&to, sa_addr, af->sockaddr_len);
1019	to.v4.sin_port = ntohs(to.v4.sin_port);	1019	to.v4.sin_port = ntohs(to.v4.sin_port);
1020		1020
1021	/* Check if there already is a matching association on the	1021	/* Check if there already is a matching association on the
1022	* endpoint (other than the one created here).	1022	* endpoint (other than the one created here).
1023	*/	1023	*/
1024	asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);	1024	asoc2 = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1025	if (asoc2 && asoc2 != asoc) {	1025	if (asoc2 && asoc2 != asoc) {
1026	if (asoc2->state >= SCTP_STATE_ESTABLISHED)	1026	if (asoc2->state >= SCTP_STATE_ESTABLISHED)
1027	err = -EISCONN;	1027	err = -EISCONN;
1028	else	1028	else
1029	err = -EALREADY;	1029	err = -EALREADY;
1030	goto out_free;	1030	goto out_free;
1031	}	1031	}
1032		1032
1033	/* If we could not find a matching association on the endpoint,	1033	/* If we could not find a matching association on the endpoint,
1034	* make sure that there is no peeled-off association matching	1034	* make sure that there is no peeled-off association matching
1035	* the peer address even on another socket.	1035	* the peer address even on another socket.
1036	*/	1036	*/
1037	if (sctp_endpoint_is_peeled_off(ep, &to)) {	1037	if (sctp_endpoint_is_peeled_off(ep, &to)) {
1038	err = -EADDRNOTAVAIL;	1038	err = -EADDRNOTAVAIL;
1039	goto out_free;	1039	goto out_free;
1040	}	1040	}
1041		1041
1042	if (!asoc) {	1042	if (!asoc) {
1043	/* If a bind() or sctp_bindx() is not called prior to	1043	/* If a bind() or sctp_bindx() is not called prior to
1044	* an sctp_connectx() call, the system picks an	1044	* an sctp_connectx() call, the system picks an
1045	* ephemeral port and will choose an address set	1045	* ephemeral port and will choose an address set
1046	* equivalent to binding with a wildcard address.	1046	* equivalent to binding with a wildcard address.
1047	*/	1047	*/
1048	if (!ep->base.bind_addr.port) {	1048	if (!ep->base.bind_addr.port) {
1049	if (sctp_autobind(sk)) {	1049	if (sctp_autobind(sk)) {
1050	err = -EAGAIN;	1050	err = -EAGAIN;
1051	goto out_free;	1051	goto out_free;
1052	}	1052	}
1053	} else {	1053	} else {
1054	/*	1054	/*
1055	* If an unprivileged user inherits a 1-many	1055	* If an unprivileged user inherits a 1-many
1056	* style socket with open associations on a	1056	* style socket with open associations on a
1057	* privileged port, it MAY be permitted to	1057	* privileged port, it MAY be permitted to
1058	* accept new associations, but it SHOULD NOT	1058	* accept new associations, but it SHOULD NOT
1059	* be permitted to open new associations.	1059	* be permitted to open new associations.
1060	*/	1060	*/
1061	if (ep->base.bind_addr.port < PROT_SOCK &&	1061	if (ep->base.bind_addr.port < PROT_SOCK &&
1062	!capable(CAP_NET_BIND_SERVICE)) {	1062	!capable(CAP_NET_BIND_SERVICE)) {
1063	err = -EACCES;	1063	err = -EACCES;
1064	goto out_free;	1064	goto out_free;
1065	}	1065	}
1066	}	1066	}
1067		1067
1068	scope = sctp_scope(&to);	1068	scope = sctp_scope(&to);
1069	asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);	1069	asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1070	if (!asoc) {	1070	if (!asoc) {
1071	err = -ENOMEM;	1071	err = -ENOMEM;
1072	goto out_free;	1072	goto out_free;
1073	}	1073	}
1074	}	1074	}
1075		1075
1076	/* Prime the peer's transport structures. */	1076	/* Prime the peer's transport structures. */
1077	transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,	1077	transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL,
1078	SCTP_UNKNOWN);	1078	SCTP_UNKNOWN);
1079	if (!transport) {	1079	if (!transport) {
1080	err = -ENOMEM;	1080	err = -ENOMEM;
1081	goto out_free;	1081	goto out_free;
1082	}	1082	}
1083		1083
1084	addrcnt++;	1084	addrcnt++;
1085	addr_buf += af->sockaddr_len;	1085	addr_buf += af->sockaddr_len;
1086	walk_size += af->sockaddr_len;	1086	walk_size += af->sockaddr_len;
1087	}	1087	}
1088		1088
1089	err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);	1089	err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
1090	if (err < 0) {	1090	if (err < 0) {
1091	goto out_free;	1091	goto out_free;
1092	}	1092	}
1093		1093
1094	err = sctp_primitive_ASSOCIATE(asoc, NULL);	1094	err = sctp_primitive_ASSOCIATE(asoc, NULL);
1095	if (err < 0) {	1095	if (err < 0) {
1096	goto out_free;	1096	goto out_free;
1097	}	1097	}
1098		1098
1099	/* Initialize sk's dport and daddr for getpeername() */	1099	/* Initialize sk's dport and daddr for getpeername() */
1100	inet_sk(sk)->dport = htons(asoc->peer.port);	1100	inet_sk(sk)->dport = htons(asoc->peer.port);
1101	af = sctp_get_af_specific(to.sa.sa_family);	1101	af = sctp_get_af_specific(to.sa.sa_family);
1102	af->to_sk_daddr(&to, sk);	1102	af->to_sk_daddr(&to, sk);
1103	sk->sk_err = 0;	1103	sk->sk_err = 0;
1104		1104
1105	timeo = sock_sndtimeo(sk, sk->sk_socket->file->f_flags & O_NONBLOCK);	1105	timeo = sock_sndtimeo(sk, sk->sk_socket->file->f_flags & O_NONBLOCK);
1106	err = sctp_wait_for_connect(asoc, &timeo);	1106	err = sctp_wait_for_connect(asoc, &timeo);
1107		1107
1108	/* Don't free association on exit. */	1108	/* Don't free association on exit. */
1109	asoc = NULL;	1109	asoc = NULL;
1110		1110
1111	out_free:	1111	out_free:
1112		1112
1113	SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p"	1113	SCTP_DEBUG_PRINTK("About to exit __sctp_connect() free asoc: %p"
1114	" kaddrs: %p err: %d\n",	1114	" kaddrs: %p err: %d\n",
1115	asoc, kaddrs, err);	1115	asoc, kaddrs, err);
1116	if (asoc)	1116	if (asoc)
1117	sctp_association_free(asoc);	1117	sctp_association_free(asoc);
1118	return err;	1118	return err;
1119	}	1119	}
1120		1120
1121	/* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()	1121	/* Helper for tunneling sctp_connectx() requests through sctp_setsockopt()
1122	*	1122	*
1123	* API 8.9	1123	* API 8.9
1124	* int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt);	1124	* int sctp_connectx(int sd, struct sockaddr *addrs, int addrcnt);
1125	*	1125	*
1126	* If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.	1126	* If sd is an IPv4 socket, the addresses passed must be IPv4 addresses.
1127	* If the sd is an IPv6 socket, the addresses passed can either be IPv4	1127	* If the sd is an IPv6 socket, the addresses passed can either be IPv4
1128	* or IPv6 addresses.	1128	* or IPv6 addresses.
1129	*	1129	*
1130	* A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see	1130	* A single address may be specified as INADDR_ANY or IN6ADDR_ANY, see
1131	* Section 3.1.2 for this usage.	1131	* Section 3.1.2 for this usage.
1132	*	1132	*
1133	* addrs is a pointer to an array of one or more socket addresses. Each	1133	* addrs is a pointer to an array of one or more socket addresses. Each
1134	* address is contained in its appropriate structure (i.e. struct	1134	* address is contained in its appropriate structure (i.e. struct
1135	* sockaddr_in or struct sockaddr_in6) the family of the address type	1135	* sockaddr_in or struct sockaddr_in6) the family of the address type
1136	* must be used to distengish the address length (note that this	1136	* must be used to distengish the address length (note that this
1137	* representation is termed a "packed array" of addresses). The caller	1137	* representation is termed a "packed array" of addresses). The caller
1138	* specifies the number of addresses in the array with addrcnt.	1138	* specifies the number of addresses in the array with addrcnt.
1139	*	1139	*
1140	* On success, sctp_connectx() returns 0. On failure, sctp_connectx() returns	1140	* On success, sctp_connectx() returns 0. On failure, sctp_connectx() returns
1141	* -1, and sets errno to the appropriate error code.	1141	* -1, and sets errno to the appropriate error code.
1142	*	1142	*
1143	* For SCTP, the port given in each socket address must be the same, or	1143	* For SCTP, the port given in each socket address must be the same, or
1144	* sctp_connectx() will fail, setting errno to EINVAL.	1144	* sctp_connectx() will fail, setting errno to EINVAL.
1145	*	1145	*
1146	* An application can use sctp_connectx to initiate an association with	1146	* An application can use sctp_connectx to initiate an association with
1147	* an endpoint that is multi-homed. Much like sctp_bindx() this call	1147	* an endpoint that is multi-homed. Much like sctp_bindx() this call
1148	* allows a caller to specify multiple addresses at which a peer can be	1148	* allows a caller to specify multiple addresses at which a peer can be
1149	* reached. The way the SCTP stack uses the list of addresses to set up	1149	* reached. The way the SCTP stack uses the list of addresses to set up
1150	* the association is implementation dependant. This function only	1150	* the association is implementation dependant. This function only
1151	* specifies that the stack will try to make use of all the addresses in	1151	* specifies that the stack will try to make use of all the addresses in
1152	* the list when needed.	1152	* the list when needed.
1153	*	1153	*
1154	* Note that the list of addresses passed in is only used for setting up	1154	* Note that the list of addresses passed in is only used for setting up
1155	* the association. It does not necessarily equal the set of addresses	1155	* the association. It does not necessarily equal the set of addresses
1156	* the peer uses for the resulting association. If the caller wants to	1156	* the peer uses for the resulting association. If the caller wants to
1157	* find out the set of peer addresses, it must use sctp_getpaddrs() to	1157	* find out the set of peer addresses, it must use sctp_getpaddrs() to
1158	* retrieve them after the association has been set up.	1158	* retrieve them after the association has been set up.
1159	*	1159	*
1160	* Basically do nothing but copying the addresses from user to kernel	1160	* Basically do nothing but copying the addresses from user to kernel
1161	* land and invoking either sctp_connectx(). This is used for tunneling	1161	* land and invoking either sctp_connectx(). This is used for tunneling
1162	* the sctp_connectx() request through sctp_setsockopt() from userspace.	1162	* the sctp_connectx() request through sctp_setsockopt() from userspace.
1163	*	1163	*
1164	* We don't use copy_from_user() for optimization: we first do the	1164	* We don't use copy_from_user() for optimization: we first do the
1165	* sanity checks (buffer size -fast- and access check-healthy	1165	* sanity checks (buffer size -fast- and access check-healthy
1166	* pointer); if all of those succeed, then we can alloc the memory	1166	* pointer); if all of those succeed, then we can alloc the memory
1167	* (expensive operation) needed to copy the data to kernel. Then we do	1167	* (expensive operation) needed to copy the data to kernel. Then we do
1168	* the copying without checking the user space area	1168	* the copying without checking the user space area
1169	* (__copy_from_user()).	1169	* (__copy_from_user()).
1170	*	1170	*
1171	* On exit there is no need to do sockfd_put(), sys_setsockopt() does	1171	* On exit there is no need to do sockfd_put(), sys_setsockopt() does
1172	* it.	1172	* it.
1173	*	1173	*
1174	* sk The sk of the socket	1174	* sk The sk of the socket
1175	* addrs The pointer to the addresses in user land	1175	* addrs The pointer to the addresses in user land
1176	* addrssize Size of the addrs buffer	1176	* addrssize Size of the addrs buffer
1177	*	1177	*
1178	* Returns 0 if ok, <0 errno code on error.	1178	* Returns 0 if ok, <0 errno code on error.
1179	*/	1179	*/
1180	SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk,	1180	SCTP_STATIC int sctp_setsockopt_connectx(struct sock* sk,
1181	struct sockaddr __user *addrs,	1181	struct sockaddr __user *addrs,
1182	int addrs_size)	1182	int addrs_size)
1183	{	1183	{
1184	int err = 0;	1184	int err = 0;
1185	struct sockaddr *kaddrs;	1185	struct sockaddr *kaddrs;
1186		1186
1187	SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n",	1187	SCTP_DEBUG_PRINTK("%s - sk %p addrs %p addrs_size %d\n",
1188	__FUNCTION__, sk, addrs, addrs_size);	1188	__FUNCTION__, sk, addrs, addrs_size);
1189		1189
1190	if (unlikely(addrs_size <= 0))	1190	if (unlikely(addrs_size <= 0))
1191	return -EINVAL;	1191	return -EINVAL;
1192		1192
1193	/* Check the user passed a healthy pointer. */	1193	/* Check the user passed a healthy pointer. */
1194	if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))	1194	if (unlikely(!access_ok(VERIFY_READ, addrs, addrs_size)))
1195	return -EFAULT;	1195	return -EFAULT;
1196		1196
1197	/* Alloc space for the address array in kernel memory. */	1197	/* Alloc space for the address array in kernel memory. */
1198	kaddrs = kmalloc(addrs_size, GFP_KERNEL);	1198	kaddrs = kmalloc(addrs_size, GFP_KERNEL);
1199	if (unlikely(!kaddrs))	1199	if (unlikely(!kaddrs))
1200	return -ENOMEM;	1200	return -ENOMEM;
1201		1201
1202	if (__copy_from_user(kaddrs, addrs, addrs_size)) {	1202	if (__copy_from_user(kaddrs, addrs, addrs_size)) {
1203	err = -EFAULT;	1203	err = -EFAULT;
1204	} else {	1204	} else {
1205	err = __sctp_connect(sk, kaddrs, addrs_size);	1205	err = __sctp_connect(sk, kaddrs, addrs_size);
1206	}	1206	}
1207		1207
1208	kfree(kaddrs);	1208	kfree(kaddrs);
1209	return err;	1209	return err;
1210	}	1210	}
1211		1211
1212	/* API 3.1.4 close() - UDP Style Syntax	1212	/* API 3.1.4 close() - UDP Style Syntax
1213	* Applications use close() to perform graceful shutdown (as described in	1213	* Applications use close() to perform graceful shutdown (as described in
1214	* Section 10.1 of [SCTP]) on ALL the associations currently represented	1214	* Section 10.1 of [SCTP]) on ALL the associations currently represented
1215	* by a UDP-style socket.	1215	* by a UDP-style socket.
1216	*	1216	*
1217	* The syntax is	1217	* The syntax is
1218	*	1218	*
1219	* ret = close(int sd);	1219	* ret = close(int sd);
1220	*	1220	*
1221	* sd - the socket descriptor of the associations to be closed.	1221	* sd - the socket descriptor of the associations to be closed.
1222	*	1222	*
1223	* To gracefully shutdown a specific association represented by the	1223	* To gracefully shutdown a specific association represented by the
1224	* UDP-style socket, an application should use the sendmsg() call,	1224	* UDP-style socket, an application should use the sendmsg() call,
1225	* passing no user data, but including the appropriate flag in the	1225	* passing no user data, but including the appropriate flag in the
1226	* ancillary data (see Section xxxx).	1226	* ancillary data (see Section xxxx).
1227	*	1227	*
1228	* If sd in the close() call is a branched-off socket representing only	1228	* If sd in the close() call is a branched-off socket representing only
1229	* one association, the shutdown is performed on that association only.	1229	* one association, the shutdown is performed on that association only.
1230	*	1230	*
1231	* 4.1.6 close() - TCP Style Syntax	1231	* 4.1.6 close() - TCP Style Syntax
1232	*	1232	*
1233	* Applications use close() to gracefully close down an association.	1233	* Applications use close() to gracefully close down an association.
1234	*	1234	*
1235	* The syntax is:	1235	* The syntax is:
1236	*	1236	*
1237	* int close(int sd);	1237	* int close(int sd);
1238	*	1238	*
1239	* sd - the socket descriptor of the association to be closed.	1239	* sd - the socket descriptor of the association to be closed.
1240	*	1240	*
1241	* After an application calls close() on a socket descriptor, no further	1241	* After an application calls close() on a socket descriptor, no further
1242	* socket operations will succeed on that descriptor.	1242	* socket operations will succeed on that descriptor.
1243	*	1243	*
1244	* API 7.1.4 SO_LINGER	1244	* API 7.1.4 SO_LINGER
1245	*	1245	*
1246	* An application using the TCP-style socket can use this option to	1246	* An application using the TCP-style socket can use this option to
1247	* perform the SCTP ABORT primitive. The linger option structure is:	1247	* perform the SCTP ABORT primitive. The linger option structure is:
1248	*	1248	*
1249	* struct linger {	1249	* struct linger {
1250	* int l_onoff; // option on/off	1250	* int l_onoff; // option on/off
1251	* int l_linger; // linger time	1251	* int l_linger; // linger time
1252	* };	1252	* };
1253	*	1253	*
1254	* To enable the option, set l_onoff to 1. If the l_linger value is set	1254	* To enable the option, set l_onoff to 1. If the l_linger value is set
1255	* to 0, calling close() is the same as the ABORT primitive. If the	1255	* to 0, calling close() is the same as the ABORT primitive. If the
1256	* value is set to a negative value, the setsockopt() call will return	1256	* value is set to a negative value, the setsockopt() call will return
1257	* an error. If the value is set to a positive value linger_time, the	1257	* an error. If the value is set to a positive value linger_time, the
1258	* close() can be blocked for at most linger_time ms. If the graceful	1258	* close() can be blocked for at most linger_time ms. If the graceful
1259	* shutdown phase does not finish during this period, close() will	1259	* shutdown phase does not finish during this period, close() will
1260	* return but the graceful shutdown phase continues in the system.	1260	* return but the graceful shutdown phase continues in the system.
1261	*/	1261	*/
1262	SCTP_STATIC void sctp_close(struct sock *sk, long timeout)	1262	SCTP_STATIC void sctp_close(struct sock *sk, long timeout)
1263	{	1263	{
1264	struct sctp_endpoint *ep;	1264	struct sctp_endpoint *ep;
1265	struct sctp_association *asoc;	1265	struct sctp_association *asoc;
1266	struct list_head pos, temp;	1266	struct list_head pos, temp;
1267		1267
1268	SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout);	1268	SCTP_DEBUG_PRINTK("sctp_close(sk: 0x%p, timeout:%ld)\n", sk, timeout);
1269		1269
1270	sctp_lock_sock(sk);	1270	sctp_lock_sock(sk);
1271	sk->sk_shutdown = SHUTDOWN_MASK;	1271	sk->sk_shutdown = SHUTDOWN_MASK;
1272		1272
1273	ep = sctp_sk(sk)->ep;	1273	ep = sctp_sk(sk)->ep;
1274		1274
1275	/* Walk all associations on an endpoint. */	1275	/* Walk all associations on an endpoint. */
1276	list_for_each_safe(pos, temp, &ep->asocs) {	1276	list_for_each_safe(pos, temp, &ep->asocs) {
1277	asoc = list_entry(pos, struct sctp_association, asocs);	1277	asoc = list_entry(pos, struct sctp_association, asocs);
1278		1278
1279	if (sctp_style(sk, TCP)) {	1279	if (sctp_style(sk, TCP)) {
1280	/* A closed association can still be in the list if	1280	/* A closed association can still be in the list if
1281	* it belongs to a TCP-style listening socket that is	1281	* it belongs to a TCP-style listening socket that is
1282	* not yet accepted. If so, free it. If not, send an	1282	* not yet accepted. If so, free it. If not, send an
1283	* ABORT or SHUTDOWN based on the linger options.	1283	* ABORT or SHUTDOWN based on the linger options.
1284	*/	1284	*/
1285	if (sctp_state(asoc, CLOSED)) {	1285	if (sctp_state(asoc, CLOSED)) {
1286	sctp_unhash_established(asoc);	1286	sctp_unhash_established(asoc);
1287	sctp_association_free(asoc);	1287	sctp_association_free(asoc);
1288	continue;	1288	continue;
1289	}	1289	}
1290	}	1290	}
1291		1291
1292	if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {	1292	if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
1293	struct sctp_chunk *chunk;	1293	struct sctp_chunk *chunk;
1294		1294
1295	chunk = sctp_make_abort_user(asoc, NULL, 0);	1295	chunk = sctp_make_abort_user(asoc, NULL, 0);
1296	if (chunk)	1296	if (chunk)
1297	sctp_primitive_ABORT(asoc, chunk);	1297	sctp_primitive_ABORT(asoc, chunk);
1298	} else	1298	} else
1299	sctp_primitive_SHUTDOWN(asoc, NULL);	1299	sctp_primitive_SHUTDOWN(asoc, NULL);
1300	}	1300	}
1301		1301
1302	/* Clean up any skbs sitting on the receive queue. */	1302	/* Clean up any skbs sitting on the receive queue. */
1303	sctp_queue_purge_ulpevents(&sk->sk_receive_queue);	1303	sctp_queue_purge_ulpevents(&sk->sk_receive_queue);
1304	sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);	1304	sctp_queue_purge_ulpevents(&sctp_sk(sk)->pd_lobby);
1305		1305
1306	/* On a TCP-style socket, block for at most linger_time if set. */	1306	/* On a TCP-style socket, block for at most linger_time if set. */
1307	if (sctp_style(sk, TCP) && timeout)	1307	if (sctp_style(sk, TCP) && timeout)
1308	sctp_wait_for_close(sk, timeout);	1308	sctp_wait_for_close(sk, timeout);
1309		1309
1310	/* This will run the backlog queue. */	1310	/* This will run the backlog queue. */
1311	sctp_release_sock(sk);	1311	sctp_release_sock(sk);
1312		1312
1313	/* Supposedly, no process has access to the socket, but	1313	/* Supposedly, no process has access to the socket, but
1314	* the net layers still may.	1314	* the net layers still may.
1315	*/	1315	*/
1316	sctp_local_bh_disable();	1316	sctp_local_bh_disable();
1317	sctp_bh_lock_sock(sk);	1317	sctp_bh_lock_sock(sk);
1318		1318
1319	/* Hold the sock, since sk_common_release() will put sock_put()	1319	/* Hold the sock, since sk_common_release() will put sock_put()
1320	* and we have just a little more cleanup.	1320	* and we have just a little more cleanup.
1321	*/	1321	*/
1322	sock_hold(sk);	1322	sock_hold(sk);
1323	sk_common_release(sk);	1323	sk_common_release(sk);
1324		1324
1325	sctp_bh_unlock_sock(sk);	1325	sctp_bh_unlock_sock(sk);
1326	sctp_local_bh_enable();	1326	sctp_local_bh_enable();
1327		1327
1328	sock_put(sk);	1328	sock_put(sk);
1329		1329
1330	SCTP_DBG_OBJCNT_DEC(sock);	1330	SCTP_DBG_OBJCNT_DEC(sock);
1331	}	1331	}
1332		1332
1333	/* Handle EPIPE error. */	1333	/* Handle EPIPE error. */
1334	static int sctp_error(struct sock *sk, int flags, int err)	1334	static int sctp_error(struct sock *sk, int flags, int err)
1335	{	1335	{
1336	if (err == -EPIPE)	1336	if (err == -EPIPE)
1337	err = sock_error(sk) ? : -EPIPE;	1337	err = sock_error(sk) ? : -EPIPE;
1338	if (err == -EPIPE && !(flags & MSG_NOSIGNAL))	1338	if (err == -EPIPE && !(flags & MSG_NOSIGNAL))
1339	send_sig(SIGPIPE, current, 0);	1339	send_sig(SIGPIPE, current, 0);
1340	return err;	1340	return err;
1341	}	1341	}
1342		1342
1343	/* API 3.1.3 sendmsg() - UDP Style Syntax	1343	/* API 3.1.3 sendmsg() - UDP Style Syntax
1344	*	1344	*
1345	* An application uses sendmsg() and recvmsg() calls to transmit data to	1345	* An application uses sendmsg() and recvmsg() calls to transmit data to
1346	* and receive data from its peer.	1346	* and receive data from its peer.
1347	*	1347	*
1348	* ssize_t sendmsg(int socket, const struct msghdr *message,	1348	* ssize_t sendmsg(int socket, const struct msghdr *message,
1349	* int flags);	1349	* int flags);
1350	*	1350	*
1351	* socket - the socket descriptor of the endpoint.	1351	* socket - the socket descriptor of the endpoint.
1352	* message - pointer to the msghdr structure which contains a single	1352	* message - pointer to the msghdr structure which contains a single
1353	* user message and possibly some ancillary data.	1353	* user message and possibly some ancillary data.
1354	*	1354	*
1355	* See Section 5 for complete description of the data	1355	* See Section 5 for complete description of the data
1356	* structures.	1356	* structures.
1357	*	1357	*
1358	* flags - flags sent or received with the user message, see Section	1358	* flags - flags sent or received with the user message, see Section
1359	* 5 for complete description of the flags.	1359	* 5 for complete description of the flags.
1360	*	1360	*
1361	* Note: This function could use a rewrite especially when explicit	1361	* Note: This function could use a rewrite especially when explicit
1362	* connect support comes in.	1362	* connect support comes in.
1363	*/	1363	*/
1364	/* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */	1364	/* BUG: We do not implement the equivalent of sk_stream_wait_memory(). */
1365		1365
1366	SCTP_STATIC int sctp_msghdr_parse(const struct msghdr , sctp_cmsgs_t );	1366	SCTP_STATIC int sctp_msghdr_parse(const struct msghdr , sctp_cmsgs_t );
1367		1367
1368	SCTP_STATIC int sctp_sendmsg(struct kiocb iocb, struct sock sk,	1368	SCTP_STATIC int sctp_sendmsg(struct kiocb iocb, struct sock sk,
1369	struct msghdr *msg, size_t msg_len)	1369	struct msghdr *msg, size_t msg_len)
1370	{	1370	{
1371	struct sctp_sock *sp;	1371	struct sctp_sock *sp;
1372	struct sctp_endpoint *ep;	1372	struct sctp_endpoint *ep;
1373	struct sctp_association new_asoc=NULL, asoc=NULL;	1373	struct sctp_association new_asoc=NULL, asoc=NULL;
1374	struct sctp_transport transport, chunk_tp;	1374	struct sctp_transport transport, chunk_tp;
1375	struct sctp_chunk *chunk;	1375	struct sctp_chunk *chunk;
1376	union sctp_addr to;	1376	union sctp_addr to;
1377	struct sockaddr *msg_name = NULL;	1377	struct sockaddr *msg_name = NULL;
1378	struct sctp_sndrcvinfo default_sinfo = { 0 };	1378	struct sctp_sndrcvinfo default_sinfo = { 0 };
1379	struct sctp_sndrcvinfo *sinfo;	1379	struct sctp_sndrcvinfo *sinfo;
1380	struct sctp_initmsg *sinit;	1380	struct sctp_initmsg *sinit;
1381	sctp_assoc_t associd = 0;	1381	sctp_assoc_t associd = 0;
1382	sctp_cmsgs_t cmsgs = { NULL };	1382	sctp_cmsgs_t cmsgs = { NULL };
1383	int err;	1383	int err;
1384	sctp_scope_t scope;	1384	sctp_scope_t scope;
1385	long timeo;	1385	long timeo;
1386	__u16 sinfo_flags = 0;	1386	__u16 sinfo_flags = 0;
1387	struct sctp_datamsg *datamsg;	1387	struct sctp_datamsg *datamsg;
1388	struct list_head *pos;	1388	struct list_head *pos;
1389	int msg_flags = msg->msg_flags;	1389	int msg_flags = msg->msg_flags;
1390		1390
1391	SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n",	1391	SCTP_DEBUG_PRINTK("sctp_sendmsg(sk: %p, msg: %p, msg_len: %zu)\n",
1392	sk, msg, msg_len);	1392	sk, msg, msg_len);
1393		1393
1394	err = 0;	1394	err = 0;
1395	sp = sctp_sk(sk);	1395	sp = sctp_sk(sk);
1396	ep = sp->ep;	1396	ep = sp->ep;
1397		1397
1398	SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep);	1398	SCTP_DEBUG_PRINTK("Using endpoint: %p.\n", ep);
1399		1399
1400	/* We cannot send a message over a TCP-style listening socket. */	1400	/* We cannot send a message over a TCP-style listening socket. */
1401	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {	1401	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING)) {
1402	err = -EPIPE;	1402	err = -EPIPE;
1403	goto out_nounlock;	1403	goto out_nounlock;
1404	}	1404	}
1405		1405
1406	/* Parse out the SCTP CMSGs. */	1406	/* Parse out the SCTP CMSGs. */
1407	err = sctp_msghdr_parse(msg, &cmsgs);	1407	err = sctp_msghdr_parse(msg, &cmsgs);
1408		1408
1409	if (err) {	1409	if (err) {
1410	SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err);	1410	SCTP_DEBUG_PRINTK("msghdr parse err = %x\n", err);
1411	goto out_nounlock;	1411	goto out_nounlock;
1412	}	1412	}
1413		1413
1414	/* Fetch the destination address for this packet. This	1414	/* Fetch the destination address for this packet. This
1415	* address only selects the association--it is not necessarily	1415	* address only selects the association--it is not necessarily
1416	* the address we will send to.	1416	* the address we will send to.
1417	* For a peeled-off socket, msg_name is ignored.	1417	* For a peeled-off socket, msg_name is ignored.
1418	*/	1418	*/
1419	if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {	1419	if (!sctp_style(sk, UDP_HIGH_BANDWIDTH) && msg->msg_name) {
1420	int msg_namelen = msg->msg_namelen;	1420	int msg_namelen = msg->msg_namelen;
1421		1421
1422	err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,	1422	err = sctp_verify_addr(sk, (union sctp_addr *)msg->msg_name,
1423	msg_namelen);	1423	msg_namelen);
1424	if (err)	1424	if (err)
1425	return err;	1425	return err;
1426		1426
1427	if (msg_namelen > sizeof(to))	1427	if (msg_namelen > sizeof(to))
1428	msg_namelen = sizeof(to);	1428	msg_namelen = sizeof(to);
1429	memcpy(&to, msg->msg_name, msg_namelen);	1429	memcpy(&to, msg->msg_name, msg_namelen);
1430	SCTP_DEBUG_PRINTK("Just memcpy'd. msg_name is "	1430	SCTP_DEBUG_PRINTK("Just memcpy'd. msg_name is "
1431	"0x%x:%u.\n",	1431	"0x%x:%u.\n",
1432	to.v4.sin_addr.s_addr, to.v4.sin_port);	1432	to.v4.sin_addr.s_addr, to.v4.sin_port);
1433		1433
1434	to.v4.sin_port = ntohs(to.v4.sin_port);	1434	to.v4.sin_port = ntohs(to.v4.sin_port);
1435	msg_name = msg->msg_name;	1435	msg_name = msg->msg_name;
1436	}	1436	}
1437		1437
1438	sinfo = cmsgs.info;	1438	sinfo = cmsgs.info;
1439	sinit = cmsgs.init;	1439	sinit = cmsgs.init;
1440		1440
1441	/* Did the user specify SNDRCVINFO? */	1441	/* Did the user specify SNDRCVINFO? */
1442	if (sinfo) {	1442	if (sinfo) {
1443	sinfo_flags = sinfo->sinfo_flags;	1443	sinfo_flags = sinfo->sinfo_flags;
1444	associd = sinfo->sinfo_assoc_id;	1444	associd = sinfo->sinfo_assoc_id;
1445	}	1445	}
1446		1446
1447	SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n",	1447	SCTP_DEBUG_PRINTK("msg_len: %zu, sinfo_flags: 0x%x\n",
1448	msg_len, sinfo_flags);	1448	msg_len, sinfo_flags);
1449		1449
1450	/* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */	1450	/* SCTP_EOF or SCTP_ABORT cannot be set on a TCP-style socket. */
1451	if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF \| SCTP_ABORT))) {	1451	if (sctp_style(sk, TCP) && (sinfo_flags & (SCTP_EOF \| SCTP_ABORT))) {
1452	err = -EINVAL;	1452	err = -EINVAL;
1453	goto out_nounlock;	1453	goto out_nounlock;
1454	}	1454	}
1455		1455
1456	/* If SCTP_EOF is set, no data can be sent. Disallow sending zero	1456	/* If SCTP_EOF is set, no data can be sent. Disallow sending zero
1457	* length messages when SCTP_EOF\|SCTP_ABORT is not set.	1457	* length messages when SCTP_EOF\|SCTP_ABORT is not set.
1458	* If SCTP_ABORT is set, the message length could be non zero with	1458	* If SCTP_ABORT is set, the message length could be non zero with
1459	* the msg_iov set to the user abort reason.	1459	* the msg_iov set to the user abort reason.
1460	*/	1460	*/
1461	if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) \|\|	1461	if (((sinfo_flags & SCTP_EOF) && (msg_len > 0)) \|\|
1462	(!(sinfo_flags & (SCTP_EOF\|SCTP_ABORT)) && (msg_len == 0))) {	1462	(!(sinfo_flags & (SCTP_EOF\|SCTP_ABORT)) && (msg_len == 0))) {
1463	err = -EINVAL;	1463	err = -EINVAL;
1464	goto out_nounlock;	1464	goto out_nounlock;
1465	}	1465	}
1466		1466
1467	/* If SCTP_ADDR_OVER is set, there must be an address	1467	/* If SCTP_ADDR_OVER is set, there must be an address
1468	* specified in msg_name.	1468	* specified in msg_name.
1469	*/	1469	*/
1470	if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {	1470	if ((sinfo_flags & SCTP_ADDR_OVER) && (!msg->msg_name)) {
1471	err = -EINVAL;	1471	err = -EINVAL;
1472	goto out_nounlock;	1472	goto out_nounlock;
1473	}	1473	}
1474		1474
1475	transport = NULL;	1475	transport = NULL;
1476		1476
1477	SCTP_DEBUG_PRINTK("About to look up association.\n");	1477	SCTP_DEBUG_PRINTK("About to look up association.\n");
1478		1478
1479	sctp_lock_sock(sk);	1479	sctp_lock_sock(sk);
1480		1480
1481	/* If a msg_name has been specified, assume this is to be used. */	1481	/* If a msg_name has been specified, assume this is to be used. */
1482	if (msg_name) {	1482	if (msg_name) {
1483	/* Look for a matching association on the endpoint. */	1483	/* Look for a matching association on the endpoint. */
1484	asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);	1484	asoc = sctp_endpoint_lookup_assoc(ep, &to, &transport);
1485	if (!asoc) {	1485	if (!asoc) {
1486	/* If we could not find a matching association on the	1486	/* If we could not find a matching association on the
1487	* endpoint, make sure that it is not a TCP-style	1487	* endpoint, make sure that it is not a TCP-style
1488	* socket that already has an association or there is	1488	* socket that already has an association or there is
1489	* no peeled-off association on another socket.	1489	* no peeled-off association on another socket.
1490	*/	1490	*/
1491	if ((sctp_style(sk, TCP) &&	1491	if ((sctp_style(sk, TCP) &&
1492	sctp_sstate(sk, ESTABLISHED)) \|\|	1492	sctp_sstate(sk, ESTABLISHED)) \|\|
1493	sctp_endpoint_is_peeled_off(ep, &to)) {	1493	sctp_endpoint_is_peeled_off(ep, &to)) {
1494	err = -EADDRNOTAVAIL;	1494	err = -EADDRNOTAVAIL;
1495	goto out_unlock;	1495	goto out_unlock;
1496	}	1496	}
1497	}	1497	}
1498	} else {	1498	} else {
1499	asoc = sctp_id2assoc(sk, associd);	1499	asoc = sctp_id2assoc(sk, associd);
1500	if (!asoc) {	1500	if (!asoc) {
1501	err = -EPIPE;	1501	err = -EPIPE;
1502	goto out_unlock;	1502	goto out_unlock;
1503	}	1503	}
1504	}	1504	}
1505		1505
1506	if (asoc) {	1506	if (asoc) {
1507	SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc);	1507	SCTP_DEBUG_PRINTK("Just looked up association: %p.\n", asoc);
1508		1508
1509	/* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED	1509	/* We cannot send a message on a TCP-style SCTP_SS_ESTABLISHED
1510	* socket that has an association in CLOSED state. This can	1510	* socket that has an association in CLOSED state. This can
1511	* happen when an accepted socket has an association that is	1511	* happen when an accepted socket has an association that is
1512	* already CLOSED.	1512	* already CLOSED.
1513	*/	1513	*/
1514	if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {	1514	if (sctp_state(asoc, CLOSED) && sctp_style(sk, TCP)) {
1515	err = -EPIPE;	1515	err = -EPIPE;
1516	goto out_unlock;	1516	goto out_unlock;
1517	}	1517	}
1518		1518
1519	if (sinfo_flags & SCTP_EOF) {	1519	if (sinfo_flags & SCTP_EOF) {
1520	SCTP_DEBUG_PRINTK("Shutting down association: %p\n",	1520	SCTP_DEBUG_PRINTK("Shutting down association: %p\n",
1521	asoc);	1521	asoc);
1522	sctp_primitive_SHUTDOWN(asoc, NULL);	1522	sctp_primitive_SHUTDOWN(asoc, NULL);
1523	err = 0;	1523	err = 0;
1524	goto out_unlock;	1524	goto out_unlock;
1525	}	1525	}
1526	if (sinfo_flags & SCTP_ABORT) {	1526	if (sinfo_flags & SCTP_ABORT) {
1527	struct sctp_chunk *chunk;	1527	struct sctp_chunk *chunk;
1528		1528
1529	chunk = sctp_make_abort_user(asoc, msg, msg_len);	1529	chunk = sctp_make_abort_user(asoc, msg, msg_len);
1530	if (!chunk) {	1530	if (!chunk) {
1531	err = -ENOMEM;	1531	err = -ENOMEM;
1532	goto out_unlock;	1532	goto out_unlock;
1533	}	1533	}
1534		1534
1535	SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc);	1535	SCTP_DEBUG_PRINTK("Aborting association: %p\n", asoc);
1536	sctp_primitive_ABORT(asoc, chunk);	1536	sctp_primitive_ABORT(asoc, chunk);
1537	err = 0;	1537	err = 0;
1538	goto out_unlock;	1538	goto out_unlock;
1539	}	1539	}
1540	}	1540	}
1541		1541
1542	/* Do we need to create the association? */	1542	/* Do we need to create the association? */
1543	if (!asoc) {	1543	if (!asoc) {
1544	SCTP_DEBUG_PRINTK("There is no association yet.\n");	1544	SCTP_DEBUG_PRINTK("There is no association yet.\n");
1545		1545
1546	if (sinfo_flags & (SCTP_EOF \| SCTP_ABORT)) {	1546	if (sinfo_flags & (SCTP_EOF \| SCTP_ABORT)) {
1547	err = -EINVAL;	1547	err = -EINVAL;
1548	goto out_unlock;	1548	goto out_unlock;
1549	}	1549	}
1550		1550
1551	/* Check for invalid stream against the stream counts,	1551	/* Check for invalid stream against the stream counts,
1552	* either the default or the user specified stream counts.	1552	* either the default or the user specified stream counts.
1553	*/	1553	*/
1554	if (sinfo) {	1554	if (sinfo) {
1555	if (!sinit \|\| (sinit && !sinit->sinit_num_ostreams)) {	1555	if (!sinit \|\| (sinit && !sinit->sinit_num_ostreams)) {
1556	/* Check against the defaults. */	1556	/* Check against the defaults. */
1557	if (sinfo->sinfo_stream >=	1557	if (sinfo->sinfo_stream >=
1558	sp->initmsg.sinit_num_ostreams) {	1558	sp->initmsg.sinit_num_ostreams) {
1559	err = -EINVAL;	1559	err = -EINVAL;
1560	goto out_unlock;	1560	goto out_unlock;
1561	}	1561	}
1562	} else {	1562	} else {
1563	/* Check against the requested. */	1563	/* Check against the requested. */
1564	if (sinfo->sinfo_stream >=	1564	if (sinfo->sinfo_stream >=
1565	sinit->sinit_num_ostreams) {	1565	sinit->sinit_num_ostreams) {
1566	err = -EINVAL;	1566	err = -EINVAL;
1567	goto out_unlock;	1567	goto out_unlock;
1568	}	1568	}
1569	}	1569	}
1570	}	1570	}
1571		1571
1572	/*	1572	/*
1573	* API 3.1.2 bind() - UDP Style Syntax	1573	* API 3.1.2 bind() - UDP Style Syntax
1574	* If a bind() or sctp_bindx() is not called prior to a	1574	* If a bind() or sctp_bindx() is not called prior to a
1575	* sendmsg() call that initiates a new association, the	1575	* sendmsg() call that initiates a new association, the
1576	* system picks an ephemeral port and will choose an address	1576	* system picks an ephemeral port and will choose an address
1577	* set equivalent to binding with a wildcard address.	1577	* set equivalent to binding with a wildcard address.
1578	*/	1578	*/
1579	if (!ep->base.bind_addr.port) {	1579	if (!ep->base.bind_addr.port) {
1580	if (sctp_autobind(sk)) {	1580	if (sctp_autobind(sk)) {
1581	err = -EAGAIN;	1581	err = -EAGAIN;
1582	goto out_unlock;	1582	goto out_unlock;
1583	}	1583	}
1584	} else {	1584	} else {
1585	/*	1585	/*
1586	* If an unprivileged user inherits a one-to-many	1586	* If an unprivileged user inherits a one-to-many
1587	* style socket with open associations on a privileged	1587	* style socket with open associations on a privileged
1588	* port, it MAY be permitted to accept new associations,	1588	* port, it MAY be permitted to accept new associations,
1589	* but it SHOULD NOT be permitted to open new	1589	* but it SHOULD NOT be permitted to open new
1590	* associations.	1590	* associations.
1591	*/	1591	*/
1592	if (ep->base.bind_addr.port < PROT_SOCK &&	1592	if (ep->base.bind_addr.port < PROT_SOCK &&
1593	!capable(CAP_NET_BIND_SERVICE)) {	1593	!capable(CAP_NET_BIND_SERVICE)) {
1594	err = -EACCES;	1594	err = -EACCES;
1595	goto out_unlock;	1595	goto out_unlock;
1596	}	1596	}
1597	}	1597	}
1598		1598
1599	scope = sctp_scope(&to);	1599	scope = sctp_scope(&to);
1600	new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);	1600	new_asoc = sctp_association_new(ep, sk, scope, GFP_KERNEL);
1601	if (!new_asoc) {	1601	if (!new_asoc) {
1602	err = -ENOMEM;	1602	err = -ENOMEM;
1603	goto out_unlock;	1603	goto out_unlock;
1604	}	1604	}
1605	asoc = new_asoc;	1605	asoc = new_asoc;
1606		1606
1607	/* If the SCTP_INIT ancillary data is specified, set all	1607	/* If the SCTP_INIT ancillary data is specified, set all
1608	* the association init values accordingly.	1608	* the association init values accordingly.
1609	*/	1609	*/
1610	if (sinit) {	1610	if (sinit) {
1611	if (sinit->sinit_num_ostreams) {	1611	if (sinit->sinit_num_ostreams) {
1612	asoc->c.sinit_num_ostreams =	1612	asoc->c.sinit_num_ostreams =
1613	sinit->sinit_num_ostreams;	1613	sinit->sinit_num_ostreams;
1614	}	1614	}
1615	if (sinit->sinit_max_instreams) {	1615	if (sinit->sinit_max_instreams) {
1616	asoc->c.sinit_max_instreams =	1616	asoc->c.sinit_max_instreams =
1617	sinit->sinit_max_instreams;	1617	sinit->sinit_max_instreams;
1618	}	1618	}
1619	if (sinit->sinit_max_attempts) {	1619	if (sinit->sinit_max_attempts) {
1620	asoc->max_init_attempts	1620	asoc->max_init_attempts
1621	= sinit->sinit_max_attempts;	1621	= sinit->sinit_max_attempts;
1622	}	1622	}
1623	if (sinit->sinit_max_init_timeo) {	1623	if (sinit->sinit_max_init_timeo) {
1624	asoc->max_init_timeo =	1624	asoc->max_init_timeo =
1625	msecs_to_jiffies(sinit->sinit_max_init_timeo);	1625	msecs_to_jiffies(sinit->sinit_max_init_timeo);
1626	}	1626	}
1627	}	1627	}
1628		1628
1629	/* Prime the peer's transport structures. */	1629	/* Prime the peer's transport structures. */
1630	transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);	1630	transport = sctp_assoc_add_peer(asoc, &to, GFP_KERNEL, SCTP_UNKNOWN);
1631	if (!transport) {	1631	if (!transport) {
1632	err = -ENOMEM;	1632	err = -ENOMEM;
1633	goto out_free;	1633	goto out_free;
1634	}	1634	}
1635	err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);	1635	err = sctp_assoc_set_bind_addr_from_ep(asoc, GFP_KERNEL);
1636	if (err < 0) {	1636	if (err < 0) {
1637	err = -ENOMEM;	1637	err = -ENOMEM;
1638	goto out_free;	1638	goto out_free;
1639	}	1639	}
1640	}	1640	}
1641		1641
1642	/* ASSERT: we have a valid association at this point. */	1642	/* ASSERT: we have a valid association at this point. */
1643	SCTP_DEBUG_PRINTK("We have a valid association.\n");	1643	SCTP_DEBUG_PRINTK("We have a valid association.\n");
1644		1644
1645	if (!sinfo) {	1645	if (!sinfo) {
1646	/* If the user didn't specify SNDRCVINFO, make up one with	1646	/* If the user didn't specify SNDRCVINFO, make up one with
1647	* some defaults.	1647	* some defaults.
1648	*/	1648	*/
1649	default_sinfo.sinfo_stream = asoc->default_stream;	1649	default_sinfo.sinfo_stream = asoc->default_stream;
1650	default_sinfo.sinfo_flags = asoc->default_flags;	1650	default_sinfo.sinfo_flags = asoc->default_flags;
1651	default_sinfo.sinfo_ppid = asoc->default_ppid;	1651	default_sinfo.sinfo_ppid = asoc->default_ppid;
1652	default_sinfo.sinfo_context = asoc->default_context;	1652	default_sinfo.sinfo_context = asoc->default_context;
1653	default_sinfo.sinfo_timetolive = asoc->default_timetolive;	1653	default_sinfo.sinfo_timetolive = asoc->default_timetolive;
1654	default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);	1654	default_sinfo.sinfo_assoc_id = sctp_assoc2id(asoc);
1655	sinfo = &default_sinfo;	1655	sinfo = &default_sinfo;
1656	}	1656	}
1657		1657
1658	/* API 7.1.7, the sndbuf size per association bounds the	1658	/* API 7.1.7, the sndbuf size per association bounds the
1659	* maximum size of data that can be sent in a single send call.	1659	* maximum size of data that can be sent in a single send call.
1660	*/	1660	*/
1661	if (msg_len > sk->sk_sndbuf) {	1661	if (msg_len > sk->sk_sndbuf) {
1662	err = -EMSGSIZE;	1662	err = -EMSGSIZE;
1663	goto out_free;	1663	goto out_free;
1664	}	1664	}
1665		1665
1666	/* If fragmentation is disabled and the message length exceeds the	1666	/* If fragmentation is disabled and the message length exceeds the
1667	* association fragmentation point, return EMSGSIZE. The I-D	1667	* association fragmentation point, return EMSGSIZE. The I-D
1668	* does not specify what this error is, but this looks like	1668	* does not specify what this error is, but this looks like
1669	* a great fit.	1669	* a great fit.
1670	*/	1670	*/
1671	if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {	1671	if (sctp_sk(sk)->disable_fragments && (msg_len > asoc->frag_point)) {
1672	err = -EMSGSIZE;	1672	err = -EMSGSIZE;
1673	goto out_free;	1673	goto out_free;
1674	}	1674	}
1675		1675
1676	if (sinfo) {	1676	if (sinfo) {
1677	/* Check for invalid stream. */	1677	/* Check for invalid stream. */
1678	if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) {	1678	if (sinfo->sinfo_stream >= asoc->c.sinit_num_ostreams) {
1679	err = -EINVAL;	1679	err = -EINVAL;
1680	goto out_free;	1680	goto out_free;
1681	}	1681	}
1682	}	1682	}
1683		1683
1684	timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);	1684	timeo = sock_sndtimeo(sk, msg->msg_flags & MSG_DONTWAIT);
1685	if (!sctp_wspace(asoc)) {	1685	if (!sctp_wspace(asoc)) {
1686	err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);	1686	err = sctp_wait_for_sndbuf(asoc, &timeo, msg_len);
1687	if (err)	1687	if (err)
1688	goto out_free;	1688	goto out_free;
1689	}	1689	}
1690		1690
1691	/* If an address is passed with the sendto/sendmsg call, it is used	1691	/* If an address is passed with the sendto/sendmsg call, it is used
1692	* to override the primary destination address in the TCP model, or	1692	* to override the primary destination address in the TCP model, or
1693	* when SCTP_ADDR_OVER flag is set in the UDP model.	1693	* when SCTP_ADDR_OVER flag is set in the UDP model.
1694	*/	1694	*/
1695	if ((sctp_style(sk, TCP) && msg_name) \|\|	1695	if ((sctp_style(sk, TCP) && msg_name) \|\|
1696	(sinfo_flags & SCTP_ADDR_OVER)) {	1696	(sinfo_flags & SCTP_ADDR_OVER)) {
1697	chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);	1697	chunk_tp = sctp_assoc_lookup_paddr(asoc, &to);
1698	if (!chunk_tp) {	1698	if (!chunk_tp) {
1699	err = -EINVAL;	1699	err = -EINVAL;
1700	goto out_free;	1700	goto out_free;
1701	}	1701	}
1702	} else	1702	} else
1703	chunk_tp = NULL;	1703	chunk_tp = NULL;
1704		1704
1705	/* Auto-connect, if we aren't connected already. */	1705	/* Auto-connect, if we aren't connected already. */
1706	if (sctp_state(asoc, CLOSED)) {	1706	if (sctp_state(asoc, CLOSED)) {
1707	err = sctp_primitive_ASSOCIATE(asoc, NULL);	1707	err = sctp_primitive_ASSOCIATE(asoc, NULL);
1708	if (err < 0)	1708	if (err < 0)
1709	goto out_free;	1709	goto out_free;
1710	SCTP_DEBUG_PRINTK("We associated primitively.\n");	1710	SCTP_DEBUG_PRINTK("We associated primitively.\n");
1711	}	1711	}
1712		1712
1713	/* Break the message into multiple chunks of maximum size. */	1713	/* Break the message into multiple chunks of maximum size. */
1714	datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len);	1714	datamsg = sctp_datamsg_from_user(asoc, sinfo, msg, msg_len);
1715	if (!datamsg) {	1715	if (!datamsg) {
1716	err = -ENOMEM;	1716	err = -ENOMEM;
1717	goto out_free;	1717	goto out_free;
1718	}	1718	}
1719		1719
1720	/* Now send the (possibly) fragmented message. */	1720	/* Now send the (possibly) fragmented message. */
1721	list_for_each(pos, &datamsg->chunks) {	1721	list_for_each(pos, &datamsg->chunks) {
1722	chunk = list_entry(pos, struct sctp_chunk, frag_list);	1722	chunk = list_entry(pos, struct sctp_chunk, frag_list);
1723	sctp_datamsg_track(chunk);	1723	sctp_datamsg_track(chunk);
1724		1724
1725	/* Do accounting for the write space. */	1725	/* Do accounting for the write space. */
1726	sctp_set_owner_w(chunk);	1726	sctp_set_owner_w(chunk);
1727		1727
1728	chunk->transport = chunk_tp;	1728	chunk->transport = chunk_tp;
1729		1729
1730	/* Send it to the lower layers. Note: all chunks	1730	/* Send it to the lower layers. Note: all chunks
1731	* must either fail or succeed. The lower layer	1731	* must either fail or succeed. The lower layer
1732	* works that way today. Keep it that way or this	1732	* works that way today. Keep it that way or this
1733	* breaks.	1733	* breaks.
1734	*/	1734	*/
1735	err = sctp_primitive_SEND(asoc, chunk);	1735	err = sctp_primitive_SEND(asoc, chunk);
1736	/* Did the lower layer accept the chunk? */	1736	/* Did the lower layer accept the chunk? */
1737	if (err)	1737	if (err)
1738	sctp_chunk_free(chunk);	1738	sctp_chunk_free(chunk);
1739	SCTP_DEBUG_PRINTK("We sent primitively.\n");	1739	SCTP_DEBUG_PRINTK("We sent primitively.\n");
1740	}	1740	}
1741		1741
1742	sctp_datamsg_free(datamsg);	1742	sctp_datamsg_free(datamsg);
1743	if (err)	1743	if (err)
1744	goto out_free;	1744	goto out_free;
1745	else	1745	else
1746	err = msg_len;	1746	err = msg_len;
1747		1747
1748	/* If we are already past ASSOCIATE, the lower	1748	/* If we are already past ASSOCIATE, the lower
1749	* layers are responsible for association cleanup.	1749	* layers are responsible for association cleanup.
1750	*/	1750	*/
1751	goto out_unlock;	1751	goto out_unlock;
1752		1752
1753	out_free:	1753	out_free:
1754	if (new_asoc)	1754	if (new_asoc)
1755	sctp_association_free(asoc);	1755	sctp_association_free(asoc);
1756	out_unlock:	1756	out_unlock:
1757	sctp_release_sock(sk);	1757	sctp_release_sock(sk);
1758		1758
1759	out_nounlock:	1759	out_nounlock:
1760	return sctp_error(sk, msg_flags, err);	1760	return sctp_error(sk, msg_flags, err);
1761		1761
1762	#if 0	1762	#if 0
1763	do_sock_err:	1763	do_sock_err:
1764	if (msg_len)	1764	if (msg_len)
1765	err = msg_len;	1765	err = msg_len;
1766	else	1766	else
1767	err = sock_error(sk);	1767	err = sock_error(sk);
1768	goto out;	1768	goto out;
1769		1769
1770	do_interrupted:	1770	do_interrupted:
1771	if (msg_len)	1771	if (msg_len)
1772	err = msg_len;	1772	err = msg_len;
1773	goto out;	1773	goto out;
1774	#endif /* 0 */	1774	#endif /* 0 */
1775	}	1775	}
1776		1776
1777	/* This is an extended version of skb_pull() that removes the data from the	1777	/* This is an extended version of skb_pull() that removes the data from the
1778	* start of a skb even when data is spread across the list of skb's in the	1778	* start of a skb even when data is spread across the list of skb's in the
1779	* frag_list. len specifies the total amount of data that needs to be removed.	1779	* frag_list. len specifies the total amount of data that needs to be removed.
1780	* when 'len' bytes could be removed from the skb, it returns 0.	1780	* when 'len' bytes could be removed from the skb, it returns 0.
1781	* If 'len' exceeds the total skb length, it returns the no. of bytes that	1781	* If 'len' exceeds the total skb length, it returns the no. of bytes that
1782	* could not be removed.	1782	* could not be removed.
1783	*/	1783	*/
1784	static int sctp_skb_pull(struct sk_buff *skb, int len)	1784	static int sctp_skb_pull(struct sk_buff *skb, int len)
1785	{	1785	{
1786	struct sk_buff *list;	1786	struct sk_buff *list;
1787	int skb_len = skb_headlen(skb);	1787	int skb_len = skb_headlen(skb);
1788	int rlen;	1788	int rlen;
1789		1789
1790	if (len <= skb_len) {	1790	if (len <= skb_len) {
1791	__skb_pull(skb, len);	1791	__skb_pull(skb, len);
1792	return 0;	1792	return 0;
1793	}	1793	}
1794	len -= skb_len;	1794	len -= skb_len;
1795	__skb_pull(skb, skb_len);	1795	__skb_pull(skb, skb_len);
1796		1796
1797	for (list = skb_shinfo(skb)->frag_list; list; list = list->next) {	1797	for (list = skb_shinfo(skb)->frag_list; list; list = list->next) {
1798	rlen = sctp_skb_pull(list, len);	1798	rlen = sctp_skb_pull(list, len);
1799	skb->len -= (len-rlen);	1799	skb->len -= (len-rlen);
1800	skb->data_len -= (len-rlen);	1800	skb->data_len -= (len-rlen);
1801		1801
1802	if (!rlen)	1802	if (!rlen)
1803	return 0;	1803	return 0;
1804		1804
1805	len = rlen;	1805	len = rlen;
1806	}	1806	}
1807		1807
1808	return len;	1808	return len;
1809	}	1809	}
1810		1810
1811	/* API 3.1.3 recvmsg() - UDP Style Syntax	1811	/* API 3.1.3 recvmsg() - UDP Style Syntax
1812	*	1812	*
1813	* ssize_t recvmsg(int socket, struct msghdr *message,	1813	* ssize_t recvmsg(int socket, struct msghdr *message,
1814	* int flags);	1814	* int flags);
1815	*	1815	*
1816	* socket - the socket descriptor of the endpoint.	1816	* socket - the socket descriptor of the endpoint.
1817	* message - pointer to the msghdr structure which contains a single	1817	* message - pointer to the msghdr structure which contains a single
1818	* user message and possibly some ancillary data.	1818	* user message and possibly some ancillary data.
1819	*	1819	*
1820	* See Section 5 for complete description of the data	1820	* See Section 5 for complete description of the data
1821	* structures.	1821	* structures.
1822	*	1822	*
1823	* flags - flags sent or received with the user message, see Section	1823	* flags - flags sent or received with the user message, see Section
1824	* 5 for complete description of the flags.	1824	* 5 for complete description of the flags.
1825	*/	1825	*/
1826	static struct sk_buff sctp_skb_recv_datagram(struct sock , int, int, int *);	1826	static struct sk_buff sctp_skb_recv_datagram(struct sock , int, int, int *);
1827		1827
1828	SCTP_STATIC int sctp_recvmsg(struct kiocb iocb, struct sock sk,	1828	SCTP_STATIC int sctp_recvmsg(struct kiocb iocb, struct sock sk,
1829	struct msghdr *msg, size_t len, int noblock,	1829	struct msghdr *msg, size_t len, int noblock,
1830	int flags, int *addr_len)	1830	int flags, int *addr_len)
1831	{	1831	{
1832	struct sctp_ulpevent *event = NULL;	1832	struct sctp_ulpevent *event = NULL;
1833	struct sctp_sock *sp = sctp_sk(sk);	1833	struct sctp_sock *sp = sctp_sk(sk);
1834	struct sk_buff *skb;	1834	struct sk_buff *skb;
1835	int copied;	1835	int copied;
1836	int err = 0;	1836	int err = 0;
1837	int skb_len;	1837	int skb_len;
1838		1838
1839	SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: "	1839	SCTP_DEBUG_PRINTK("sctp_recvmsg(%s: %p, %s: %p, %s: %zd, %s: %d, %s: "
1840	"0x%x, %s: %p)\n", "sk", sk, "msghdr", msg,	1840	"0x%x, %s: %p)\n", "sk", sk, "msghdr", msg,
1841	"len", len, "knoblauch", noblock,	1841	"len", len, "knoblauch", noblock,
1842	"flags", flags, "addr_len", addr_len);	1842	"flags", flags, "addr_len", addr_len);
1843		1843
1844	sctp_lock_sock(sk);	1844	sctp_lock_sock(sk);
1845		1845
1846	if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) {	1846	if (sctp_style(sk, TCP) && !sctp_sstate(sk, ESTABLISHED)) {
1847	err = -ENOTCONN;	1847	err = -ENOTCONN;
1848	goto out;	1848	goto out;
1849	}	1849	}
1850		1850
1851	skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);	1851	skb = sctp_skb_recv_datagram(sk, flags, noblock, &err);
1852	if (!skb)	1852	if (!skb)
1853	goto out;	1853	goto out;
1854		1854
1855	/* Get the total length of the skb including any skb's in the	1855	/* Get the total length of the skb including any skb's in the
1856	* frag_list.	1856	* frag_list.
1857	*/	1857	*/
1858	skb_len = skb->len;	1858	skb_len = skb->len;
1859		1859
1860	copied = skb_len;	1860	copied = skb_len;
1861	if (copied > len)	1861	if (copied > len)
1862	copied = len;	1862	copied = len;
1863		1863
1864	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);	1864	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1865		1865
1866	event = sctp_skb2event(skb);	1866	event = sctp_skb2event(skb);
1867		1867
1868	if (err)	1868	if (err)
1869	goto out_free;	1869	goto out_free;
1870		1870
1871	sock_recv_timestamp(msg, sk, skb);	1871	sock_recv_timestamp(msg, sk, skb);
1872	if (sctp_ulpevent_is_notification(event)) {	1872	if (sctp_ulpevent_is_notification(event)) {
1873	msg->msg_flags \|= MSG_NOTIFICATION;	1873	msg->msg_flags \|= MSG_NOTIFICATION;
1874	sp->pf->event_msgname(event, msg->msg_name, addr_len);	1874	sp->pf->event_msgname(event, msg->msg_name, addr_len);
1875	} else {	1875	} else {
1876	sp->pf->skb_msgname(skb, msg->msg_name, addr_len);	1876	sp->pf->skb_msgname(skb, msg->msg_name, addr_len);
1877	}	1877	}
1878		1878
1879	/* Check if we allow SCTP_SNDRCVINFO. */	1879	/* Check if we allow SCTP_SNDRCVINFO. */
1880	if (sp->subscribe.sctp_data_io_event)	1880	if (sp->subscribe.sctp_data_io_event)
1881	sctp_ulpevent_read_sndrcvinfo(event, msg);	1881	sctp_ulpevent_read_sndrcvinfo(event, msg);
1882	#if 0	1882	#if 0
1883	/* FIXME: we should be calling IP/IPv6 layers. */	1883	/* FIXME: we should be calling IP/IPv6 layers. */
1884	if (sk->sk_protinfo.af_inet.cmsg_flags)	1884	if (sk->sk_protinfo.af_inet.cmsg_flags)
1885	ip_cmsg_recv(msg, skb);	1885	ip_cmsg_recv(msg, skb);
1886	#endif	1886	#endif
1887		1887
1888	err = copied;	1888	err = copied;
1889		1889
1890	/* If skb's length exceeds the user's buffer, update the skb and	1890	/* If skb's length exceeds the user's buffer, update the skb and
1891	* push it back to the receive_queue so that the next call to	1891	* push it back to the receive_queue so that the next call to
1892	* recvmsg() will return the remaining data. Don't set MSG_EOR.	1892	* recvmsg() will return the remaining data. Don't set MSG_EOR.
1893	*/	1893	*/
1894	if (skb_len > copied) {	1894	if (skb_len > copied) {
1895	msg->msg_flags &= ~MSG_EOR;	1895	msg->msg_flags &= ~MSG_EOR;
1896	if (flags & MSG_PEEK)	1896	if (flags & MSG_PEEK)
1897	goto out_free;	1897	goto out_free;
1898	sctp_skb_pull(skb, copied);	1898	sctp_skb_pull(skb, copied);
1899	skb_queue_head(&sk->sk_receive_queue, skb);	1899	skb_queue_head(&sk->sk_receive_queue, skb);
1900		1900
1901	/* When only partial message is copied to the user, increase	1901	/* When only partial message is copied to the user, increase
1902	* rwnd by that amount. If all the data in the skb is read,	1902	* rwnd by that amount. If all the data in the skb is read,
1903	* rwnd is updated when the event is freed.	1903	* rwnd is updated when the event is freed.
1904	*/	1904	*/
1905	sctp_assoc_rwnd_increase(event->asoc, copied);	1905	sctp_assoc_rwnd_increase(event->asoc, copied);
1906	goto out;	1906	goto out;
1907	} else if ((event->msg_flags & MSG_NOTIFICATION) \|\|	1907	} else if ((event->msg_flags & MSG_NOTIFICATION) \|\|
1908	(event->msg_flags & MSG_EOR))	1908	(event->msg_flags & MSG_EOR))
1909	msg->msg_flags \|= MSG_EOR;	1909	msg->msg_flags \|= MSG_EOR;
1910	else	1910	else
1911	msg->msg_flags &= ~MSG_EOR;	1911	msg->msg_flags &= ~MSG_EOR;
1912		1912
1913	out_free:	1913	out_free:
1914	if (flags & MSG_PEEK) {	1914	if (flags & MSG_PEEK) {
1915	/* Release the skb reference acquired after peeking the skb in	1915	/* Release the skb reference acquired after peeking the skb in
1916	* sctp_skb_recv_datagram().	1916	* sctp_skb_recv_datagram().
1917	*/	1917	*/
1918	kfree_skb(skb);	1918	kfree_skb(skb);
1919	} else {	1919	} else {
1920	/* Free the event which includes releasing the reference to	1920	/* Free the event which includes releasing the reference to
1921	* the owner of the skb, freeing the skb and updating the	1921	* the owner of the skb, freeing the skb and updating the
1922	* rwnd.	1922	* rwnd.
1923	*/	1923	*/
1924	sctp_ulpevent_free(event);	1924	sctp_ulpevent_free(event);
1925	}	1925	}
1926	out:	1926	out:
1927	sctp_release_sock(sk);	1927	sctp_release_sock(sk);
1928	return err;	1928	return err;
1929	}	1929	}
1930		1930
1931	/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)	1931	/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
1932	*	1932	*
1933	* This option is a on/off flag. If enabled no SCTP message	1933	* This option is a on/off flag. If enabled no SCTP message
1934	* fragmentation will be performed. Instead if a message being sent	1934	* fragmentation will be performed. Instead if a message being sent
1935	* exceeds the current PMTU size, the message will NOT be sent and	1935	* exceeds the current PMTU size, the message will NOT be sent and
1936	* instead a error will be indicated to the user.	1936	* instead a error will be indicated to the user.
1937	*/	1937	*/
1938	static int sctp_setsockopt_disable_fragments(struct sock *sk,	1938	static int sctp_setsockopt_disable_fragments(struct sock *sk,
1939	char __user *optval, int optlen)	1939	char __user *optval, int optlen)
1940	{	1940	{
1941	int val;	1941	int val;
1942		1942
1943	if (optlen < sizeof(int))	1943	if (optlen < sizeof(int))
1944	return -EINVAL;	1944	return -EINVAL;
1945		1945
1946	if (get_user(val, (int __user *)optval))	1946	if (get_user(val, (int __user *)optval))
1947	return -EFAULT;	1947	return -EFAULT;
1948		1948
1949	sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;	1949	sctp_sk(sk)->disable_fragments = (val == 0) ? 0 : 1;
1950		1950
1951	return 0;	1951	return 0;
1952	}	1952	}
1953		1953
1954	static int sctp_setsockopt_events(struct sock sk, char __user optval,	1954	static int sctp_setsockopt_events(struct sock sk, char __user optval,
1955	int optlen)	1955	int optlen)
1956	{	1956	{
1957	if (optlen != sizeof(struct sctp_event_subscribe))	1957	if (optlen != sizeof(struct sctp_event_subscribe))
1958	return -EINVAL;	1958	return -EINVAL;
1959	if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))	1959	if (copy_from_user(&sctp_sk(sk)->subscribe, optval, optlen))
1960	return -EFAULT;	1960	return -EFAULT;
1961	return 0;	1961	return 0;
1962	}	1962	}
1963		1963
1964	/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)	1964	/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
1965	*	1965	*
1966	* This socket option is applicable to the UDP-style socket only. When	1966	* This socket option is applicable to the UDP-style socket only. When
1967	* set it will cause associations that are idle for more than the	1967	* set it will cause associations that are idle for more than the
1968	* specified number of seconds to automatically close. An association	1968	* specified number of seconds to automatically close. An association
1969	* being idle is defined an association that has NOT sent or received	1969	* being idle is defined an association that has NOT sent or received
1970	* user data. The special value of '0' indicates that no automatic	1970	* user data. The special value of '0' indicates that no automatic
1971	* close of any associations should be performed. The option expects an	1971	* close of any associations should be performed. The option expects an
1972	* integer defining the number of seconds of idle time before an	1972	* integer defining the number of seconds of idle time before an
1973	* association is closed.	1973	* association is closed.
1974	*/	1974	*/
1975	static int sctp_setsockopt_autoclose(struct sock sk, char __user optval,	1975	static int sctp_setsockopt_autoclose(struct sock sk, char __user optval,
1976	int optlen)	1976	int optlen)
1977	{	1977	{
1978	struct sctp_sock *sp = sctp_sk(sk);	1978	struct sctp_sock *sp = sctp_sk(sk);
1979		1979
1980	/* Applicable to UDP-style socket only */	1980	/* Applicable to UDP-style socket only */
1981	if (sctp_style(sk, TCP))	1981	if (sctp_style(sk, TCP))
1982	return -EOPNOTSUPP;	1982	return -EOPNOTSUPP;
1983	if (optlen != sizeof(int))	1983	if (optlen != sizeof(int))
1984	return -EINVAL;	1984	return -EINVAL;
1985	if (copy_from_user(&sp->autoclose, optval, optlen))	1985	if (copy_from_user(&sp->autoclose, optval, optlen))
1986	return -EFAULT;	1986	return -EFAULT;
1987		1987
1988	return 0;	1988	return 0;
1989	}	1989	}
1990		1990
1991	/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)	1991	/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
1992	*	1992	*
1993	* Applications can enable or disable heartbeats for any peer address of	1993	* Applications can enable or disable heartbeats for any peer address of
1994	* an association, modify an address's heartbeat interval, force a	1994	* an association, modify an address's heartbeat interval, force a
1995	* heartbeat to be sent immediately, and adjust the address's maximum	1995	* heartbeat to be sent immediately, and adjust the address's maximum
1996	* number of retransmissions sent before an address is considered	1996	* number of retransmissions sent before an address is considered
1997	* unreachable. The following structure is used to access and modify an	1997	* unreachable. The following structure is used to access and modify an
1998	* address's parameters:	1998	* address's parameters:
1999	*	1999	*
2000	* struct sctp_paddrparams {	2000	* struct sctp_paddrparams {
2001	* sctp_assoc_t spp_assoc_id;	2001	* sctp_assoc_t spp_assoc_id;
2002	* struct sockaddr_storage spp_address;	2002	* struct sockaddr_storage spp_address;
2003	* uint32_t spp_hbinterval;	2003	* uint32_t spp_hbinterval;
2004	* uint16_t spp_pathmaxrxt;	2004	* uint16_t spp_pathmaxrxt;
2005	* uint32_t spp_pathmtu;	2005	* uint32_t spp_pathmtu;
2006	* uint32_t spp_sackdelay;	2006	* uint32_t spp_sackdelay;
2007	* uint32_t spp_flags;	2007	* uint32_t spp_flags;
2008	* };	2008	* };
2009	*	2009	*
2010	* spp_assoc_id - (one-to-many style socket) This is filled in the	2010	* spp_assoc_id - (one-to-many style socket) This is filled in the
2011	* application, and identifies the association for	2011	* application, and identifies the association for
2012	* this query.	2012	* this query.
2013	* spp_address - This specifies which address is of interest.	2013	* spp_address - This specifies which address is of interest.
2014	* spp_hbinterval - This contains the value of the heartbeat interval,	2014	* spp_hbinterval - This contains the value of the heartbeat interval,
2015	* in milliseconds. If a value of zero	2015	* in milliseconds. If a value of zero
2016	* is present in this field then no changes are to	2016	* is present in this field then no changes are to
2017	* be made to this parameter.	2017	* be made to this parameter.
2018	* spp_pathmaxrxt - This contains the maximum number of	2018	* spp_pathmaxrxt - This contains the maximum number of
2019	* retransmissions before this address shall be	2019	* retransmissions before this address shall be
2020	* considered unreachable. If a value of zero	2020	* considered unreachable. If a value of zero
2021	* is present in this field then no changes are to	2021	* is present in this field then no changes are to
2022	* be made to this parameter.	2022	* be made to this parameter.
2023	* spp_pathmtu - When Path MTU discovery is disabled the value	2023	* spp_pathmtu - When Path MTU discovery is disabled the value
2024	* specified here will be the "fixed" path mtu.	2024	* specified here will be the "fixed" path mtu.
2025	* Note that if the spp_address field is empty	2025	* Note that if the spp_address field is empty
2026	* then all associations on this address will	2026	* then all associations on this address will
2027	* have this fixed path mtu set upon them.	2027	* have this fixed path mtu set upon them.
2028	*	2028	*
2029	* spp_sackdelay - When delayed sack is enabled, this value specifies	2029	* spp_sackdelay - When delayed sack is enabled, this value specifies
2030	* the number of milliseconds that sacks will be delayed	2030	* the number of milliseconds that sacks will be delayed
2031	* for. This value will apply to all addresses of an	2031	* for. This value will apply to all addresses of an
2032	* association if the spp_address field is empty. Note	2032	* association if the spp_address field is empty. Note
2033	* also, that if delayed sack is enabled and this	2033	* also, that if delayed sack is enabled and this
2034	* value is set to 0, no change is made to the last	2034	* value is set to 0, no change is made to the last
2035	* recorded delayed sack timer value.	2035	* recorded delayed sack timer value.
2036	*	2036	*
2037	* spp_flags - These flags are used to control various features	2037	* spp_flags - These flags are used to control various features
2038	* on an association. The flag field may contain	2038	* on an association. The flag field may contain
2039	* zero or more of the following options.	2039	* zero or more of the following options.
2040	*	2040	*
2041	* SPP_HB_ENABLE - Enable heartbeats on the	2041	* SPP_HB_ENABLE - Enable heartbeats on the
2042	* specified address. Note that if the address	2042	* specified address. Note that if the address
2043	* field is empty all addresses for the association	2043	* field is empty all addresses for the association
2044	* have heartbeats enabled upon them.	2044	* have heartbeats enabled upon them.
2045	*	2045	*
2046	* SPP_HB_DISABLE - Disable heartbeats on the	2046	* SPP_HB_DISABLE - Disable heartbeats on the
2047	* speicifed address. Note that if the address	2047	* speicifed address. Note that if the address
2048	* field is empty all addresses for the association	2048	* field is empty all addresses for the association
2049	* will have their heartbeats disabled. Note also	2049	* will have their heartbeats disabled. Note also
2050	* that SPP_HB_ENABLE and SPP_HB_DISABLE are	2050	* that SPP_HB_ENABLE and SPP_HB_DISABLE are
2051	* mutually exclusive, only one of these two should	2051	* mutually exclusive, only one of these two should
2052	* be specified. Enabling both fields will have	2052	* be specified. Enabling both fields will have
2053	* undetermined results.	2053	* undetermined results.
2054	*	2054	*
2055	* SPP_HB_DEMAND - Request a user initiated heartbeat	2055	* SPP_HB_DEMAND - Request a user initiated heartbeat
2056	* to be made immediately.	2056	* to be made immediately.
2057	*	2057	*
2058	* SPP_PMTUD_ENABLE - This field will enable PMTU	2058	* SPP_PMTUD_ENABLE - This field will enable PMTU
2059	* discovery upon the specified address. Note that	2059	* discovery upon the specified address. Note that
2060	* if the address feild is empty then all addresses	2060	* if the address feild is empty then all addresses
2061	* on the association are effected.	2061	* on the association are effected.
2062	*	2062	*
2063	* SPP_PMTUD_DISABLE - This field will disable PMTU	2063	* SPP_PMTUD_DISABLE - This field will disable PMTU
2064	* discovery upon the specified address. Note that	2064	* discovery upon the specified address. Note that
2065	* if the address feild is empty then all addresses	2065	* if the address feild is empty then all addresses
2066	* on the association are effected. Not also that	2066	* on the association are effected. Not also that
2067	* SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually	2067	* SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
2068	* exclusive. Enabling both will have undetermined	2068	* exclusive. Enabling both will have undetermined
2069	* results.	2069	* results.
2070	*	2070	*
2071	* SPP_SACKDELAY_ENABLE - Setting this flag turns	2071	* SPP_SACKDELAY_ENABLE - Setting this flag turns
2072	* on delayed sack. The time specified in spp_sackdelay	2072	* on delayed sack. The time specified in spp_sackdelay
2073	* is used to specify the sack delay for this address. Note	2073	* is used to specify the sack delay for this address. Note
2074	* that if spp_address is empty then all addresses will	2074	* that if spp_address is empty then all addresses will
2075	* enable delayed sack and take on the sack delay	2075	* enable delayed sack and take on the sack delay
2076	* value specified in spp_sackdelay.	2076	* value specified in spp_sackdelay.
2077	* SPP_SACKDELAY_DISABLE - Setting this flag turns	2077	* SPP_SACKDELAY_DISABLE - Setting this flag turns
2078	* off delayed sack. If the spp_address field is blank then	2078	* off delayed sack. If the spp_address field is blank then
2079	* delayed sack is disabled for the entire association. Note	2079	* delayed sack is disabled for the entire association. Note
2080	* also that this field is mutually exclusive to	2080	* also that this field is mutually exclusive to
2081	* SPP_SACKDELAY_ENABLE, setting both will have undefined	2081	* SPP_SACKDELAY_ENABLE, setting both will have undefined
2082	* results.	2082	* results.
2083	*/	2083	*/
2084	int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,	2084	static int sctp_apply_peer_addr_params(struct sctp_paddrparams *params,
2085	struct sctp_transport *trans,	2085	struct sctp_transport *trans,
2086	struct sctp_association *asoc,	2086	struct sctp_association *asoc,
2087	struct sctp_sock *sp,	2087	struct sctp_sock *sp,
2088	int hb_change,	2088	int hb_change,
2089	int pmtud_change,	2089	int pmtud_change,
2090	int sackdelay_change)	2090	int sackdelay_change)
2091	{	2091	{
2092	int error;	2092	int error;
2093		2093
2094	if (params->spp_flags & SPP_HB_DEMAND && trans) {	2094	if (params->spp_flags & SPP_HB_DEMAND && trans) {
2095	error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans);	2095	error = sctp_primitive_REQUESTHEARTBEAT (trans->asoc, trans);
2096	if (error)	2096	if (error)
2097	return error;	2097	return error;
2098	}	2098	}
2099		2099
2100	if (params->spp_hbinterval) {	2100	if (params->spp_hbinterval) {
2101	if (trans) {	2101	if (trans) {
2102	trans->hbinterval = msecs_to_jiffies(params->spp_hbinterval);	2102	trans->hbinterval = msecs_to_jiffies(params->spp_hbinterval);
2103	} else if (asoc) {	2103	} else if (asoc) {
2104	asoc->hbinterval = msecs_to_jiffies(params->spp_hbinterval);	2104	asoc->hbinterval = msecs_to_jiffies(params->spp_hbinterval);
2105	} else {	2105	} else {
2106	sp->hbinterval = params->spp_hbinterval;	2106	sp->hbinterval = params->spp_hbinterval;
2107	}	2107	}
2108	}	2108	}
2109		2109
2110	if (hb_change) {	2110	if (hb_change) {
2111	if (trans) {	2111	if (trans) {
2112	trans->param_flags =	2112	trans->param_flags =
2113	(trans->param_flags & ~SPP_HB) \| hb_change;	2113	(trans->param_flags & ~SPP_HB) \| hb_change;
2114	} else if (asoc) {	2114	} else if (asoc) {
2115	asoc->param_flags =	2115	asoc->param_flags =
2116	(asoc->param_flags & ~SPP_HB) \| hb_change;	2116	(asoc->param_flags & ~SPP_HB) \| hb_change;
2117	} else {	2117	} else {
2118	sp->param_flags =	2118	sp->param_flags =
2119	(sp->param_flags & ~SPP_HB) \| hb_change;	2119	(sp->param_flags & ~SPP_HB) \| hb_change;
2120	}	2120	}
2121	}	2121	}
2122		2122
2123	if (params->spp_pathmtu) {	2123	if (params->spp_pathmtu) {
2124	if (trans) {	2124	if (trans) {
2125	trans->pathmtu = params->spp_pathmtu;	2125	trans->pathmtu = params->spp_pathmtu;
2126	sctp_assoc_sync_pmtu(asoc);	2126	sctp_assoc_sync_pmtu(asoc);
2127	} else if (asoc) {	2127	} else if (asoc) {
2128	asoc->pathmtu = params->spp_pathmtu;	2128	asoc->pathmtu = params->spp_pathmtu;
2129	sctp_frag_point(sp, params->spp_pathmtu);	2129	sctp_frag_point(sp, params->spp_pathmtu);
2130	} else {	2130	} else {
2131	sp->pathmtu = params->spp_pathmtu;	2131	sp->pathmtu = params->spp_pathmtu;
2132	}	2132	}
2133	}	2133	}
2134		2134
2135	if (pmtud_change) {	2135	if (pmtud_change) {
2136	if (trans) {	2136	if (trans) {
2137	int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&	2137	int update = (trans->param_flags & SPP_PMTUD_DISABLE) &&
2138	(params->spp_flags & SPP_PMTUD_ENABLE);	2138	(params->spp_flags & SPP_PMTUD_ENABLE);
2139	trans->param_flags =	2139	trans->param_flags =
2140	(trans->param_flags & ~SPP_PMTUD) \| pmtud_change;	2140	(trans->param_flags & ~SPP_PMTUD) \| pmtud_change;
2141	if (update) {	2141	if (update) {
2142	sctp_transport_pmtu(trans);	2142	sctp_transport_pmtu(trans);
2143	sctp_assoc_sync_pmtu(asoc);	2143	sctp_assoc_sync_pmtu(asoc);
2144	}	2144	}
2145	} else if (asoc) {	2145	} else if (asoc) {
2146	asoc->param_flags =	2146	asoc->param_flags =
2147	(asoc->param_flags & ~SPP_PMTUD) \| pmtud_change;	2147	(asoc->param_flags & ~SPP_PMTUD) \| pmtud_change;
2148	} else {	2148	} else {
2149	sp->param_flags =	2149	sp->param_flags =
2150	(sp->param_flags & ~SPP_PMTUD) \| pmtud_change;	2150	(sp->param_flags & ~SPP_PMTUD) \| pmtud_change;
2151	}	2151	}
2152	}	2152	}
2153		2153
2154	if (params->spp_sackdelay) {	2154	if (params->spp_sackdelay) {
2155	if (trans) {	2155	if (trans) {
2156	trans->sackdelay =	2156	trans->sackdelay =
2157	msecs_to_jiffies(params->spp_sackdelay);	2157	msecs_to_jiffies(params->spp_sackdelay);
2158	} else if (asoc) {	2158	} else if (asoc) {
2159	asoc->sackdelay =	2159	asoc->sackdelay =
2160	msecs_to_jiffies(params->spp_sackdelay);	2160	msecs_to_jiffies(params->spp_sackdelay);
2161	} else {	2161	} else {
2162	sp->sackdelay = params->spp_sackdelay;	2162	sp->sackdelay = params->spp_sackdelay;
2163	}	2163	}
2164	}	2164	}
2165		2165
2166	if (sackdelay_change) {	2166	if (sackdelay_change) {
2167	if (trans) {	2167	if (trans) {
2168	trans->param_flags =	2168	trans->param_flags =
2169	(trans->param_flags & ~SPP_SACKDELAY) \|	2169	(trans->param_flags & ~SPP_SACKDELAY) \|
2170	sackdelay_change;	2170	sackdelay_change;
2171	} else if (asoc) {	2171	} else if (asoc) {
2172	asoc->param_flags =	2172	asoc->param_flags =
2173	(asoc->param_flags & ~SPP_SACKDELAY) \|	2173	(asoc->param_flags & ~SPP_SACKDELAY) \|
2174	sackdelay_change;	2174	sackdelay_change;
2175	} else {	2175	} else {
2176	sp->param_flags =	2176	sp->param_flags =
2177	(sp->param_flags & ~SPP_SACKDELAY) \|	2177	(sp->param_flags & ~SPP_SACKDELAY) \|
2178	sackdelay_change;	2178	sackdelay_change;
2179	}	2179	}
2180	}	2180	}
2181		2181
2182	if (params->spp_pathmaxrxt) {	2182	if (params->spp_pathmaxrxt) {
2183	if (trans) {	2183	if (trans) {
2184	trans->pathmaxrxt = params->spp_pathmaxrxt;	2184	trans->pathmaxrxt = params->spp_pathmaxrxt;
2185	} else if (asoc) {	2185	} else if (asoc) {
2186	asoc->pathmaxrxt = params->spp_pathmaxrxt;	2186	asoc->pathmaxrxt = params->spp_pathmaxrxt;
2187	} else {	2187	} else {
2188	sp->pathmaxrxt = params->spp_pathmaxrxt;	2188	sp->pathmaxrxt = params->spp_pathmaxrxt;
2189	}	2189	}
2190	}	2190	}
2191		2191
2192	return 0;	2192	return 0;
2193	}	2193	}
2194		2194
2195	static int sctp_setsockopt_peer_addr_params(struct sock *sk,	2195	static int sctp_setsockopt_peer_addr_params(struct sock *sk,
2196	char __user *optval, int optlen)	2196	char __user *optval, int optlen)
2197	{	2197	{
2198	struct sctp_paddrparams params;	2198	struct sctp_paddrparams params;
2199	struct sctp_transport *trans = NULL;	2199	struct sctp_transport *trans = NULL;
2200	struct sctp_association *asoc = NULL;	2200	struct sctp_association *asoc = NULL;
2201	struct sctp_sock *sp = sctp_sk(sk);	2201	struct sctp_sock *sp = sctp_sk(sk);
2202	int error;	2202	int error;
2203	int hb_change, pmtud_change, sackdelay_change;	2203	int hb_change, pmtud_change, sackdelay_change;
2204		2204
2205	if (optlen != sizeof(struct sctp_paddrparams))	2205	if (optlen != sizeof(struct sctp_paddrparams))
2206	return - EINVAL;	2206	return - EINVAL;
2207		2207
2208	if (copy_from_user(&params, optval, optlen))	2208	if (copy_from_user(&params, optval, optlen))
2209	return -EFAULT;	2209	return -EFAULT;
2210		2210
2211	/* Validate flags and value parameters. */	2211	/* Validate flags and value parameters. */
2212	hb_change = params.spp_flags & SPP_HB;	2212	hb_change = params.spp_flags & SPP_HB;
2213	pmtud_change = params.spp_flags & SPP_PMTUD;	2213	pmtud_change = params.spp_flags & SPP_PMTUD;
2214	sackdelay_change = params.spp_flags & SPP_SACKDELAY;	2214	sackdelay_change = params.spp_flags & SPP_SACKDELAY;
2215		2215
2216	if (hb_change == SPP_HB \|\|	2216	if (hb_change == SPP_HB \|\|
2217	pmtud_change == SPP_PMTUD \|\|	2217	pmtud_change == SPP_PMTUD \|\|
2218	sackdelay_change == SPP_SACKDELAY \|\|	2218	sackdelay_change == SPP_SACKDELAY \|\|
2219	params.spp_sackdelay > 500 \|\|	2219	params.spp_sackdelay > 500 \|\|
2220	(params.spp_pathmtu	2220	(params.spp_pathmtu
2221	&& params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))	2221	&& params.spp_pathmtu < SCTP_DEFAULT_MINSEGMENT))
2222	return -EINVAL;	2222	return -EINVAL;
2223		2223
2224	/* If an address other than INADDR_ANY is specified, and	2224	/* If an address other than INADDR_ANY is specified, and
2225	* no transport is found, then the request is invalid.	2225	* no transport is found, then the request is invalid.
2226	*/	2226	*/
2227	if (!sctp_is_any(( union sctp_addr *)&params.spp_address)) {	2227	if (!sctp_is_any(( union sctp_addr *)&params.spp_address)) {
2228	trans = sctp_addr_id2transport(sk, &params.spp_address,	2228	trans = sctp_addr_id2transport(sk, &params.spp_address,
2229	params.spp_assoc_id);	2229	params.spp_assoc_id);
2230	if (!trans)	2230	if (!trans)
2231	return -EINVAL;	2231	return -EINVAL;
2232	}	2232	}
2233		2233
2234	/* Get association, if assoc_id != 0 and the socket is a one	2234	/* Get association, if assoc_id != 0 and the socket is a one
2235	* to many style socket, and an association was not found, then	2235	* to many style socket, and an association was not found, then
2236	* the id was invalid.	2236	* the id was invalid.
2237	*/	2237	*/
2238	asoc = sctp_id2assoc(sk, params.spp_assoc_id);	2238	asoc = sctp_id2assoc(sk, params.spp_assoc_id);
2239	if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))	2239	if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP))
2240	return -EINVAL;	2240	return -EINVAL;
2241		2241
2242	/* Heartbeat demand can only be sent on a transport or	2242	/* Heartbeat demand can only be sent on a transport or
2243	* association, but not a socket.	2243	* association, but not a socket.
2244	*/	2244	*/
2245	if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)	2245	if (params.spp_flags & SPP_HB_DEMAND && !trans && !asoc)
2246	return -EINVAL;	2246	return -EINVAL;
2247		2247
2248	/* Process parameters. */	2248	/* Process parameters. */
2249	error = sctp_apply_peer_addr_params(&params, trans, asoc, sp,	2249	error = sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2250	hb_change, pmtud_change,	2250	hb_change, pmtud_change,
2251	sackdelay_change);	2251	sackdelay_change);
2252		2252
2253	if (error)	2253	if (error)
2254	return error;	2254	return error;
2255		2255
2256	/* If changes are for association, also apply parameters to each	2256	/* If changes are for association, also apply parameters to each
2257	* transport.	2257	* transport.
2258	*/	2258	*/
2259	if (!trans && asoc) {	2259	if (!trans && asoc) {
2260	struct list_head *pos;	2260	struct list_head *pos;
2261		2261
2262	list_for_each(pos, &asoc->peer.transport_addr_list) {	2262	list_for_each(pos, &asoc->peer.transport_addr_list) {
2263	trans = list_entry(pos, struct sctp_transport,	2263	trans = list_entry(pos, struct sctp_transport,
2264	transports);	2264	transports);
2265	sctp_apply_peer_addr_params(&params, trans, asoc, sp,	2265	sctp_apply_peer_addr_params(&params, trans, asoc, sp,
2266	hb_change, pmtud_change,	2266	hb_change, pmtud_change,
2267	sackdelay_change);	2267	sackdelay_change);
2268	}	2268	}
2269	}	2269	}
2270		2270
2271	return 0;	2271	return 0;
2272	}	2272	}
2273		2273
2274	/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)	2274	/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)
2275	*	2275	*
2276	* This options will get or set the delayed ack timer. The time is set	2276	* This options will get or set the delayed ack timer. The time is set
2277	* in milliseconds. If the assoc_id is 0, then this sets or gets the	2277	* in milliseconds. If the assoc_id is 0, then this sets or gets the
2278	* endpoints default delayed ack timer value. If the assoc_id field is	2278	* endpoints default delayed ack timer value. If the assoc_id field is
2279	* non-zero, then the set or get effects the specified association.	2279	* non-zero, then the set or get effects the specified association.
2280	*	2280	*
2281	* struct sctp_assoc_value {	2281	* struct sctp_assoc_value {
2282	* sctp_assoc_t assoc_id;	2282	* sctp_assoc_t assoc_id;
2283	* uint32_t assoc_value;	2283	* uint32_t assoc_value;
2284	* };	2284	* };
2285	*	2285	*
2286	* assoc_id - This parameter, indicates which association the	2286	* assoc_id - This parameter, indicates which association the
2287	* user is preforming an action upon. Note that if	2287	* user is preforming an action upon. Note that if
2288	* this field's value is zero then the endpoints	2288	* this field's value is zero then the endpoints
2289	* default value is changed (effecting future	2289	* default value is changed (effecting future
2290	* associations only).	2290	* associations only).
2291	*	2291	*
2292	* assoc_value - This parameter contains the number of milliseconds	2292	* assoc_value - This parameter contains the number of milliseconds
2293	* that the user is requesting the delayed ACK timer	2293	* that the user is requesting the delayed ACK timer
2294	* be set to. Note that this value is defined in	2294	* be set to. Note that this value is defined in
2295	* the standard to be between 200 and 500 milliseconds.	2295	* the standard to be between 200 and 500 milliseconds.
2296	*	2296	*
2297	* Note: a value of zero will leave the value alone,	2297	* Note: a value of zero will leave the value alone,
2298	* but disable SACK delay. A non-zero value will also	2298	* but disable SACK delay. A non-zero value will also
2299	* enable SACK delay.	2299	* enable SACK delay.
2300	*/	2300	*/
2301		2301
2302	static int sctp_setsockopt_delayed_ack_time(struct sock *sk,	2302	static int sctp_setsockopt_delayed_ack_time(struct sock *sk,
2303	char __user *optval, int optlen)	2303	char __user *optval, int optlen)
2304	{	2304	{
2305	struct sctp_assoc_value params;	2305	struct sctp_assoc_value params;
2306	struct sctp_transport *trans = NULL;	2306	struct sctp_transport *trans = NULL;
2307	struct sctp_association *asoc = NULL;	2307	struct sctp_association *asoc = NULL;
2308	struct sctp_sock *sp = sctp_sk(sk);	2308	struct sctp_sock *sp = sctp_sk(sk);
2309		2309
2310	if (optlen != sizeof(struct sctp_assoc_value))	2310	if (optlen != sizeof(struct sctp_assoc_value))
2311	return - EINVAL;	2311	return - EINVAL;
2312		2312
2313	if (copy_from_user(&params, optval, optlen))	2313	if (copy_from_user(&params, optval, optlen))
2314	return -EFAULT;	2314	return -EFAULT;
2315		2315
2316	/* Validate value parameter. */	2316	/* Validate value parameter. */
2317	if (params.assoc_value > 500)	2317	if (params.assoc_value > 500)
2318	return -EINVAL;	2318	return -EINVAL;
2319		2319
2320	/* Get association, if assoc_id != 0 and the socket is a one	2320	/* Get association, if assoc_id != 0 and the socket is a one
2321	* to many style socket, and an association was not found, then	2321	* to many style socket, and an association was not found, then
2322	* the id was invalid.	2322	* the id was invalid.
2323	*/	2323	*/
2324	asoc = sctp_id2assoc(sk, params.assoc_id);	2324	asoc = sctp_id2assoc(sk, params.assoc_id);
2325	if (!asoc && params.assoc_id && sctp_style(sk, UDP))	2325	if (!asoc && params.assoc_id && sctp_style(sk, UDP))
2326	return -EINVAL;	2326	return -EINVAL;
2327		2327
2328	if (params.assoc_value) {	2328	if (params.assoc_value) {
2329	if (asoc) {	2329	if (asoc) {
2330	asoc->sackdelay =	2330	asoc->sackdelay =
2331	msecs_to_jiffies(params.assoc_value);	2331	msecs_to_jiffies(params.assoc_value);
2332	asoc->param_flags =	2332	asoc->param_flags =
2333	(asoc->param_flags & ~SPP_SACKDELAY) \|	2333	(asoc->param_flags & ~SPP_SACKDELAY) \|
2334	SPP_SACKDELAY_ENABLE;	2334	SPP_SACKDELAY_ENABLE;
2335	} else {	2335	} else {
2336	sp->sackdelay = params.assoc_value;	2336	sp->sackdelay = params.assoc_value;
2337	sp->param_flags =	2337	sp->param_flags =
2338	(sp->param_flags & ~SPP_SACKDELAY) \|	2338	(sp->param_flags & ~SPP_SACKDELAY) \|
2339	SPP_SACKDELAY_ENABLE;	2339	SPP_SACKDELAY_ENABLE;
2340	}	2340	}
2341	} else {	2341	} else {
2342	if (asoc) {	2342	if (asoc) {
2343	asoc->param_flags =	2343	asoc->param_flags =
2344	(asoc->param_flags & ~SPP_SACKDELAY) \|	2344	(asoc->param_flags & ~SPP_SACKDELAY) \|
2345	SPP_SACKDELAY_DISABLE;	2345	SPP_SACKDELAY_DISABLE;
2346	} else {	2346	} else {
2347	sp->param_flags =	2347	sp->param_flags =
2348	(sp->param_flags & ~SPP_SACKDELAY) \|	2348	(sp->param_flags & ~SPP_SACKDELAY) \|
2349	SPP_SACKDELAY_DISABLE;	2349	SPP_SACKDELAY_DISABLE;
2350	}	2350	}
2351	}	2351	}
2352		2352
2353	/* If change is for association, also apply to each transport. */	2353	/* If change is for association, also apply to each transport. */
2354	if (asoc) {	2354	if (asoc) {
2355	struct list_head *pos;	2355	struct list_head *pos;
2356		2356
2357	list_for_each(pos, &asoc->peer.transport_addr_list) {	2357	list_for_each(pos, &asoc->peer.transport_addr_list) {
2358	trans = list_entry(pos, struct sctp_transport,	2358	trans = list_entry(pos, struct sctp_transport,
2359	transports);	2359	transports);
2360	if (params.assoc_value) {	2360	if (params.assoc_value) {
2361	trans->sackdelay =	2361	trans->sackdelay =
2362	msecs_to_jiffies(params.assoc_value);	2362	msecs_to_jiffies(params.assoc_value);
2363	trans->param_flags =	2363	trans->param_flags =
2364	(trans->param_flags & ~SPP_SACKDELAY) \|	2364	(trans->param_flags & ~SPP_SACKDELAY) \|
2365	SPP_SACKDELAY_ENABLE;	2365	SPP_SACKDELAY_ENABLE;
2366	} else {	2366	} else {
2367	trans->param_flags =	2367	trans->param_flags =
2368	(trans->param_flags & ~SPP_SACKDELAY) \|	2368	(trans->param_flags & ~SPP_SACKDELAY) \|
2369	SPP_SACKDELAY_DISABLE;	2369	SPP_SACKDELAY_DISABLE;
2370	}	2370	}
2371	}	2371	}
2372	}	2372	}
2373		2373
2374	return 0;	2374	return 0;
2375	}	2375	}
2376		2376
2377	/* 7.1.3 Initialization Parameters (SCTP_INITMSG)	2377	/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
2378	*	2378	*
2379	* Applications can specify protocol parameters for the default association	2379	* Applications can specify protocol parameters for the default association
2380	* initialization. The option name argument to setsockopt() and getsockopt()	2380	* initialization. The option name argument to setsockopt() and getsockopt()
2381	* is SCTP_INITMSG.	2381	* is SCTP_INITMSG.
2382	*	2382	*
2383	* Setting initialization parameters is effective only on an unconnected	2383	* Setting initialization parameters is effective only on an unconnected
2384	* socket (for UDP-style sockets only future associations are effected	2384	* socket (for UDP-style sockets only future associations are effected
2385	* by the change). With TCP-style sockets, this option is inherited by	2385	* by the change). With TCP-style sockets, this option is inherited by
2386	* sockets derived from a listener socket.	2386	* sockets derived from a listener socket.
2387	*/	2387	*/
2388	static int sctp_setsockopt_initmsg(struct sock sk, char __user optval, int optlen)	2388	static int sctp_setsockopt_initmsg(struct sock sk, char __user optval, int optlen)
2389	{	2389	{
2390	struct sctp_initmsg sinit;	2390	struct sctp_initmsg sinit;
2391	struct sctp_sock *sp = sctp_sk(sk);	2391	struct sctp_sock *sp = sctp_sk(sk);
2392		2392
2393	if (optlen != sizeof(struct sctp_initmsg))	2393	if (optlen != sizeof(struct sctp_initmsg))
2394	return -EINVAL;	2394	return -EINVAL;
2395	if (copy_from_user(&sinit, optval, optlen))	2395	if (copy_from_user(&sinit, optval, optlen))
2396	return -EFAULT;	2396	return -EFAULT;
2397		2397
2398	if (sinit.sinit_num_ostreams)	2398	if (sinit.sinit_num_ostreams)
2399	sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;	2399	sp->initmsg.sinit_num_ostreams = sinit.sinit_num_ostreams;
2400	if (sinit.sinit_max_instreams)	2400	if (sinit.sinit_max_instreams)
2401	sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;	2401	sp->initmsg.sinit_max_instreams = sinit.sinit_max_instreams;
2402	if (sinit.sinit_max_attempts)	2402	if (sinit.sinit_max_attempts)
2403	sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;	2403	sp->initmsg.sinit_max_attempts = sinit.sinit_max_attempts;
2404	if (sinit.sinit_max_init_timeo)	2404	if (sinit.sinit_max_init_timeo)
2405	sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;	2405	sp->initmsg.sinit_max_init_timeo = sinit.sinit_max_init_timeo;
2406		2406
2407	return 0;	2407	return 0;
2408	}	2408	}
2409		2409
2410	/*	2410	/*
2411	* 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)	2411	* 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
2412	*	2412	*
2413	* Applications that wish to use the sendto() system call may wish to	2413	* Applications that wish to use the sendto() system call may wish to
2414	* specify a default set of parameters that would normally be supplied	2414	* specify a default set of parameters that would normally be supplied
2415	* through the inclusion of ancillary data. This socket option allows	2415	* through the inclusion of ancillary data. This socket option allows
2416	* such an application to set the default sctp_sndrcvinfo structure.	2416	* such an application to set the default sctp_sndrcvinfo structure.
2417	* The application that wishes to use this socket option simply passes	2417	* The application that wishes to use this socket option simply passes
2418	* in to this call the sctp_sndrcvinfo structure defined in Section	2418	* in to this call the sctp_sndrcvinfo structure defined in Section
2419	* 5.2.2) The input parameters accepted by this call include	2419	* 5.2.2) The input parameters accepted by this call include
2420	* sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,	2420	* sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
2421	* sinfo_timetolive. The user must provide the sinfo_assoc_id field in	2421	* sinfo_timetolive. The user must provide the sinfo_assoc_id field in
2422	* to this call if the caller is using the UDP model.	2422	* to this call if the caller is using the UDP model.
2423	*/	2423	*/
2424	static int sctp_setsockopt_default_send_param(struct sock *sk,	2424	static int sctp_setsockopt_default_send_param(struct sock *sk,
2425	char __user *optval, int optlen)	2425	char __user *optval, int optlen)
2426	{	2426	{
2427	struct sctp_sndrcvinfo info;	2427	struct sctp_sndrcvinfo info;
2428	struct sctp_association *asoc;	2428	struct sctp_association *asoc;
2429	struct sctp_sock *sp = sctp_sk(sk);	2429	struct sctp_sock *sp = sctp_sk(sk);
2430		2430
2431	if (optlen != sizeof(struct sctp_sndrcvinfo))	2431	if (optlen != sizeof(struct sctp_sndrcvinfo))
2432	return -EINVAL;	2432	return -EINVAL;
2433	if (copy_from_user(&info, optval, optlen))	2433	if (copy_from_user(&info, optval, optlen))
2434	return -EFAULT;	2434	return -EFAULT;
2435		2435
2436	asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);	2436	asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
2437	if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))	2437	if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
2438	return -EINVAL;	2438	return -EINVAL;
2439		2439
2440	if (asoc) {	2440	if (asoc) {
2441	asoc->default_stream = info.sinfo_stream;	2441	asoc->default_stream = info.sinfo_stream;
2442	asoc->default_flags = info.sinfo_flags;	2442	asoc->default_flags = info.sinfo_flags;
2443	asoc->default_ppid = info.sinfo_ppid;	2443	asoc->default_ppid = info.sinfo_ppid;
2444	asoc->default_context = info.sinfo_context;	2444	asoc->default_context = info.sinfo_context;
2445	asoc->default_timetolive = info.sinfo_timetolive;	2445	asoc->default_timetolive = info.sinfo_timetolive;
2446	} else {	2446	} else {
2447	sp->default_stream = info.sinfo_stream;	2447	sp->default_stream = info.sinfo_stream;
2448	sp->default_flags = info.sinfo_flags;	2448	sp->default_flags = info.sinfo_flags;
2449	sp->default_ppid = info.sinfo_ppid;	2449	sp->default_ppid = info.sinfo_ppid;
2450	sp->default_context = info.sinfo_context;	2450	sp->default_context = info.sinfo_context;
2451	sp->default_timetolive = info.sinfo_timetolive;	2451	sp->default_timetolive = info.sinfo_timetolive;
2452	}	2452	}
2453		2453
2454	return 0;	2454	return 0;
2455	}	2455	}
2456		2456
2457	/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)	2457	/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
2458	*	2458	*
2459	* Requests that the local SCTP stack use the enclosed peer address as	2459	* Requests that the local SCTP stack use the enclosed peer address as
2460	* the association primary. The enclosed address must be one of the	2460	* the association primary. The enclosed address must be one of the
2461	* association peer's addresses.	2461	* association peer's addresses.
2462	*/	2462	*/
2463	static int sctp_setsockopt_primary_addr(struct sock sk, char __user optval,	2463	static int sctp_setsockopt_primary_addr(struct sock sk, char __user optval,
2464	int optlen)	2464	int optlen)
2465	{	2465	{
2466	struct sctp_prim prim;	2466	struct sctp_prim prim;
2467	struct sctp_transport *trans;	2467	struct sctp_transport *trans;
2468		2468
2469	if (optlen != sizeof(struct sctp_prim))	2469	if (optlen != sizeof(struct sctp_prim))
2470	return -EINVAL;	2470	return -EINVAL;
2471		2471
2472	if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))	2472	if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
2473	return -EFAULT;	2473	return -EFAULT;
2474		2474
2475	trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);	2475	trans = sctp_addr_id2transport(sk, &prim.ssp_addr, prim.ssp_assoc_id);
2476	if (!trans)	2476	if (!trans)
2477	return -EINVAL;	2477	return -EINVAL;
2478		2478
2479	sctp_assoc_set_primary(trans->asoc, trans);	2479	sctp_assoc_set_primary(trans->asoc, trans);
2480		2480
2481	return 0;	2481	return 0;
2482	}	2482	}
2483		2483
2484	/*	2484	/*
2485	* 7.1.5 SCTP_NODELAY	2485	* 7.1.5 SCTP_NODELAY
2486	*	2486	*
2487	* Turn on/off any Nagle-like algorithm. This means that packets are	2487	* Turn on/off any Nagle-like algorithm. This means that packets are
2488	* generally sent as soon as possible and no unnecessary delays are	2488	* generally sent as soon as possible and no unnecessary delays are
2489	* introduced, at the cost of more packets in the network. Expects an	2489	* introduced, at the cost of more packets in the network. Expects an
2490	* integer boolean flag.	2490	* integer boolean flag.
2491	*/	2491	*/
2492	static int sctp_setsockopt_nodelay(struct sock sk, char __user optval,	2492	static int sctp_setsockopt_nodelay(struct sock sk, char __user optval,
2493	int optlen)	2493	int optlen)
2494	{	2494	{
2495	int val;	2495	int val;
2496		2496
2497	if (optlen < sizeof(int))	2497	if (optlen < sizeof(int))
2498	return -EINVAL;	2498	return -EINVAL;
2499	if (get_user(val, (int __user *)optval))	2499	if (get_user(val, (int __user *)optval))
2500	return -EFAULT;	2500	return -EFAULT;
2501		2501
2502	sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;	2502	sctp_sk(sk)->nodelay = (val == 0) ? 0 : 1;
2503	return 0;	2503	return 0;
2504	}	2504	}
2505		2505
2506	/*	2506	/*
2507	*	2507	*
2508	* 7.1.1 SCTP_RTOINFO	2508	* 7.1.1 SCTP_RTOINFO
2509	*	2509	*
2510	* The protocol parameters used to initialize and bound retransmission	2510	* The protocol parameters used to initialize and bound retransmission
2511	* timeout (RTO) are tunable. sctp_rtoinfo structure is used to access	2511	* timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
2512	* and modify these parameters.	2512	* and modify these parameters.
2513	* All parameters are time values, in milliseconds. A value of 0, when	2513	* All parameters are time values, in milliseconds. A value of 0, when
2514	* modifying the parameters, indicates that the current value should not	2514	* modifying the parameters, indicates that the current value should not
2515	* be changed.	2515	* be changed.
2516	*	2516	*
2517	*/	2517	*/
2518	static int sctp_setsockopt_rtoinfo(struct sock sk, char __user optval, int optlen) {	2518	static int sctp_setsockopt_rtoinfo(struct sock sk, char __user optval, int optlen) {
2519	struct sctp_rtoinfo rtoinfo;	2519	struct sctp_rtoinfo rtoinfo;
2520	struct sctp_association *asoc;	2520	struct sctp_association *asoc;
2521		2521
2522	if (optlen != sizeof (struct sctp_rtoinfo))	2522	if (optlen != sizeof (struct sctp_rtoinfo))
2523	return -EINVAL;	2523	return -EINVAL;
2524		2524
2525	if (copy_from_user(&rtoinfo, optval, optlen))	2525	if (copy_from_user(&rtoinfo, optval, optlen))
2526	return -EFAULT;	2526	return -EFAULT;
2527		2527
2528	asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);	2528	asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
2529		2529
2530	/* Set the values to the specific association */	2530	/* Set the values to the specific association */
2531	if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))	2531	if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
2532	return -EINVAL;	2532	return -EINVAL;
2533		2533
2534	if (asoc) {	2534	if (asoc) {
2535	if (rtoinfo.srto_initial != 0)	2535	if (rtoinfo.srto_initial != 0)
2536	asoc->rto_initial =	2536	asoc->rto_initial =
2537	msecs_to_jiffies(rtoinfo.srto_initial);	2537	msecs_to_jiffies(rtoinfo.srto_initial);
2538	if (rtoinfo.srto_max != 0)	2538	if (rtoinfo.srto_max != 0)
2539	asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max);	2539	asoc->rto_max = msecs_to_jiffies(rtoinfo.srto_max);
2540	if (rtoinfo.srto_min != 0)	2540	if (rtoinfo.srto_min != 0)
2541	asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min);	2541	asoc->rto_min = msecs_to_jiffies(rtoinfo.srto_min);
2542	} else {	2542	} else {
2543	/* If there is no association or the association-id = 0	2543	/* If there is no association or the association-id = 0
2544	* set the values to the endpoint.	2544	* set the values to the endpoint.
2545	*/	2545	*/
2546	struct sctp_sock *sp = sctp_sk(sk);	2546	struct sctp_sock *sp = sctp_sk(sk);
2547		2547
2548	if (rtoinfo.srto_initial != 0)	2548	if (rtoinfo.srto_initial != 0)
2549	sp->rtoinfo.srto_initial = rtoinfo.srto_initial;	2549	sp->rtoinfo.srto_initial = rtoinfo.srto_initial;
2550	if (rtoinfo.srto_max != 0)	2550	if (rtoinfo.srto_max != 0)
2551	sp->rtoinfo.srto_max = rtoinfo.srto_max;	2551	sp->rtoinfo.srto_max = rtoinfo.srto_max;
2552	if (rtoinfo.srto_min != 0)	2552	if (rtoinfo.srto_min != 0)
2553	sp->rtoinfo.srto_min = rtoinfo.srto_min;	2553	sp->rtoinfo.srto_min = rtoinfo.srto_min;
2554	}	2554	}
2555		2555
2556	return 0;	2556	return 0;
2557	}	2557	}
2558		2558
2559	/*	2559	/*
2560	*	2560	*
2561	* 7.1.2 SCTP_ASSOCINFO	2561	* 7.1.2 SCTP_ASSOCINFO
2562	*	2562	*
2563	* This option is used to tune the the maximum retransmission attempts	2563	* This option is used to tune the the maximum retransmission attempts
2564	* of the association.	2564	* of the association.
2565	* Returns an error if the new association retransmission value is	2565	* Returns an error if the new association retransmission value is
2566	* greater than the sum of the retransmission value of the peer.	2566	* greater than the sum of the retransmission value of the peer.
2567	* See [SCTP] for more information.	2567	* See [SCTP] for more information.
2568	*	2568	*
2569	*/	2569	*/
2570	static int sctp_setsockopt_associnfo(struct sock sk, char __user optval, int optlen)	2570	static int sctp_setsockopt_associnfo(struct sock sk, char __user optval, int optlen)
2571	{	2571	{
2572		2572
2573	struct sctp_assocparams assocparams;	2573	struct sctp_assocparams assocparams;
2574	struct sctp_association *asoc;	2574	struct sctp_association *asoc;
2575		2575
2576	if (optlen != sizeof(struct sctp_assocparams))	2576	if (optlen != sizeof(struct sctp_assocparams))
2577	return -EINVAL;	2577	return -EINVAL;
2578	if (copy_from_user(&assocparams, optval, optlen))	2578	if (copy_from_user(&assocparams, optval, optlen))
2579	return -EFAULT;	2579	return -EFAULT;
2580		2580
2581	asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);	2581	asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
2582		2582
2583	if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))	2583	if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
2584	return -EINVAL;	2584	return -EINVAL;
2585		2585
2586	/* Set the values to the specific association */	2586	/* Set the values to the specific association */
2587	if (asoc) {	2587	if (asoc) {
2588	if (assocparams.sasoc_asocmaxrxt != 0) {	2588	if (assocparams.sasoc_asocmaxrxt != 0) {
2589	__u32 path_sum = 0;	2589	__u32 path_sum = 0;
2590	int paths = 0;	2590	int paths = 0;
2591	struct list_head *pos;	2591	struct list_head *pos;
2592	struct sctp_transport *peer_addr;	2592	struct sctp_transport *peer_addr;
2593		2593
2594	list_for_each(pos, &asoc->peer.transport_addr_list) {	2594	list_for_each(pos, &asoc->peer.transport_addr_list) {
2595	peer_addr = list_entry(pos,	2595	peer_addr = list_entry(pos,
2596	struct sctp_transport,	2596	struct sctp_transport,
2597	transports);	2597	transports);
2598	path_sum += peer_addr->pathmaxrxt;	2598	path_sum += peer_addr->pathmaxrxt;
2599	paths++;	2599	paths++;
2600	}	2600	}
2601		2601
2602	/* Only validate asocmaxrxt if we have more then	2602	/* Only validate asocmaxrxt if we have more then
2603	* one path/transport. We do this because path	2603	* one path/transport. We do this because path
2604	* retransmissions are only counted when we have more	2604	* retransmissions are only counted when we have more
2605	* then one path.	2605	* then one path.
2606	*/	2606	*/
2607	if (paths > 1 &&	2607	if (paths > 1 &&
2608	assocparams.sasoc_asocmaxrxt > path_sum)	2608	assocparams.sasoc_asocmaxrxt > path_sum)
2609	return -EINVAL;	2609	return -EINVAL;
2610		2610
2611	asoc->max_retrans = assocparams.sasoc_asocmaxrxt;	2611	asoc->max_retrans = assocparams.sasoc_asocmaxrxt;
2612	}	2612	}
2613		2613
2614	if (assocparams.sasoc_cookie_life != 0) {	2614	if (assocparams.sasoc_cookie_life != 0) {
2615	asoc->cookie_life.tv_sec =	2615	asoc->cookie_life.tv_sec =
2616	assocparams.sasoc_cookie_life / 1000;	2616	assocparams.sasoc_cookie_life / 1000;
2617	asoc->cookie_life.tv_usec =	2617	asoc->cookie_life.tv_usec =
2618	(assocparams.sasoc_cookie_life % 1000)	2618	(assocparams.sasoc_cookie_life % 1000)
2619	* 1000;	2619	* 1000;
2620	}	2620	}
2621	} else {	2621	} else {
2622	/* Set the values to the endpoint */	2622	/* Set the values to the endpoint */
2623	struct sctp_sock *sp = sctp_sk(sk);	2623	struct sctp_sock *sp = sctp_sk(sk);
2624		2624
2625	if (assocparams.sasoc_asocmaxrxt != 0)	2625	if (assocparams.sasoc_asocmaxrxt != 0)
2626	sp->assocparams.sasoc_asocmaxrxt =	2626	sp->assocparams.sasoc_asocmaxrxt =
2627	assocparams.sasoc_asocmaxrxt;	2627	assocparams.sasoc_asocmaxrxt;
2628	if (assocparams.sasoc_cookie_life != 0)	2628	if (assocparams.sasoc_cookie_life != 0)
2629	sp->assocparams.sasoc_cookie_life =	2629	sp->assocparams.sasoc_cookie_life =
2630	assocparams.sasoc_cookie_life;	2630	assocparams.sasoc_cookie_life;
2631	}	2631	}
2632	return 0;	2632	return 0;
2633	}	2633	}
2634		2634
2635	/*	2635	/*
2636	* 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)	2636	* 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
2637	*	2637	*
2638	* This socket option is a boolean flag which turns on or off mapped V4	2638	* This socket option is a boolean flag which turns on or off mapped V4
2639	* addresses. If this option is turned on and the socket is type	2639	* addresses. If this option is turned on and the socket is type
2640	* PF_INET6, then IPv4 addresses will be mapped to V6 representation.	2640	* PF_INET6, then IPv4 addresses will be mapped to V6 representation.
2641	* If this option is turned off, then no mapping will be done of V4	2641	* If this option is turned off, then no mapping will be done of V4
2642	* addresses and a user will receive both PF_INET6 and PF_INET type	2642	* addresses and a user will receive both PF_INET6 and PF_INET type
2643	* addresses on the socket.	2643	* addresses on the socket.
2644	*/	2644	*/
2645	static int sctp_setsockopt_mappedv4(struct sock sk, char __user optval, int optlen)	2645	static int sctp_setsockopt_mappedv4(struct sock sk, char __user optval, int optlen)
2646	{	2646	{
2647	int val;	2647	int val;
2648	struct sctp_sock *sp = sctp_sk(sk);	2648	struct sctp_sock *sp = sctp_sk(sk);
2649		2649
2650	if (optlen < sizeof(int))	2650	if (optlen < sizeof(int))
2651	return -EINVAL;	2651	return -EINVAL;
2652	if (get_user(val, (int __user *)optval))	2652	if (get_user(val, (int __user *)optval))
2653	return -EFAULT;	2653	return -EFAULT;
2654	if (val)	2654	if (val)
2655	sp->v4mapped = 1;	2655	sp->v4mapped = 1;
2656	else	2656	else
2657	sp->v4mapped = 0;	2657	sp->v4mapped = 0;
2658		2658
2659	return 0;	2659	return 0;
2660	}	2660	}
2661		2661
2662	/*	2662	/*
2663	* 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)	2663	* 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
2664	*	2664	*
2665	* This socket option specifies the maximum size to put in any outgoing	2665	* This socket option specifies the maximum size to put in any outgoing
2666	* SCTP chunk. If a message is larger than this size it will be	2666	* SCTP chunk. If a message is larger than this size it will be
2667	* fragmented by SCTP into the specified size. Note that the underlying	2667	* fragmented by SCTP into the specified size. Note that the underlying
2668	* SCTP implementation may fragment into smaller sized chunks when the	2668	* SCTP implementation may fragment into smaller sized chunks when the
2669	* PMTU of the underlying association is smaller than the value set by	2669	* PMTU of the underlying association is smaller than the value set by
2670	* the user.	2670	* the user.
2671	*/	2671	*/
2672	static int sctp_setsockopt_maxseg(struct sock sk, char __user optval, int optlen)	2672	static int sctp_setsockopt_maxseg(struct sock sk, char __user optval, int optlen)
2673	{	2673	{
2674	struct sctp_association *asoc;	2674	struct sctp_association *asoc;
2675	struct list_head *pos;	2675	struct list_head *pos;
2676	struct sctp_sock *sp = sctp_sk(sk);	2676	struct sctp_sock *sp = sctp_sk(sk);
2677	int val;	2677	int val;
2678		2678
2679	if (optlen < sizeof(int))	2679	if (optlen < sizeof(int))
2680	return -EINVAL;	2680	return -EINVAL;
2681	if (get_user(val, (int __user *)optval))	2681	if (get_user(val, (int __user *)optval))
2682	return -EFAULT;	2682	return -EFAULT;
2683	if ((val != 0) && ((val < 8) \|\| (val > SCTP_MAX_CHUNK_LEN)))	2683	if ((val != 0) && ((val < 8) \|\| (val > SCTP_MAX_CHUNK_LEN)))
2684	return -EINVAL;	2684	return -EINVAL;
2685	sp->user_frag = val;	2685	sp->user_frag = val;
2686		2686
2687	/* Update the frag_point of the existing associations. */	2687	/* Update the frag_point of the existing associations. */
2688	list_for_each(pos, &(sp->ep->asocs)) {	2688	list_for_each(pos, &(sp->ep->asocs)) {
2689	asoc = list_entry(pos, struct sctp_association, asocs);	2689	asoc = list_entry(pos, struct sctp_association, asocs);
2690	asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu);	2690	asoc->frag_point = sctp_frag_point(sp, asoc->pathmtu);
2691	}	2691	}
2692		2692
2693	return 0;	2693	return 0;
2694	}	2694	}
2695		2695
2696		2696
2697	/*	2697	/*
2698	* 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)	2698	* 7.1.9 Set Peer Primary Address (SCTP_SET_PEER_PRIMARY_ADDR)
2699	*	2699	*
2700	* Requests that the peer mark the enclosed address as the association	2700	* Requests that the peer mark the enclosed address as the association
2701	* primary. The enclosed address must be one of the association's	2701	* primary. The enclosed address must be one of the association's
2702	* locally bound addresses. The following structure is used to make a	2702	* locally bound addresses. The following structure is used to make a
2703	* set primary request:	2703	* set primary request:
2704	*/	2704	*/
2705	static int sctp_setsockopt_peer_primary_addr(struct sock sk, char __user optval,	2705	static int sctp_setsockopt_peer_primary_addr(struct sock sk, char __user optval,
2706	int optlen)	2706	int optlen)
2707	{	2707	{
2708	struct sctp_sock *sp;	2708	struct sctp_sock *sp;
2709	struct sctp_endpoint *ep;	2709	struct sctp_endpoint *ep;
2710	struct sctp_association *asoc = NULL;	2710	struct sctp_association *asoc = NULL;
2711	struct sctp_setpeerprim prim;	2711	struct sctp_setpeerprim prim;
2712	struct sctp_chunk *chunk;	2712	struct sctp_chunk *chunk;
2713	int err;	2713	int err;
2714		2714
2715	sp = sctp_sk(sk);	2715	sp = sctp_sk(sk);
2716	ep = sp->ep;	2716	ep = sp->ep;
2717		2717
2718	if (!sctp_addip_enable)	2718	if (!sctp_addip_enable)
2719	return -EPERM;	2719	return -EPERM;
2720		2720
2721	if (optlen != sizeof(struct sctp_setpeerprim))	2721	if (optlen != sizeof(struct sctp_setpeerprim))
2722	return -EINVAL;	2722	return -EINVAL;
2723		2723
2724	if (copy_from_user(&prim, optval, optlen))	2724	if (copy_from_user(&prim, optval, optlen))
2725	return -EFAULT;	2725	return -EFAULT;
2726		2726
2727	asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);	2727	asoc = sctp_id2assoc(sk, prim.sspp_assoc_id);
2728	if (!asoc)	2728	if (!asoc)
2729	return -EINVAL;	2729	return -EINVAL;
2730		2730
2731	if (!asoc->peer.asconf_capable)	2731	if (!asoc->peer.asconf_capable)
2732	return -EPERM;	2732	return -EPERM;
2733		2733
2734	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)	2734	if (asoc->peer.addip_disabled_mask & SCTP_PARAM_SET_PRIMARY)
2735	return -EPERM;	2735	return -EPERM;
2736		2736
2737	if (!sctp_state(asoc, ESTABLISHED))	2737	if (!sctp_state(asoc, ESTABLISHED))
2738	return -ENOTCONN;	2738	return -ENOTCONN;
2739		2739
2740	if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))	2740	if (!sctp_assoc_lookup_laddr(asoc, (union sctp_addr *)&prim.sspp_addr))
2741	return -EADDRNOTAVAIL;	2741	return -EADDRNOTAVAIL;
2742		2742
2743	/* Create an ASCONF chunk with SET_PRIMARY parameter */	2743	/* Create an ASCONF chunk with SET_PRIMARY parameter */
2744	chunk = sctp_make_asconf_set_prim(asoc,	2744	chunk = sctp_make_asconf_set_prim(asoc,
2745	(union sctp_addr *)&prim.sspp_addr);	2745	(union sctp_addr *)&prim.sspp_addr);
2746	if (!chunk)	2746	if (!chunk)
2747	return -ENOMEM;	2747	return -ENOMEM;
2748		2748
2749	err = sctp_send_asconf(asoc, chunk);	2749	err = sctp_send_asconf(asoc, chunk);
2750		2750
2751	SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n");	2751	SCTP_DEBUG_PRINTK("We set peer primary addr primitively.\n");
2752		2752
2753	return err;	2753	return err;
2754	}	2754	}
2755		2755
2756	static int sctp_setsockopt_adaption_layer(struct sock sk, char __user optval,	2756	static int sctp_setsockopt_adaption_layer(struct sock sk, char __user optval,
2757	int optlen)	2757	int optlen)
2758	{	2758	{
2759	struct sctp_setadaption adaption;	2759	struct sctp_setadaption adaption;
2760		2760
2761	if (optlen != sizeof(struct sctp_setadaption))	2761	if (optlen != sizeof(struct sctp_setadaption))
2762	return -EINVAL;	2762	return -EINVAL;
2763	if (copy_from_user(&adaption, optval, optlen))	2763	if (copy_from_user(&adaption, optval, optlen))
2764	return -EFAULT;	2764	return -EFAULT;
2765		2765
2766	sctp_sk(sk)->adaption_ind = adaption.ssb_adaption_ind;	2766	sctp_sk(sk)->adaption_ind = adaption.ssb_adaption_ind;
2767		2767
2768	return 0;	2768	return 0;
2769	}	2769	}
2770		2770
2771	/* API 6.2 setsockopt(), getsockopt()	2771	/* API 6.2 setsockopt(), getsockopt()
2772	*	2772	*
2773	* Applications use setsockopt() and getsockopt() to set or retrieve	2773	* Applications use setsockopt() and getsockopt() to set or retrieve
2774	* socket options. Socket options are used to change the default	2774	* socket options. Socket options are used to change the default
2775	* behavior of sockets calls. They are described in Section 7.	2775	* behavior of sockets calls. They are described in Section 7.
2776	*	2776	*
2777	* The syntax is:	2777	* The syntax is:
2778	*	2778	*
2779	* ret = getsockopt(int sd, int level, int optname, void __user *optval,	2779	* ret = getsockopt(int sd, int level, int optname, void __user *optval,
2780	* int __user *optlen);	2780	* int __user *optlen);
2781	* ret = setsockopt(int sd, int level, int optname, const void __user *optval,	2781	* ret = setsockopt(int sd, int level, int optname, const void __user *optval,
2782	* int optlen);	2782	* int optlen);
2783	*	2783	*
2784	* sd - the socket descript.	2784	* sd - the socket descript.
2785	* level - set to IPPROTO_SCTP for all SCTP options.	2785	* level - set to IPPROTO_SCTP for all SCTP options.
2786	* optname - the option name.	2786	* optname - the option name.
2787	* optval - the buffer to store the value of the option.	2787	* optval - the buffer to store the value of the option.
2788	* optlen - the size of the buffer.	2788	* optlen - the size of the buffer.
2789	*/	2789	*/
2790	SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,	2790	SCTP_STATIC int sctp_setsockopt(struct sock *sk, int level, int optname,
2791	char __user *optval, int optlen)	2791	char __user *optval, int optlen)
2792	{	2792	{
2793	int retval = 0;	2793	int retval = 0;
2794		2794
2795	SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n",	2795	SCTP_DEBUG_PRINTK("sctp_setsockopt(sk: %p... optname: %d)\n",
2796	sk, optname);	2796	sk, optname);
2797		2797
2798	/* I can hardly begin to describe how wrong this is. This is	2798	/* I can hardly begin to describe how wrong this is. This is
2799	* so broken as to be worse than useless. The API draft	2799	* so broken as to be worse than useless. The API draft
2800	* REALLY is NOT helpful here... I am not convinced that the	2800	* REALLY is NOT helpful here... I am not convinced that the
2801	* semantics of setsockopt() with a level OTHER THAN SOL_SCTP	2801	* semantics of setsockopt() with a level OTHER THAN SOL_SCTP
2802	* are at all well-founded.	2802	* are at all well-founded.
2803	*/	2803	*/
2804	if (level != SOL_SCTP) {	2804	if (level != SOL_SCTP) {
2805	struct sctp_af *af = sctp_sk(sk)->pf->af;	2805	struct sctp_af *af = sctp_sk(sk)->pf->af;
2806	retval = af->setsockopt(sk, level, optname, optval, optlen);	2806	retval = af->setsockopt(sk, level, optname, optval, optlen);
2807	goto out_nounlock;	2807	goto out_nounlock;
2808	}	2808	}
2809		2809
2810	sctp_lock_sock(sk);	2810	sctp_lock_sock(sk);
2811		2811
2812	switch (optname) {	2812	switch (optname) {
2813	case SCTP_SOCKOPT_BINDX_ADD:	2813	case SCTP_SOCKOPT_BINDX_ADD:
2814	/* 'optlen' is the size of the addresses buffer. */	2814	/* 'optlen' is the size of the addresses buffer. */
2815	retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,	2815	retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
2816	optlen, SCTP_BINDX_ADD_ADDR);	2816	optlen, SCTP_BINDX_ADD_ADDR);
2817	break;	2817	break;
2818		2818
2819	case SCTP_SOCKOPT_BINDX_REM:	2819	case SCTP_SOCKOPT_BINDX_REM:
2820	/* 'optlen' is the size of the addresses buffer. */	2820	/* 'optlen' is the size of the addresses buffer. */
2821	retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,	2821	retval = sctp_setsockopt_bindx(sk, (struct sockaddr __user *)optval,
2822	optlen, SCTP_BINDX_REM_ADDR);	2822	optlen, SCTP_BINDX_REM_ADDR);
2823	break;	2823	break;
2824		2824
2825	case SCTP_SOCKOPT_CONNECTX:	2825	case SCTP_SOCKOPT_CONNECTX:
2826	/* 'optlen' is the size of the addresses buffer. */	2826	/* 'optlen' is the size of the addresses buffer. */
2827	retval = sctp_setsockopt_connectx(sk, (struct sockaddr __user *)optval,	2827	retval = sctp_setsockopt_connectx(sk, (struct sockaddr __user *)optval,
2828	optlen);	2828	optlen);
2829	break;	2829	break;
2830		2830
2831	case SCTP_DISABLE_FRAGMENTS:	2831	case SCTP_DISABLE_FRAGMENTS:
2832	retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);	2832	retval = sctp_setsockopt_disable_fragments(sk, optval, optlen);
2833	break;	2833	break;
2834		2834
2835	case SCTP_EVENTS:	2835	case SCTP_EVENTS:
2836	retval = sctp_setsockopt_events(sk, optval, optlen);	2836	retval = sctp_setsockopt_events(sk, optval, optlen);
2837	break;	2837	break;
2838		2838
2839	case SCTP_AUTOCLOSE:	2839	case SCTP_AUTOCLOSE:
2840	retval = sctp_setsockopt_autoclose(sk, optval, optlen);	2840	retval = sctp_setsockopt_autoclose(sk, optval, optlen);
2841	break;	2841	break;
2842		2842
2843	case SCTP_PEER_ADDR_PARAMS:	2843	case SCTP_PEER_ADDR_PARAMS:
2844	retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);	2844	retval = sctp_setsockopt_peer_addr_params(sk, optval, optlen);
2845	break;	2845	break;
2846		2846
2847	case SCTP_DELAYED_ACK_TIME:	2847	case SCTP_DELAYED_ACK_TIME:
2848	retval = sctp_setsockopt_delayed_ack_time(sk, optval, optlen);	2848	retval = sctp_setsockopt_delayed_ack_time(sk, optval, optlen);
2849	break;	2849	break;
2850		2850
2851	case SCTP_INITMSG:	2851	case SCTP_INITMSG:
2852	retval = sctp_setsockopt_initmsg(sk, optval, optlen);	2852	retval = sctp_setsockopt_initmsg(sk, optval, optlen);
2853	break;	2853	break;
2854	case SCTP_DEFAULT_SEND_PARAM:	2854	case SCTP_DEFAULT_SEND_PARAM:
2855	retval = sctp_setsockopt_default_send_param(sk, optval,	2855	retval = sctp_setsockopt_default_send_param(sk, optval,
2856	optlen);	2856	optlen);
2857	break;	2857	break;
2858	case SCTP_PRIMARY_ADDR:	2858	case SCTP_PRIMARY_ADDR:
2859	retval = sctp_setsockopt_primary_addr(sk, optval, optlen);	2859	retval = sctp_setsockopt_primary_addr(sk, optval, optlen);
2860	break;	2860	break;
2861	case SCTP_SET_PEER_PRIMARY_ADDR:	2861	case SCTP_SET_PEER_PRIMARY_ADDR:
2862	retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);	2862	retval = sctp_setsockopt_peer_primary_addr(sk, optval, optlen);
2863	break;	2863	break;
2864	case SCTP_NODELAY:	2864	case SCTP_NODELAY:
2865	retval = sctp_setsockopt_nodelay(sk, optval, optlen);	2865	retval = sctp_setsockopt_nodelay(sk, optval, optlen);
2866	break;	2866	break;
2867	case SCTP_RTOINFO:	2867	case SCTP_RTOINFO:
2868	retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);	2868	retval = sctp_setsockopt_rtoinfo(sk, optval, optlen);
2869	break;	2869	break;
2870	case SCTP_ASSOCINFO:	2870	case SCTP_ASSOCINFO:
2871	retval = sctp_setsockopt_associnfo(sk, optval, optlen);	2871	retval = sctp_setsockopt_associnfo(sk, optval, optlen);
2872	break;	2872	break;
2873	case SCTP_I_WANT_MAPPED_V4_ADDR:	2873	case SCTP_I_WANT_MAPPED_V4_ADDR:
2874	retval = sctp_setsockopt_mappedv4(sk, optval, optlen);	2874	retval = sctp_setsockopt_mappedv4(sk, optval, optlen);
2875	break;	2875	break;
2876	case SCTP_MAXSEG:	2876	case SCTP_MAXSEG:
2877	retval = sctp_setsockopt_maxseg(sk, optval, optlen);	2877	retval = sctp_setsockopt_maxseg(sk, optval, optlen);
2878	break;	2878	break;
2879	case SCTP_ADAPTION_LAYER:	2879	case SCTP_ADAPTION_LAYER:
2880	retval = sctp_setsockopt_adaption_layer(sk, optval, optlen);	2880	retval = sctp_setsockopt_adaption_layer(sk, optval, optlen);
2881	break;	2881	break;
2882		2882
2883	default:	2883	default:
2884	retval = -ENOPROTOOPT;	2884	retval = -ENOPROTOOPT;
2885	break;	2885	break;
2886	};	2886	};
2887		2887
2888	sctp_release_sock(sk);	2888	sctp_release_sock(sk);
2889		2889
2890	out_nounlock:	2890	out_nounlock:
2891	return retval;	2891	return retval;
2892	}	2892	}
2893		2893
2894	/* API 3.1.6 connect() - UDP Style Syntax	2894	/* API 3.1.6 connect() - UDP Style Syntax
2895	*	2895	*
2896	* An application may use the connect() call in the UDP model to initiate an	2896	* An application may use the connect() call in the UDP model to initiate an
2897	* association without sending data.	2897	* association without sending data.
2898	*	2898	*
2899	* The syntax is:	2899	* The syntax is:
2900	*	2900	*
2901	* ret = connect(int sd, const struct sockaddr *nam, socklen_t len);	2901	* ret = connect(int sd, const struct sockaddr *nam, socklen_t len);
2902	*	2902	*
2903	* sd: the socket descriptor to have a new association added to.	2903	* sd: the socket descriptor to have a new association added to.
2904	*	2904	*
2905	* nam: the address structure (either struct sockaddr_in or struct	2905	* nam: the address structure (either struct sockaddr_in or struct
2906	* sockaddr_in6 defined in RFC2553 [7]).	2906	* sockaddr_in6 defined in RFC2553 [7]).
2907	*	2907	*
2908	* len: the size of the address.	2908	* len: the size of the address.
2909	*/	2909	*/
2910	SCTP_STATIC int sctp_connect(struct sock sk, struct sockaddr addr,	2910	SCTP_STATIC int sctp_connect(struct sock sk, struct sockaddr addr,
2911	int addr_len)	2911	int addr_len)
2912	{	2912	{
2913	int err = 0;	2913	int err = 0;
2914	struct sctp_af *af;	2914	struct sctp_af *af;
2915		2915
2916	sctp_lock_sock(sk);	2916	sctp_lock_sock(sk);
2917		2917
2918	SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n",	2918	SCTP_DEBUG_PRINTK("%s - sk: %p, sockaddr: %p, addr_len: %d\n",
2919	__FUNCTION__, sk, addr, addr_len);	2919	__FUNCTION__, sk, addr, addr_len);
2920		2920
2921	/* Validate addr_len before calling common connect/connectx routine. */	2921	/* Validate addr_len before calling common connect/connectx routine. */
2922	af = sctp_get_af_specific(addr->sa_family);	2922	af = sctp_get_af_specific(addr->sa_family);
2923	if (!af \|\| addr_len < af->sockaddr_len) {	2923	if (!af \|\| addr_len < af->sockaddr_len) {
2924	err = -EINVAL;	2924	err = -EINVAL;
2925	} else {	2925	} else {
2926	/* Pass correct addr len to common routine (so it knows there	2926	/* Pass correct addr len to common routine (so it knows there
2927	* is only one address being passed.	2927	* is only one address being passed.
2928	*/	2928	*/
2929	err = __sctp_connect(sk, addr, af->sockaddr_len);	2929	err = __sctp_connect(sk, addr, af->sockaddr_len);
2930	}	2930	}
2931		2931
2932	sctp_release_sock(sk);	2932	sctp_release_sock(sk);
2933	return err;	2933	return err;
2934	}	2934	}
2935		2935
2936	/* FIXME: Write comments. */	2936	/* FIXME: Write comments. */
2937	SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags)	2937	SCTP_STATIC int sctp_disconnect(struct sock *sk, int flags)
2938	{	2938	{
2939	return -EOPNOTSUPP; /* STUB */	2939	return -EOPNOTSUPP; /* STUB */
2940	}	2940	}
2941		2941
2942	/* 4.1.4 accept() - TCP Style Syntax	2942	/* 4.1.4 accept() - TCP Style Syntax
2943	*	2943	*
2944	* Applications use accept() call to remove an established SCTP	2944	* Applications use accept() call to remove an established SCTP
2945	* association from the accept queue of the endpoint. A new socket	2945	* association from the accept queue of the endpoint. A new socket
2946	* descriptor will be returned from accept() to represent the newly	2946	* descriptor will be returned from accept() to represent the newly
2947	* formed association.	2947	* formed association.
2948	*/	2948	*/
2949	SCTP_STATIC struct sock sctp_accept(struct sock sk, int flags, int *err)	2949	SCTP_STATIC struct sock sctp_accept(struct sock sk, int flags, int *err)
2950	{	2950	{
2951	struct sctp_sock *sp;	2951	struct sctp_sock *sp;
2952	struct sctp_endpoint *ep;	2952	struct sctp_endpoint *ep;
2953	struct sock *newsk = NULL;	2953	struct sock *newsk = NULL;
2954	struct sctp_association *asoc;	2954	struct sctp_association *asoc;
2955	long timeo;	2955	long timeo;
2956	int error = 0;	2956	int error = 0;
2957		2957
2958	sctp_lock_sock(sk);	2958	sctp_lock_sock(sk);
2959		2959
2960	sp = sctp_sk(sk);	2960	sp = sctp_sk(sk);
2961	ep = sp->ep;	2961	ep = sp->ep;
2962		2962
2963	if (!sctp_style(sk, TCP)) {	2963	if (!sctp_style(sk, TCP)) {
2964	error = -EOPNOTSUPP;	2964	error = -EOPNOTSUPP;
2965	goto out;	2965	goto out;
2966	}	2966	}
2967		2967
2968	if (!sctp_sstate(sk, LISTENING)) {	2968	if (!sctp_sstate(sk, LISTENING)) {
2969	error = -EINVAL;	2969	error = -EINVAL;
2970	goto out;	2970	goto out;
2971	}	2971	}
2972		2972
2973	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);	2973	timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
2974		2974
2975	error = sctp_wait_for_accept(sk, timeo);	2975	error = sctp_wait_for_accept(sk, timeo);
2976	if (error)	2976	if (error)
2977	goto out;	2977	goto out;
2978		2978
2979	/* We treat the list of associations on the endpoint as the accept	2979	/* We treat the list of associations on the endpoint as the accept
2980	* queue and pick the first association on the list.	2980	* queue and pick the first association on the list.
2981	*/	2981	*/
2982	asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);	2982	asoc = list_entry(ep->asocs.next, struct sctp_association, asocs);
2983		2983
2984	newsk = sp->pf->create_accept_sk(sk, asoc);	2984	newsk = sp->pf->create_accept_sk(sk, asoc);
2985	if (!newsk) {	2985	if (!newsk) {
2986	error = -ENOMEM;	2986	error = -ENOMEM;
2987	goto out;	2987	goto out;
2988	}	2988	}
2989		2989
2990	/* Populate the fields of the newsk from the oldsk and migrate the	2990	/* Populate the fields of the newsk from the oldsk and migrate the
2991	* asoc to the newsk.	2991	* asoc to the newsk.
2992	*/	2992	*/
2993	sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);	2993	sctp_sock_migrate(sk, newsk, asoc, SCTP_SOCKET_TCP);
2994		2994
2995	out:	2995	out:
2996	sctp_release_sock(sk);	2996	sctp_release_sock(sk);
2997	*err = error;	2997	*err = error;
2998	return newsk;	2998	return newsk;
2999	}	2999	}
3000		3000
3001	/* The SCTP ioctl handler. */	3001	/* The SCTP ioctl handler. */
3002	SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)	3002	SCTP_STATIC int sctp_ioctl(struct sock *sk, int cmd, unsigned long arg)
3003	{	3003	{
3004	return -ENOIOCTLCMD;	3004	return -ENOIOCTLCMD;
3005	}	3005	}
3006		3006
3007	/* This is the function which gets called during socket creation to	3007	/* This is the function which gets called during socket creation to
3008	* initialized the SCTP-specific portion of the sock.	3008	* initialized the SCTP-specific portion of the sock.
3009	* The sock structure should already be zero-filled memory.	3009	* The sock structure should already be zero-filled memory.
3010	*/	3010	*/
3011	SCTP_STATIC int sctp_init_sock(struct sock *sk)	3011	SCTP_STATIC int sctp_init_sock(struct sock *sk)
3012	{	3012	{
3013	struct sctp_endpoint *ep;	3013	struct sctp_endpoint *ep;
3014	struct sctp_sock *sp;	3014	struct sctp_sock *sp;
3015		3015
3016	SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk);	3016	SCTP_DEBUG_PRINTK("sctp_init_sock(sk: %p)\n", sk);
3017		3017
3018	sp = sctp_sk(sk);	3018	sp = sctp_sk(sk);
3019		3019
3020	/* Initialize the SCTP per socket area. */	3020	/* Initialize the SCTP per socket area. */
3021	switch (sk->sk_type) {	3021	switch (sk->sk_type) {
3022	case SOCK_SEQPACKET:	3022	case SOCK_SEQPACKET:
3023	sp->type = SCTP_SOCKET_UDP;	3023	sp->type = SCTP_SOCKET_UDP;
3024	break;	3024	break;
3025	case SOCK_STREAM:	3025	case SOCK_STREAM:
3026	sp->type = SCTP_SOCKET_TCP;	3026	sp->type = SCTP_SOCKET_TCP;
3027	break;	3027	break;
3028	default:	3028	default:
3029	return -ESOCKTNOSUPPORT;	3029	return -ESOCKTNOSUPPORT;
3030	}	3030	}
3031		3031
3032	/* Initialize default send parameters. These parameters can be	3032	/* Initialize default send parameters. These parameters can be
3033	* modified with the SCTP_DEFAULT_SEND_PARAM socket option.	3033	* modified with the SCTP_DEFAULT_SEND_PARAM socket option.
3034	*/	3034	*/
3035	sp->default_stream = 0;	3035	sp->default_stream = 0;
3036	sp->default_ppid = 0;	3036	sp->default_ppid = 0;
3037	sp->default_flags = 0;	3037	sp->default_flags = 0;
3038	sp->default_context = 0;	3038	sp->default_context = 0;
3039	sp->default_timetolive = 0;	3039	sp->default_timetolive = 0;
3040		3040
3041	/* Initialize default setup parameters. These parameters	3041	/* Initialize default setup parameters. These parameters
3042	* can be modified with the SCTP_INITMSG socket option or	3042	* can be modified with the SCTP_INITMSG socket option or
3043	* overridden by the SCTP_INIT CMSG.	3043	* overridden by the SCTP_INIT CMSG.
3044	*/	3044	*/
3045	sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;	3045	sp->initmsg.sinit_num_ostreams = sctp_max_outstreams;
3046	sp->initmsg.sinit_max_instreams = sctp_max_instreams;	3046	sp->initmsg.sinit_max_instreams = sctp_max_instreams;
3047	sp->initmsg.sinit_max_attempts = sctp_max_retrans_init;	3047	sp->initmsg.sinit_max_attempts = sctp_max_retrans_init;
3048	sp->initmsg.sinit_max_init_timeo = sctp_rto_max;	3048	sp->initmsg.sinit_max_init_timeo = sctp_rto_max;
3049		3049
3050	/* Initialize default RTO related parameters. These parameters can	3050	/* Initialize default RTO related parameters. These parameters can
3051	* be modified for with the SCTP_RTOINFO socket option.	3051	* be modified for with the SCTP_RTOINFO socket option.
3052	*/	3052	*/
3053	sp->rtoinfo.srto_initial = sctp_rto_initial;	3053	sp->rtoinfo.srto_initial = sctp_rto_initial;
3054	sp->rtoinfo.srto_max = sctp_rto_max;	3054	sp->rtoinfo.srto_max = sctp_rto_max;
3055	sp->rtoinfo.srto_min = sctp_rto_min;	3055	sp->rtoinfo.srto_min = sctp_rto_min;
3056		3056
3057	/* Initialize default association related parameters. These parameters	3057	/* Initialize default association related parameters. These parameters
3058	* can be modified with the SCTP_ASSOCINFO socket option.	3058	* can be modified with the SCTP_ASSOCINFO socket option.
3059	*/	3059	*/
3060	sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association;	3060	sp->assocparams.sasoc_asocmaxrxt = sctp_max_retrans_association;
3061	sp->assocparams.sasoc_number_peer_destinations = 0;	3061	sp->assocparams.sasoc_number_peer_destinations = 0;
3062	sp->assocparams.sasoc_peer_rwnd = 0;	3062	sp->assocparams.sasoc_peer_rwnd = 0;
3063	sp->assocparams.sasoc_local_rwnd = 0;	3063	sp->assocparams.sasoc_local_rwnd = 0;
3064	sp->assocparams.sasoc_cookie_life = sctp_valid_cookie_life;	3064	sp->assocparams.sasoc_cookie_life = sctp_valid_cookie_life;
3065		3065
3066	/* Initialize default event subscriptions. By default, all the	3066	/* Initialize default event subscriptions. By default, all the
3067	* options are off.	3067	* options are off.
3068	*/	3068	*/
3069	memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));	3069	memset(&sp->subscribe, 0, sizeof(struct sctp_event_subscribe));
3070		3070
3071	/* Default Peer Address Parameters. These defaults can	3071	/* Default Peer Address Parameters. These defaults can
3072	* be modified via SCTP_PEER_ADDR_PARAMS	3072	* be modified via SCTP_PEER_ADDR_PARAMS
3073	*/	3073	*/
3074	sp->hbinterval = sctp_hb_interval;	3074	sp->hbinterval = sctp_hb_interval;
3075	sp->pathmaxrxt = sctp_max_retrans_path;	3075	sp->pathmaxrxt = sctp_max_retrans_path;
3076	sp->pathmtu = 0; // allow default discovery	3076	sp->pathmtu = 0; // allow default discovery
3077	sp->sackdelay = sctp_sack_timeout;	3077	sp->sackdelay = sctp_sack_timeout;
3078	sp->param_flags = SPP_HB_ENABLE \|	3078	sp->param_flags = SPP_HB_ENABLE \|
3079	SPP_PMTUD_ENABLE \|	3079	SPP_PMTUD_ENABLE \|
3080	SPP_SACKDELAY_ENABLE;	3080	SPP_SACKDELAY_ENABLE;
3081		3081
3082	/* If enabled no SCTP message fragmentation will be performed.	3082	/* If enabled no SCTP message fragmentation will be performed.
3083	* Configure through SCTP_DISABLE_FRAGMENTS socket option.	3083	* Configure through SCTP_DISABLE_FRAGMENTS socket option.
3084	*/	3084	*/
3085	sp->disable_fragments = 0;	3085	sp->disable_fragments = 0;
3086		3086
3087	/* Turn on/off any Nagle-like algorithm. */	3087	/* Turn on/off any Nagle-like algorithm. */
3088	sp->nodelay = 1;	3088	sp->nodelay = 1;
3089		3089
3090	/* Enable by default. */	3090	/* Enable by default. */
3091	sp->v4mapped = 1;	3091	sp->v4mapped = 1;
3092		3092
3093	/* Auto-close idle associations after the configured	3093	/* Auto-close idle associations after the configured
3094	* number of seconds. A value of 0 disables this	3094	* number of seconds. A value of 0 disables this
3095	* feature. Configure through the SCTP_AUTOCLOSE socket option,	3095	* feature. Configure through the SCTP_AUTOCLOSE socket option,
3096	* for UDP-style sockets only.	3096	* for UDP-style sockets only.
3097	*/	3097	*/
3098	sp->autoclose = 0;	3098	sp->autoclose = 0;
3099		3099
3100	/* User specified fragmentation limit. */	3100	/* User specified fragmentation limit. */
3101	sp->user_frag = 0;	3101	sp->user_frag = 0;
3102		3102
3103	sp->adaption_ind = 0;	3103	sp->adaption_ind = 0;
3104		3104
3105	sp->pf = sctp_get_pf_specific(sk->sk_family);	3105	sp->pf = sctp_get_pf_specific(sk->sk_family);
3106		3106
3107	/* Control variables for partial data delivery. */	3107	/* Control variables for partial data delivery. */
3108	sp->pd_mode = 0;	3108	sp->pd_mode = 0;
3109	skb_queue_head_init(&sp->pd_lobby);	3109	skb_queue_head_init(&sp->pd_lobby);
3110		3110
3111	/* Create a per socket endpoint structure. Even if we	3111	/* Create a per socket endpoint structure. Even if we
3112	* change the data structure relationships, this may still	3112	* change the data structure relationships, this may still
3113	* be useful for storing pre-connect address information.	3113	* be useful for storing pre-connect address information.
3114	*/	3114	*/
3115	ep = sctp_endpoint_new(sk, GFP_KERNEL);	3115	ep = sctp_endpoint_new(sk, GFP_KERNEL);
3116	if (!ep)	3116	if (!ep)
3117	return -ENOMEM;	3117	return -ENOMEM;
3118		3118
3119	sp->ep = ep;	3119	sp->ep = ep;
3120	sp->hmac = NULL;	3120	sp->hmac = NULL;
3121		3121
3122	SCTP_DBG_OBJCNT_INC(sock);	3122	SCTP_DBG_OBJCNT_INC(sock);
3123	return 0;	3123	return 0;
3124	}	3124	}
3125		3125
3126	/* Cleanup any SCTP per socket resources. */	3126	/* Cleanup any SCTP per socket resources. */
3127	SCTP_STATIC int sctp_destroy_sock(struct sock *sk)	3127	SCTP_STATIC int sctp_destroy_sock(struct sock *sk)
3128	{	3128	{
3129	struct sctp_endpoint *ep;	3129	struct sctp_endpoint *ep;
3130		3130
3131	SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk);	3131	SCTP_DEBUG_PRINTK("sctp_destroy_sock(sk: %p)\n", sk);
3132		3132
3133	/* Release our hold on the endpoint. */	3133	/* Release our hold on the endpoint. */
3134	ep = sctp_sk(sk)->ep;	3134	ep = sctp_sk(sk)->ep;
3135	sctp_endpoint_free(ep);	3135	sctp_endpoint_free(ep);
3136		3136
3137	return 0;	3137	return 0;
3138	}	3138	}
3139		3139
3140	/* API 4.1.7 shutdown() - TCP Style Syntax	3140	/* API 4.1.7 shutdown() - TCP Style Syntax
3141	* int shutdown(int socket, int how);	3141	* int shutdown(int socket, int how);
3142	*	3142	*
3143	* sd - the socket descriptor of the association to be closed.	3143	* sd - the socket descriptor of the association to be closed.
3144	* how - Specifies the type of shutdown. The values are	3144	* how - Specifies the type of shutdown. The values are
3145	* as follows:	3145	* as follows:
3146	* SHUT_RD	3146	* SHUT_RD
3147	* Disables further receive operations. No SCTP	3147	* Disables further receive operations. No SCTP
3148	* protocol action is taken.	3148	* protocol action is taken.
3149	* SHUT_WR	3149	* SHUT_WR
3150	* Disables further send operations, and initiates	3150	* Disables further send operations, and initiates
3151	* the SCTP shutdown sequence.	3151	* the SCTP shutdown sequence.
3152	* SHUT_RDWR	3152	* SHUT_RDWR
3153	* Disables further send and receive operations	3153	* Disables further send and receive operations
3154	* and initiates the SCTP shutdown sequence.	3154	* and initiates the SCTP shutdown sequence.
3155	*/	3155	*/
3156	SCTP_STATIC void sctp_shutdown(struct sock *sk, int how)	3156	SCTP_STATIC void sctp_shutdown(struct sock *sk, int how)
3157	{	3157	{
3158	struct sctp_endpoint *ep;	3158	struct sctp_endpoint *ep;
3159	struct sctp_association *asoc;	3159	struct sctp_association *asoc;
3160		3160
3161	if (!sctp_style(sk, TCP))	3161	if (!sctp_style(sk, TCP))
3162	return;	3162	return;
3163		3163
3164	if (how & SEND_SHUTDOWN) {	3164	if (how & SEND_SHUTDOWN) {
3165	ep = sctp_sk(sk)->ep;	3165	ep = sctp_sk(sk)->ep;
3166	if (!list_empty(&ep->asocs)) {	3166	if (!list_empty(&ep->asocs)) {
3167	asoc = list_entry(ep->asocs.next,	3167	asoc = list_entry(ep->asocs.next,
3168	struct sctp_association, asocs);	3168	struct sctp_association, asocs);
3169	sctp_primitive_SHUTDOWN(asoc, NULL);	3169	sctp_primitive_SHUTDOWN(asoc, NULL);
3170	}	3170	}
3171	}	3171	}
3172	}	3172	}
3173		3173
3174	/* 7.2.1 Association Status (SCTP_STATUS)	3174	/* 7.2.1 Association Status (SCTP_STATUS)
3175		3175
3176	* Applications can retrieve current status information about an	3176	* Applications can retrieve current status information about an
3177	* association, including association state, peer receiver window size,	3177	* association, including association state, peer receiver window size,
3178	* number of unacked data chunks, and number of data chunks pending	3178	* number of unacked data chunks, and number of data chunks pending
3179	* receipt. This information is read-only.	3179	* receipt. This information is read-only.
3180	*/	3180	*/
3181	static int sctp_getsockopt_sctp_status(struct sock *sk, int len,	3181	static int sctp_getsockopt_sctp_status(struct sock *sk, int len,
3182	char __user *optval,	3182	char __user *optval,
3183	int __user *optlen)	3183	int __user *optlen)
3184	{	3184	{
3185	struct sctp_status status;	3185	struct sctp_status status;
3186	struct sctp_association *asoc = NULL;	3186	struct sctp_association *asoc = NULL;
3187	struct sctp_transport *transport;	3187	struct sctp_transport *transport;
3188	sctp_assoc_t associd;	3188	sctp_assoc_t associd;
3189	int retval = 0;	3189	int retval = 0;
3190		3190
3191	if (len != sizeof(status)) {	3191	if (len != sizeof(status)) {
3192	retval = -EINVAL;	3192	retval = -EINVAL;
3193	goto out;	3193	goto out;
3194	}	3194	}
3195		3195
3196	if (copy_from_user(&status, optval, sizeof(status))) {	3196	if (copy_from_user(&status, optval, sizeof(status))) {
3197	retval = -EFAULT;	3197	retval = -EFAULT;
3198	goto out;	3198	goto out;
3199	}	3199	}
3200		3200
3201	associd = status.sstat_assoc_id;	3201	associd = status.sstat_assoc_id;
3202	asoc = sctp_id2assoc(sk, associd);	3202	asoc = sctp_id2assoc(sk, associd);
3203	if (!asoc) {	3203	if (!asoc) {
3204	retval = -EINVAL;	3204	retval = -EINVAL;
3205	goto out;	3205	goto out;
3206	}	3206	}
3207		3207
3208	transport = asoc->peer.primary_path;	3208	transport = asoc->peer.primary_path;
3209		3209
3210	status.sstat_assoc_id = sctp_assoc2id(asoc);	3210	status.sstat_assoc_id = sctp_assoc2id(asoc);
3211	status.sstat_state = asoc->state;	3211	status.sstat_state = asoc->state;
3212	status.sstat_rwnd = asoc->peer.rwnd;	3212	status.sstat_rwnd = asoc->peer.rwnd;
3213	status.sstat_unackdata = asoc->unack_data;	3213	status.sstat_unackdata = asoc->unack_data;
3214		3214
3215	status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);	3215	status.sstat_penddata = sctp_tsnmap_pending(&asoc->peer.tsn_map);
3216	status.sstat_instrms = asoc->c.sinit_max_instreams;	3216	status.sstat_instrms = asoc->c.sinit_max_instreams;
3217	status.sstat_outstrms = asoc->c.sinit_num_ostreams;	3217	status.sstat_outstrms = asoc->c.sinit_num_ostreams;
3218	status.sstat_fragmentation_point = asoc->frag_point;	3218	status.sstat_fragmentation_point = asoc->frag_point;
3219	status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);	3219	status.sstat_primary.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
3220	memcpy(&status.sstat_primary.spinfo_address,	3220	memcpy(&status.sstat_primary.spinfo_address,
3221	&(transport->ipaddr), sizeof(union sctp_addr));	3221	&(transport->ipaddr), sizeof(union sctp_addr));
3222	/* Map ipv4 address into v4-mapped-on-v6 address. */	3222	/* Map ipv4 address into v4-mapped-on-v6 address. */
3223	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),	3223	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
3224	(union sctp_addr *)&status.sstat_primary.spinfo_address);	3224	(union sctp_addr *)&status.sstat_primary.spinfo_address);
3225	status.sstat_primary.spinfo_state = transport->state;	3225	status.sstat_primary.spinfo_state = transport->state;
3226	status.sstat_primary.spinfo_cwnd = transport->cwnd;	3226	status.sstat_primary.spinfo_cwnd = transport->cwnd;
3227	status.sstat_primary.spinfo_srtt = transport->srtt;	3227	status.sstat_primary.spinfo_srtt = transport->srtt;
3228	status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);	3228	status.sstat_primary.spinfo_rto = jiffies_to_msecs(transport->rto);
3229	status.sstat_primary.spinfo_mtu = transport->pathmtu;	3229	status.sstat_primary.spinfo_mtu = transport->pathmtu;
3230		3230
3231	if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)	3231	if (status.sstat_primary.spinfo_state == SCTP_UNKNOWN)
3232	status.sstat_primary.spinfo_state = SCTP_ACTIVE;	3232	status.sstat_primary.spinfo_state = SCTP_ACTIVE;
3233		3233
3234	if (put_user(len, optlen)) {	3234	if (put_user(len, optlen)) {
3235	retval = -EFAULT;	3235	retval = -EFAULT;
3236	goto out;	3236	goto out;
3237	}	3237	}
3238		3238
3239	SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n",	3239	SCTP_DEBUG_PRINTK("sctp_getsockopt_sctp_status(%d): %d %d %d\n",
3240	len, status.sstat_state, status.sstat_rwnd,	3240	len, status.sstat_state, status.sstat_rwnd,
3241	status.sstat_assoc_id);	3241	status.sstat_assoc_id);
3242		3242
3243	if (copy_to_user(optval, &status, len)) {	3243	if (copy_to_user(optval, &status, len)) {
3244	retval = -EFAULT;	3244	retval = -EFAULT;
3245	goto out;	3245	goto out;
3246	}	3246	}
3247		3247
3248	out:	3248	out:
3249	return (retval);	3249	return (retval);
3250	}	3250	}
3251		3251
3252		3252
3253	/* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)	3253	/* 7.2.2 Peer Address Information (SCTP_GET_PEER_ADDR_INFO)
3254	*	3254	*
3255	* Applications can retrieve information about a specific peer address	3255	* Applications can retrieve information about a specific peer address
3256	* of an association, including its reachability state, congestion	3256	* of an association, including its reachability state, congestion
3257	* window, and retransmission timer values. This information is	3257	* window, and retransmission timer values. This information is
3258	* read-only.	3258	* read-only.
3259	*/	3259	*/
3260	static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,	3260	static int sctp_getsockopt_peer_addr_info(struct sock *sk, int len,
3261	char __user *optval,	3261	char __user *optval,
3262	int __user *optlen)	3262	int __user *optlen)
3263	{	3263	{
3264	struct sctp_paddrinfo pinfo;	3264	struct sctp_paddrinfo pinfo;
3265	struct sctp_transport *transport;	3265	struct sctp_transport *transport;
3266	int retval = 0;	3266	int retval = 0;
3267		3267
3268	if (len != sizeof(pinfo)) {	3268	if (len != sizeof(pinfo)) {
3269	retval = -EINVAL;	3269	retval = -EINVAL;
3270	goto out;	3270	goto out;
3271	}	3271	}
3272		3272
3273	if (copy_from_user(&pinfo, optval, sizeof(pinfo))) {	3273	if (copy_from_user(&pinfo, optval, sizeof(pinfo))) {
3274	retval = -EFAULT;	3274	retval = -EFAULT;
3275	goto out;	3275	goto out;
3276	}	3276	}
3277		3277
3278	transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,	3278	transport = sctp_addr_id2transport(sk, &pinfo.spinfo_address,
3279	pinfo.spinfo_assoc_id);	3279	pinfo.spinfo_assoc_id);
3280	if (!transport)	3280	if (!transport)
3281	return -EINVAL;	3281	return -EINVAL;
3282		3282
3283	pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);	3283	pinfo.spinfo_assoc_id = sctp_assoc2id(transport->asoc);
3284	pinfo.spinfo_state = transport->state;	3284	pinfo.spinfo_state = transport->state;
3285	pinfo.spinfo_cwnd = transport->cwnd;	3285	pinfo.spinfo_cwnd = transport->cwnd;
3286	pinfo.spinfo_srtt = transport->srtt;	3286	pinfo.spinfo_srtt = transport->srtt;
3287	pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);	3287	pinfo.spinfo_rto = jiffies_to_msecs(transport->rto);
3288	pinfo.spinfo_mtu = transport->pathmtu;	3288	pinfo.spinfo_mtu = transport->pathmtu;
3289		3289
3290	if (pinfo.spinfo_state == SCTP_UNKNOWN)	3290	if (pinfo.spinfo_state == SCTP_UNKNOWN)
3291	pinfo.spinfo_state = SCTP_ACTIVE;	3291	pinfo.spinfo_state = SCTP_ACTIVE;
3292		3292
3293	if (put_user(len, optlen)) {	3293	if (put_user(len, optlen)) {
3294	retval = -EFAULT;	3294	retval = -EFAULT;
3295	goto out;	3295	goto out;
3296	}	3296	}
3297		3297
3298	if (copy_to_user(optval, &pinfo, len)) {	3298	if (copy_to_user(optval, &pinfo, len)) {
3299	retval = -EFAULT;	3299	retval = -EFAULT;
3300	goto out;	3300	goto out;
3301	}	3301	}
3302		3302
3303	out:	3303	out:
3304	return (retval);	3304	return (retval);
3305	}	3305	}
3306		3306
3307	/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)	3307	/* 7.1.12 Enable/Disable message fragmentation (SCTP_DISABLE_FRAGMENTS)
3308	*	3308	*
3309	* This option is a on/off flag. If enabled no SCTP message	3309	* This option is a on/off flag. If enabled no SCTP message
3310	* fragmentation will be performed. Instead if a message being sent	3310	* fragmentation will be performed. Instead if a message being sent
3311	* exceeds the current PMTU size, the message will NOT be sent and	3311	* exceeds the current PMTU size, the message will NOT be sent and
3312	* instead a error will be indicated to the user.	3312	* instead a error will be indicated to the user.
3313	*/	3313	*/
3314	static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,	3314	static int sctp_getsockopt_disable_fragments(struct sock *sk, int len,
3315	char __user optval, int __user optlen)	3315	char __user optval, int __user optlen)
3316	{	3316	{
3317	int val;	3317	int val;
3318		3318
3319	if (len < sizeof(int))	3319	if (len < sizeof(int))
3320	return -EINVAL;	3320	return -EINVAL;
3321		3321
3322	len = sizeof(int);	3322	len = sizeof(int);
3323	val = (sctp_sk(sk)->disable_fragments == 1);	3323	val = (sctp_sk(sk)->disable_fragments == 1);
3324	if (put_user(len, optlen))	3324	if (put_user(len, optlen))
3325	return -EFAULT;	3325	return -EFAULT;
3326	if (copy_to_user(optval, &val, len))	3326	if (copy_to_user(optval, &val, len))
3327	return -EFAULT;	3327	return -EFAULT;
3328	return 0;	3328	return 0;
3329	}	3329	}
3330		3330
3331	/* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)	3331	/* 7.1.15 Set notification and ancillary events (SCTP_EVENTS)
3332	*	3332	*
3333	* This socket option is used to specify various notifications and	3333	* This socket option is used to specify various notifications and
3334	* ancillary data the user wishes to receive.	3334	* ancillary data the user wishes to receive.
3335	*/	3335	*/
3336	static int sctp_getsockopt_events(struct sock sk, int len, char __user optval,	3336	static int sctp_getsockopt_events(struct sock sk, int len, char __user optval,
3337	int __user *optlen)	3337	int __user *optlen)
3338	{	3338	{
3339	if (len != sizeof(struct sctp_event_subscribe))	3339	if (len != sizeof(struct sctp_event_subscribe))
3340	return -EINVAL;	3340	return -EINVAL;
3341	if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))	3341	if (copy_to_user(optval, &sctp_sk(sk)->subscribe, len))
3342	return -EFAULT;	3342	return -EFAULT;
3343	return 0;	3343	return 0;
3344	}	3344	}
3345		3345
3346	/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)	3346	/* 7.1.8 Automatic Close of associations (SCTP_AUTOCLOSE)
3347	*	3347	*
3348	* This socket option is applicable to the UDP-style socket only. When	3348	* This socket option is applicable to the UDP-style socket only. When
3349	* set it will cause associations that are idle for more than the	3349	* set it will cause associations that are idle for more than the
3350	* specified number of seconds to automatically close. An association	3350	* specified number of seconds to automatically close. An association
3351	* being idle is defined an association that has NOT sent or received	3351	* being idle is defined an association that has NOT sent or received
3352	* user data. The special value of '0' indicates that no automatic	3352	* user data. The special value of '0' indicates that no automatic
3353	* close of any associations should be performed. The option expects an	3353	* close of any associations should be performed. The option expects an
3354	* integer defining the number of seconds of idle time before an	3354	* integer defining the number of seconds of idle time before an
3355	* association is closed.	3355	* association is closed.
3356	*/	3356	*/
3357	static int sctp_getsockopt_autoclose(struct sock sk, int len, char __user optval, int __user *optlen)	3357	static int sctp_getsockopt_autoclose(struct sock sk, int len, char __user optval, int __user *optlen)
3358	{	3358	{
3359	/* Applicable to UDP-style socket only */	3359	/* Applicable to UDP-style socket only */
3360	if (sctp_style(sk, TCP))	3360	if (sctp_style(sk, TCP))
3361	return -EOPNOTSUPP;	3361	return -EOPNOTSUPP;
3362	if (len != sizeof(int))	3362	if (len != sizeof(int))
3363	return -EINVAL;	3363	return -EINVAL;
3364	if (copy_to_user(optval, &sctp_sk(sk)->autoclose, len))	3364	if (copy_to_user(optval, &sctp_sk(sk)->autoclose, len))
3365	return -EFAULT;	3365	return -EFAULT;
3366	return 0;	3366	return 0;
3367	}	3367	}
3368		3368
3369	/* Helper routine to branch off an association to a new socket. */	3369	/* Helper routine to branch off an association to a new socket. */
3370	SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,	3370	SCTP_STATIC int sctp_do_peeloff(struct sctp_association *asoc,
3371	struct socket **sockp)	3371	struct socket **sockp)
3372	{	3372	{
3373	struct sock *sk = asoc->base.sk;	3373	struct sock *sk = asoc->base.sk;
3374	struct socket *sock;	3374	struct socket *sock;
3375	int err = 0;	3375	int err = 0;
3376		3376
3377	/* An association cannot be branched off from an already peeled-off	3377	/* An association cannot be branched off from an already peeled-off
3378	* socket, nor is this supported for tcp style sockets.	3378	* socket, nor is this supported for tcp style sockets.
3379	*/	3379	*/
3380	if (!sctp_style(sk, UDP))	3380	if (!sctp_style(sk, UDP))
3381	return -EINVAL;	3381	return -EINVAL;
3382		3382
3383	/* Create a new socket. */	3383	/* Create a new socket. */
3384	err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);	3384	err = sock_create(sk->sk_family, SOCK_SEQPACKET, IPPROTO_SCTP, &sock);
3385	if (err < 0)	3385	if (err < 0)
3386	return err;	3386	return err;
3387		3387
3388	/* Populate the fields of the newsk from the oldsk and migrate the	3388	/* Populate the fields of the newsk from the oldsk and migrate the
3389	* asoc to the newsk.	3389	* asoc to the newsk.
3390	*/	3390	*/
3391	sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);	3391	sctp_sock_migrate(sk, sock->sk, asoc, SCTP_SOCKET_UDP_HIGH_BANDWIDTH);
3392	*sockp = sock;	3392	*sockp = sock;
3393		3393
3394	return err;	3394	return err;
3395	}	3395	}
3396		3396
3397	static int sctp_getsockopt_peeloff(struct sock sk, int len, char __user optval, int __user *optlen)	3397	static int sctp_getsockopt_peeloff(struct sock sk, int len, char __user optval, int __user *optlen)
3398	{	3398	{
3399	sctp_peeloff_arg_t peeloff;	3399	sctp_peeloff_arg_t peeloff;
3400	struct socket *newsock;	3400	struct socket *newsock;
3401	int retval = 0;	3401	int retval = 0;
3402	struct sctp_association *asoc;	3402	struct sctp_association *asoc;
3403		3403
3404	if (len != sizeof(sctp_peeloff_arg_t))	3404	if (len != sizeof(sctp_peeloff_arg_t))
3405	return -EINVAL;	3405	return -EINVAL;
3406	if (copy_from_user(&peeloff, optval, len))	3406	if (copy_from_user(&peeloff, optval, len))
3407	return -EFAULT;	3407	return -EFAULT;
3408		3408
3409	asoc = sctp_id2assoc(sk, peeloff.associd);	3409	asoc = sctp_id2assoc(sk, peeloff.associd);
3410	if (!asoc) {	3410	if (!asoc) {
3411	retval = -EINVAL;	3411	retval = -EINVAL;
3412	goto out;	3412	goto out;
3413	}	3413	}
3414		3414
3415	SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __FUNCTION__, sk, asoc);	3415	SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p\n", __FUNCTION__, sk, asoc);
3416		3416
3417	retval = sctp_do_peeloff(asoc, &newsock);	3417	retval = sctp_do_peeloff(asoc, &newsock);
3418	if (retval < 0)	3418	if (retval < 0)
3419	goto out;	3419	goto out;
3420		3420
3421	/* Map the socket to an unused fd that can be returned to the user. */	3421	/* Map the socket to an unused fd that can be returned to the user. */
3422	retval = sock_map_fd(newsock);	3422	retval = sock_map_fd(newsock);
3423	if (retval < 0) {	3423	if (retval < 0) {
3424	sock_release(newsock);	3424	sock_release(newsock);
3425	goto out;	3425	goto out;
3426	}	3426	}
3427		3427
3428	SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n",	3428	SCTP_DEBUG_PRINTK("%s: sk: %p asoc: %p newsk: %p sd: %d\n",
3429	__FUNCTION__, sk, asoc, newsock->sk, retval);	3429	__FUNCTION__, sk, asoc, newsock->sk, retval);
3430		3430
3431	/* Return the fd mapped to the new socket. */	3431	/* Return the fd mapped to the new socket. */
3432	peeloff.sd = retval;	3432	peeloff.sd = retval;
3433	if (copy_to_user(optval, &peeloff, len))	3433	if (copy_to_user(optval, &peeloff, len))
3434	retval = -EFAULT;	3434	retval = -EFAULT;
3435		3435
3436	out:	3436	out:
3437	return retval;	3437	return retval;
3438	}	3438	}
3439		3439
3440	/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)	3440	/* 7.1.13 Peer Address Parameters (SCTP_PEER_ADDR_PARAMS)
3441	*	3441	*
3442	* Applications can enable or disable heartbeats for any peer address of	3442	* Applications can enable or disable heartbeats for any peer address of
3443	* an association, modify an address's heartbeat interval, force a	3443	* an association, modify an address's heartbeat interval, force a
3444	* heartbeat to be sent immediately, and adjust the address's maximum	3444	* heartbeat to be sent immediately, and adjust the address's maximum
3445	* number of retransmissions sent before an address is considered	3445	* number of retransmissions sent before an address is considered
3446	* unreachable. The following structure is used to access and modify an	3446	* unreachable. The following structure is used to access and modify an
3447	* address's parameters:	3447	* address's parameters:
3448	*	3448	*
3449	* struct sctp_paddrparams {	3449	* struct sctp_paddrparams {
3450	* sctp_assoc_t spp_assoc_id;	3450	* sctp_assoc_t spp_assoc_id;
3451	* struct sockaddr_storage spp_address;	3451	* struct sockaddr_storage spp_address;
3452	* uint32_t spp_hbinterval;	3452	* uint32_t spp_hbinterval;
3453	* uint16_t spp_pathmaxrxt;	3453	* uint16_t spp_pathmaxrxt;
3454	* uint32_t spp_pathmtu;	3454	* uint32_t spp_pathmtu;
3455	* uint32_t spp_sackdelay;	3455	* uint32_t spp_sackdelay;
3456	* uint32_t spp_flags;	3456	* uint32_t spp_flags;
3457	* };	3457	* };
3458	*	3458	*
3459	* spp_assoc_id - (one-to-many style socket) This is filled in the	3459	* spp_assoc_id - (one-to-many style socket) This is filled in the
3460	* application, and identifies the association for	3460	* application, and identifies the association for
3461	* this query.	3461	* this query.
3462	* spp_address - This specifies which address is of interest.	3462	* spp_address - This specifies which address is of interest.
3463	* spp_hbinterval - This contains the value of the heartbeat interval,	3463	* spp_hbinterval - This contains the value of the heartbeat interval,
3464	* in milliseconds. If a value of zero	3464	* in milliseconds. If a value of zero
3465	* is present in this field then no changes are to	3465	* is present in this field then no changes are to
3466	* be made to this parameter.	3466	* be made to this parameter.
3467	* spp_pathmaxrxt - This contains the maximum number of	3467	* spp_pathmaxrxt - This contains the maximum number of
3468	* retransmissions before this address shall be	3468	* retransmissions before this address shall be
3469	* considered unreachable. If a value of zero	3469	* considered unreachable. If a value of zero
3470	* is present in this field then no changes are to	3470	* is present in this field then no changes are to
3471	* be made to this parameter.	3471	* be made to this parameter.
3472	* spp_pathmtu - When Path MTU discovery is disabled the value	3472	* spp_pathmtu - When Path MTU discovery is disabled the value
3473	* specified here will be the "fixed" path mtu.	3473	* specified here will be the "fixed" path mtu.
3474	* Note that if the spp_address field is empty	3474	* Note that if the spp_address field is empty
3475	* then all associations on this address will	3475	* then all associations on this address will
3476	* have this fixed path mtu set upon them.	3476	* have this fixed path mtu set upon them.
3477	*	3477	*
3478	* spp_sackdelay - When delayed sack is enabled, this value specifies	3478	* spp_sackdelay - When delayed sack is enabled, this value specifies
3479	* the number of milliseconds that sacks will be delayed	3479	* the number of milliseconds that sacks will be delayed
3480	* for. This value will apply to all addresses of an	3480	* for. This value will apply to all addresses of an
3481	* association if the spp_address field is empty. Note	3481	* association if the spp_address field is empty. Note
3482	* also, that if delayed sack is enabled and this	3482	* also, that if delayed sack is enabled and this
3483	* value is set to 0, no change is made to the last	3483	* value is set to 0, no change is made to the last
3484	* recorded delayed sack timer value.	3484	* recorded delayed sack timer value.
3485	*	3485	*
3486	* spp_flags - These flags are used to control various features	3486	* spp_flags - These flags are used to control various features
3487	* on an association. The flag field may contain	3487	* on an association. The flag field may contain
3488	* zero or more of the following options.	3488	* zero or more of the following options.
3489	*	3489	*
3490	* SPP_HB_ENABLE - Enable heartbeats on the	3490	* SPP_HB_ENABLE - Enable heartbeats on the
3491	* specified address. Note that if the address	3491	* specified address. Note that if the address
3492	* field is empty all addresses for the association	3492	* field is empty all addresses for the association
3493	* have heartbeats enabled upon them.	3493	* have heartbeats enabled upon them.
3494	*	3494	*
3495	* SPP_HB_DISABLE - Disable heartbeats on the	3495	* SPP_HB_DISABLE - Disable heartbeats on the
3496	* speicifed address. Note that if the address	3496	* speicifed address. Note that if the address
3497	* field is empty all addresses for the association	3497	* field is empty all addresses for the association
3498	* will have their heartbeats disabled. Note also	3498	* will have their heartbeats disabled. Note also
3499	* that SPP_HB_ENABLE and SPP_HB_DISABLE are	3499	* that SPP_HB_ENABLE and SPP_HB_DISABLE are
3500	* mutually exclusive, only one of these two should	3500	* mutually exclusive, only one of these two should
3501	* be specified. Enabling both fields will have	3501	* be specified. Enabling both fields will have
3502	* undetermined results.	3502	* undetermined results.
3503	*	3503	*
3504	* SPP_HB_DEMAND - Request a user initiated heartbeat	3504	* SPP_HB_DEMAND - Request a user initiated heartbeat
3505	* to be made immediately.	3505	* to be made immediately.
3506	*	3506	*
3507	* SPP_PMTUD_ENABLE - This field will enable PMTU	3507	* SPP_PMTUD_ENABLE - This field will enable PMTU
3508	* discovery upon the specified address. Note that	3508	* discovery upon the specified address. Note that
3509	* if the address feild is empty then all addresses	3509	* if the address feild is empty then all addresses
3510	* on the association are effected.	3510	* on the association are effected.
3511	*	3511	*
3512	* SPP_PMTUD_DISABLE - This field will disable PMTU	3512	* SPP_PMTUD_DISABLE - This field will disable PMTU
3513	* discovery upon the specified address. Note that	3513	* discovery upon the specified address. Note that
3514	* if the address feild is empty then all addresses	3514	* if the address feild is empty then all addresses
3515	* on the association are effected. Not also that	3515	* on the association are effected. Not also that
3516	* SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually	3516	* SPP_PMTUD_ENABLE and SPP_PMTUD_DISABLE are mutually
3517	* exclusive. Enabling both will have undetermined	3517	* exclusive. Enabling both will have undetermined
3518	* results.	3518	* results.
3519	*	3519	*
3520	* SPP_SACKDELAY_ENABLE - Setting this flag turns	3520	* SPP_SACKDELAY_ENABLE - Setting this flag turns
3521	* on delayed sack. The time specified in spp_sackdelay	3521	* on delayed sack. The time specified in spp_sackdelay
3522	* is used to specify the sack delay for this address. Note	3522	* is used to specify the sack delay for this address. Note
3523	* that if spp_address is empty then all addresses will	3523	* that if spp_address is empty then all addresses will
3524	* enable delayed sack and take on the sack delay	3524	* enable delayed sack and take on the sack delay
3525	* value specified in spp_sackdelay.	3525	* value specified in spp_sackdelay.
3526	* SPP_SACKDELAY_DISABLE - Setting this flag turns	3526	* SPP_SACKDELAY_DISABLE - Setting this flag turns
3527	* off delayed sack. If the spp_address field is blank then	3527	* off delayed sack. If the spp_address field is blank then
3528	* delayed sack is disabled for the entire association. Note	3528	* delayed sack is disabled for the entire association. Note
3529	* also that this field is mutually exclusive to	3529	* also that this field is mutually exclusive to
3530	* SPP_SACKDELAY_ENABLE, setting both will have undefined	3530	* SPP_SACKDELAY_ENABLE, setting both will have undefined
3531	* results.	3531	* results.
3532	*/	3532	*/
3533	static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,	3533	static int sctp_getsockopt_peer_addr_params(struct sock *sk, int len,
3534	char __user optval, int __user optlen)	3534	char __user optval, int __user optlen)
3535	{	3535	{
3536	struct sctp_paddrparams params;	3536	struct sctp_paddrparams params;
3537	struct sctp_transport *trans = NULL;	3537	struct sctp_transport *trans = NULL;
3538	struct sctp_association *asoc = NULL;	3538	struct sctp_association *asoc = NULL;
3539	struct sctp_sock *sp = sctp_sk(sk);	3539	struct sctp_sock *sp = sctp_sk(sk);
3540		3540
3541	if (len != sizeof(struct sctp_paddrparams))	3541	if (len != sizeof(struct sctp_paddrparams))
3542	return -EINVAL;	3542	return -EINVAL;
3543		3543
3544	if (copy_from_user(&params, optval, len))	3544	if (copy_from_user(&params, optval, len))
3545	return -EFAULT;	3545	return -EFAULT;
3546		3546
3547	/* If an address other than INADDR_ANY is specified, and	3547	/* If an address other than INADDR_ANY is specified, and
3548	* no transport is found, then the request is invalid.	3548	* no transport is found, then the request is invalid.
3549	*/	3549	*/
3550	if (!sctp_is_any(( union sctp_addr *)&params.spp_address)) {	3550	if (!sctp_is_any(( union sctp_addr *)&params.spp_address)) {
3551	trans = sctp_addr_id2transport(sk, &params.spp_address,	3551	trans = sctp_addr_id2transport(sk, &params.spp_address,
3552	params.spp_assoc_id);	3552	params.spp_assoc_id);
3553	if (!trans) {	3553	if (!trans) {
3554	SCTP_DEBUG_PRINTK("Failed no transport\n");	3554	SCTP_DEBUG_PRINTK("Failed no transport\n");
3555	return -EINVAL;	3555	return -EINVAL;
3556	}	3556	}
3557	}	3557	}
3558		3558
3559	/* Get association, if assoc_id != 0 and the socket is a one	3559	/* Get association, if assoc_id != 0 and the socket is a one
3560	* to many style socket, and an association was not found, then	3560	* to many style socket, and an association was not found, then
3561	* the id was invalid.	3561	* the id was invalid.
3562	*/	3562	*/
3563	asoc = sctp_id2assoc(sk, params.spp_assoc_id);	3563	asoc = sctp_id2assoc(sk, params.spp_assoc_id);
3564	if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {	3564	if (!asoc && params.spp_assoc_id && sctp_style(sk, UDP)) {
3565	SCTP_DEBUG_PRINTK("Failed no association\n");	3565	SCTP_DEBUG_PRINTK("Failed no association\n");
3566	return -EINVAL;	3566	return -EINVAL;
3567	}	3567	}
3568		3568
3569	if (trans) {	3569	if (trans) {
3570	/* Fetch transport values. */	3570	/* Fetch transport values. */
3571	params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);	3571	params.spp_hbinterval = jiffies_to_msecs(trans->hbinterval);
3572	params.spp_pathmtu = trans->pathmtu;	3572	params.spp_pathmtu = trans->pathmtu;
3573	params.spp_pathmaxrxt = trans->pathmaxrxt;	3573	params.spp_pathmaxrxt = trans->pathmaxrxt;
3574	params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);	3574	params.spp_sackdelay = jiffies_to_msecs(trans->sackdelay);
3575		3575
3576	/draft-11 doesn't say what to return in spp_flags/	3576	/draft-11 doesn't say what to return in spp_flags/
3577	params.spp_flags = trans->param_flags;	3577	params.spp_flags = trans->param_flags;
3578	} else if (asoc) {	3578	} else if (asoc) {
3579	/* Fetch association values. */	3579	/* Fetch association values. */
3580	params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);	3580	params.spp_hbinterval = jiffies_to_msecs(asoc->hbinterval);
3581	params.spp_pathmtu = asoc->pathmtu;	3581	params.spp_pathmtu = asoc->pathmtu;
3582	params.spp_pathmaxrxt = asoc->pathmaxrxt;	3582	params.spp_pathmaxrxt = asoc->pathmaxrxt;
3583	params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);	3583	params.spp_sackdelay = jiffies_to_msecs(asoc->sackdelay);
3584		3584
3585	/draft-11 doesn't say what to return in spp_flags/	3585	/draft-11 doesn't say what to return in spp_flags/
3586	params.spp_flags = asoc->param_flags;	3586	params.spp_flags = asoc->param_flags;
3587	} else {	3587	} else {
3588	/* Fetch socket values. */	3588	/* Fetch socket values. */
3589	params.spp_hbinterval = sp->hbinterval;	3589	params.spp_hbinterval = sp->hbinterval;
3590	params.spp_pathmtu = sp->pathmtu;	3590	params.spp_pathmtu = sp->pathmtu;
3591	params.spp_sackdelay = sp->sackdelay;	3591	params.spp_sackdelay = sp->sackdelay;
3592	params.spp_pathmaxrxt = sp->pathmaxrxt;	3592	params.spp_pathmaxrxt = sp->pathmaxrxt;
3593		3593
3594	/draft-11 doesn't say what to return in spp_flags/	3594	/draft-11 doesn't say what to return in spp_flags/
3595	params.spp_flags = sp->param_flags;	3595	params.spp_flags = sp->param_flags;
3596	}	3596	}
3597		3597
3598	if (copy_to_user(optval, &params, len))	3598	if (copy_to_user(optval, &params, len))
3599	return -EFAULT;	3599	return -EFAULT;
3600		3600
3601	if (put_user(len, optlen))	3601	if (put_user(len, optlen))
3602	return -EFAULT;	3602	return -EFAULT;
3603		3603
3604	return 0;	3604	return 0;
3605	}	3605	}
3606		3606
3607	/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)	3607	/* 7.1.24. Delayed Ack Timer (SCTP_DELAYED_ACK_TIME)
3608	*	3608	*
3609	* This options will get or set the delayed ack timer. The time is set	3609	* This options will get or set the delayed ack timer. The time is set
3610	* in milliseconds. If the assoc_id is 0, then this sets or gets the	3610	* in milliseconds. If the assoc_id is 0, then this sets or gets the
3611	* endpoints default delayed ack timer value. If the assoc_id field is	3611	* endpoints default delayed ack timer value. If the assoc_id field is
3612	* non-zero, then the set or get effects the specified association.	3612	* non-zero, then the set or get effects the specified association.
3613	*	3613	*
3614	* struct sctp_assoc_value {	3614	* struct sctp_assoc_value {
3615	* sctp_assoc_t assoc_id;	3615	* sctp_assoc_t assoc_id;
3616	* uint32_t assoc_value;	3616	* uint32_t assoc_value;
3617	* };	3617	* };
3618	*	3618	*
3619	* assoc_id - This parameter, indicates which association the	3619	* assoc_id - This parameter, indicates which association the
3620	* user is preforming an action upon. Note that if	3620	* user is preforming an action upon. Note that if
3621	* this field's value is zero then the endpoints	3621	* this field's value is zero then the endpoints
3622	* default value is changed (effecting future	3622	* default value is changed (effecting future
3623	* associations only).	3623	* associations only).
3624	*	3624	*
3625	* assoc_value - This parameter contains the number of milliseconds	3625	* assoc_value - This parameter contains the number of milliseconds
3626	* that the user is requesting the delayed ACK timer	3626	* that the user is requesting the delayed ACK timer
3627	* be set to. Note that this value is defined in	3627	* be set to. Note that this value is defined in
3628	* the standard to be between 200 and 500 milliseconds.	3628	* the standard to be between 200 and 500 milliseconds.
3629	*	3629	*
3630	* Note: a value of zero will leave the value alone,	3630	* Note: a value of zero will leave the value alone,
3631	* but disable SACK delay. A non-zero value will also	3631	* but disable SACK delay. A non-zero value will also
3632	* enable SACK delay.	3632	* enable SACK delay.
3633	*/	3633	*/
3634	static int sctp_getsockopt_delayed_ack_time(struct sock *sk, int len,	3634	static int sctp_getsockopt_delayed_ack_time(struct sock *sk, int len,
3635	char __user *optval,	3635	char __user *optval,
3636	int __user *optlen)	3636	int __user *optlen)
3637	{	3637	{
3638	struct sctp_assoc_value params;	3638	struct sctp_assoc_value params;
3639	struct sctp_association *asoc = NULL;	3639	struct sctp_association *asoc = NULL;
3640	struct sctp_sock *sp = sctp_sk(sk);	3640	struct sctp_sock *sp = sctp_sk(sk);
3641		3641
3642	if (len != sizeof(struct sctp_assoc_value))	3642	if (len != sizeof(struct sctp_assoc_value))
3643	return - EINVAL;	3643	return - EINVAL;
3644		3644
3645	if (copy_from_user(&params, optval, len))	3645	if (copy_from_user(&params, optval, len))
3646	return -EFAULT;	3646	return -EFAULT;
3647		3647
3648	/* Get association, if assoc_id != 0 and the socket is a one	3648	/* Get association, if assoc_id != 0 and the socket is a one
3649	* to many style socket, and an association was not found, then	3649	* to many style socket, and an association was not found, then
3650	* the id was invalid.	3650	* the id was invalid.
3651	*/	3651	*/
3652	asoc = sctp_id2assoc(sk, params.assoc_id);	3652	asoc = sctp_id2assoc(sk, params.assoc_id);
3653	if (!asoc && params.assoc_id && sctp_style(sk, UDP))	3653	if (!asoc && params.assoc_id && sctp_style(sk, UDP))
3654	return -EINVAL;	3654	return -EINVAL;
3655		3655
3656	if (asoc) {	3656	if (asoc) {
3657	/* Fetch association values. */	3657	/* Fetch association values. */
3658	if (asoc->param_flags & SPP_SACKDELAY_ENABLE)	3658	if (asoc->param_flags & SPP_SACKDELAY_ENABLE)
3659	params.assoc_value = jiffies_to_msecs(	3659	params.assoc_value = jiffies_to_msecs(
3660	asoc->sackdelay);	3660	asoc->sackdelay);
3661	else	3661	else
3662	params.assoc_value = 0;	3662	params.assoc_value = 0;
3663	} else {	3663	} else {
3664	/* Fetch socket values. */	3664	/* Fetch socket values. */
3665	if (sp->param_flags & SPP_SACKDELAY_ENABLE)	3665	if (sp->param_flags & SPP_SACKDELAY_ENABLE)
3666	params.assoc_value = sp->sackdelay;	3666	params.assoc_value = sp->sackdelay;
3667	else	3667	else
3668	params.assoc_value = 0;	3668	params.assoc_value = 0;
3669	}	3669	}
3670		3670
3671	if (copy_to_user(optval, &params, len))	3671	if (copy_to_user(optval, &params, len))
3672	return -EFAULT;	3672	return -EFAULT;
3673		3673
3674	if (put_user(len, optlen))	3674	if (put_user(len, optlen))
3675	return -EFAULT;	3675	return -EFAULT;
3676		3676
3677	return 0;	3677	return 0;
3678	}	3678	}
3679		3679
3680	/* 7.1.3 Initialization Parameters (SCTP_INITMSG)	3680	/* 7.1.3 Initialization Parameters (SCTP_INITMSG)
3681	*	3681	*
3682	* Applications can specify protocol parameters for the default association	3682	* Applications can specify protocol parameters for the default association
3683	* initialization. The option name argument to setsockopt() and getsockopt()	3683	* initialization. The option name argument to setsockopt() and getsockopt()
3684	* is SCTP_INITMSG.	3684	* is SCTP_INITMSG.
3685	*	3685	*
3686	* Setting initialization parameters is effective only on an unconnected	3686	* Setting initialization parameters is effective only on an unconnected
3687	* socket (for UDP-style sockets only future associations are effected	3687	* socket (for UDP-style sockets only future associations are effected
3688	* by the change). With TCP-style sockets, this option is inherited by	3688	* by the change). With TCP-style sockets, this option is inherited by
3689	* sockets derived from a listener socket.	3689	* sockets derived from a listener socket.
3690	*/	3690	*/
3691	static int sctp_getsockopt_initmsg(struct sock sk, int len, char __user optval, int __user *optlen)	3691	static int sctp_getsockopt_initmsg(struct sock sk, int len, char __user optval, int __user *optlen)
3692	{	3692	{
3693	if (len != sizeof(struct sctp_initmsg))	3693	if (len != sizeof(struct sctp_initmsg))
3694	return -EINVAL;	3694	return -EINVAL;
3695	if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))	3695	if (copy_to_user(optval, &sctp_sk(sk)->initmsg, len))
3696	return -EFAULT;	3696	return -EFAULT;
3697	return 0;	3697	return 0;
3698	}	3698	}
3699		3699
3700	static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len,	3700	static int sctp_getsockopt_peer_addrs_num_old(struct sock *sk, int len,
3701	char __user *optval,	3701	char __user *optval,
3702	int __user *optlen)	3702	int __user *optlen)
3703	{	3703	{
3704	sctp_assoc_t id;	3704	sctp_assoc_t id;
3705	struct sctp_association *asoc;	3705	struct sctp_association *asoc;
3706	struct list_head *pos;	3706	struct list_head *pos;
3707	int cnt = 0;	3707	int cnt = 0;
3708		3708
3709	if (len != sizeof(sctp_assoc_t))	3709	if (len != sizeof(sctp_assoc_t))
3710	return -EINVAL;	3710	return -EINVAL;
3711		3711
3712	if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))	3712	if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
3713	return -EFAULT;	3713	return -EFAULT;
3714		3714
3715	/* For UDP-style sockets, id specifies the association to query. */	3715	/* For UDP-style sockets, id specifies the association to query. */
3716	asoc = sctp_id2assoc(sk, id);	3716	asoc = sctp_id2assoc(sk, id);
3717	if (!asoc)	3717	if (!asoc)
3718	return -EINVAL;	3718	return -EINVAL;
3719		3719
3720	list_for_each(pos, &asoc->peer.transport_addr_list) {	3720	list_for_each(pos, &asoc->peer.transport_addr_list) {
3721	cnt ++;	3721	cnt ++;
3722	}	3722	}
3723		3723
3724	return cnt;	3724	return cnt;
3725	}	3725	}
3726		3726
3727	/*	3727	/*
3728	* Old API for getting list of peer addresses. Does not work for 32-bit	3728	* Old API for getting list of peer addresses. Does not work for 32-bit
3729	* programs running on a 64-bit kernel	3729	* programs running on a 64-bit kernel
3730	*/	3730	*/
3731	static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len,	3731	static int sctp_getsockopt_peer_addrs_old(struct sock *sk, int len,
3732	char __user *optval,	3732	char __user *optval,
3733	int __user *optlen)	3733	int __user *optlen)
3734	{	3734	{
3735	struct sctp_association *asoc;	3735	struct sctp_association *asoc;
3736	struct list_head *pos;	3736	struct list_head *pos;
3737	int cnt = 0;	3737	int cnt = 0;
3738	struct sctp_getaddrs_old getaddrs;	3738	struct sctp_getaddrs_old getaddrs;
3739	struct sctp_transport *from;	3739	struct sctp_transport *from;
3740	void __user *to;	3740	void __user *to;
3741	union sctp_addr temp;	3741	union sctp_addr temp;
3742	struct sctp_sock *sp = sctp_sk(sk);	3742	struct sctp_sock *sp = sctp_sk(sk);
3743	int addrlen;	3743	int addrlen;
3744		3744
3745	if (len != sizeof(struct sctp_getaddrs_old))	3745	if (len != sizeof(struct sctp_getaddrs_old))
3746	return -EINVAL;	3746	return -EINVAL;
3747		3747
3748	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))	3748	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))
3749	return -EFAULT;	3749	return -EFAULT;
3750		3750
3751	if (getaddrs.addr_num <= 0) return -EINVAL;	3751	if (getaddrs.addr_num <= 0) return -EINVAL;
3752		3752
3753	/* For UDP-style sockets, id specifies the association to query. */	3753	/* For UDP-style sockets, id specifies the association to query. */
3754	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);	3754	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
3755	if (!asoc)	3755	if (!asoc)
3756	return -EINVAL;	3756	return -EINVAL;
3757		3757
3758	to = (void __user *)getaddrs.addrs;	3758	to = (void __user *)getaddrs.addrs;
3759	list_for_each(pos, &asoc->peer.transport_addr_list) {	3759	list_for_each(pos, &asoc->peer.transport_addr_list) {
3760	from = list_entry(pos, struct sctp_transport, transports);	3760	from = list_entry(pos, struct sctp_transport, transports);
3761	memcpy(&temp, &from->ipaddr, sizeof(temp));	3761	memcpy(&temp, &from->ipaddr, sizeof(temp));
3762	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);	3762	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
3763	addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;	3763	addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
3764	temp.v4.sin_port = htons(temp.v4.sin_port);	3764	temp.v4.sin_port = htons(temp.v4.sin_port);
3765	if (copy_to_user(to, &temp, addrlen))	3765	if (copy_to_user(to, &temp, addrlen))
3766	return -EFAULT;	3766	return -EFAULT;
3767	to += addrlen ;	3767	to += addrlen ;
3768	cnt ++;	3768	cnt ++;
3769	if (cnt >= getaddrs.addr_num) break;	3769	if (cnt >= getaddrs.addr_num) break;
3770	}	3770	}
3771	getaddrs.addr_num = cnt;	3771	getaddrs.addr_num = cnt;
3772	if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))	3772	if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))
3773	return -EFAULT;	3773	return -EFAULT;
3774		3774
3775	return 0;	3775	return 0;
3776	}	3776	}
3777		3777
3778	static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,	3778	static int sctp_getsockopt_peer_addrs(struct sock *sk, int len,
3779	char __user optval, int __user optlen)	3779	char __user optval, int __user optlen)
3780	{	3780	{
3781	struct sctp_association *asoc;	3781	struct sctp_association *asoc;
3782	struct list_head *pos;	3782	struct list_head *pos;
3783	int cnt = 0;	3783	int cnt = 0;
3784	struct sctp_getaddrs getaddrs;	3784	struct sctp_getaddrs getaddrs;
3785	struct sctp_transport *from;	3785	struct sctp_transport *from;
3786	void __user *to;	3786	void __user *to;
3787	union sctp_addr temp;	3787	union sctp_addr temp;
3788	struct sctp_sock *sp = sctp_sk(sk);	3788	struct sctp_sock *sp = sctp_sk(sk);
3789	int addrlen;	3789	int addrlen;
3790	size_t space_left;	3790	size_t space_left;
3791	int bytes_copied;	3791	int bytes_copied;
3792		3792
3793	if (len < sizeof(struct sctp_getaddrs))	3793	if (len < sizeof(struct sctp_getaddrs))
3794	return -EINVAL;	3794	return -EINVAL;
3795		3795
3796	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))	3796	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
3797	return -EFAULT;	3797	return -EFAULT;
3798		3798
3799	/* For UDP-style sockets, id specifies the association to query. */	3799	/* For UDP-style sockets, id specifies the association to query. */
3800	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);	3800	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
3801	if (!asoc)	3801	if (!asoc)
3802	return -EINVAL;	3802	return -EINVAL;
3803		3803
3804	to = optval + offsetof(struct sctp_getaddrs,addrs);	3804	to = optval + offsetof(struct sctp_getaddrs,addrs);
3805	space_left = len - sizeof(struct sctp_getaddrs) -	3805	space_left = len - sizeof(struct sctp_getaddrs) -
3806	offsetof(struct sctp_getaddrs,addrs);	3806	offsetof(struct sctp_getaddrs,addrs);
3807		3807
3808	list_for_each(pos, &asoc->peer.transport_addr_list) {	3808	list_for_each(pos, &asoc->peer.transport_addr_list) {
3809	from = list_entry(pos, struct sctp_transport, transports);	3809	from = list_entry(pos, struct sctp_transport, transports);
3810	memcpy(&temp, &from->ipaddr, sizeof(temp));	3810	memcpy(&temp, &from->ipaddr, sizeof(temp));
3811	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);	3811	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
3812	addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;	3812	addrlen = sctp_get_af_specific(sk->sk_family)->sockaddr_len;
3813	if(space_left < addrlen)	3813	if(space_left < addrlen)
3814	return -ENOMEM;	3814	return -ENOMEM;
3815	temp.v4.sin_port = htons(temp.v4.sin_port);	3815	temp.v4.sin_port = htons(temp.v4.sin_port);
3816	if (copy_to_user(to, &temp, addrlen))	3816	if (copy_to_user(to, &temp, addrlen))
3817	return -EFAULT;	3817	return -EFAULT;
3818	to += addrlen;	3818	to += addrlen;
3819	cnt++;	3819	cnt++;
3820	space_left -= addrlen;	3820	space_left -= addrlen;
3821	}	3821	}
3822		3822
3823	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))	3823	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
3824	return -EFAULT;	3824	return -EFAULT;
3825	bytes_copied = ((char __user *)to) - optval;	3825	bytes_copied = ((char __user *)to) - optval;
3826	if (put_user(bytes_copied, optlen))	3826	if (put_user(bytes_copied, optlen))
3827	return -EFAULT;	3827	return -EFAULT;
3828		3828
3829	return 0;	3829	return 0;
3830	}	3830	}
3831		3831
3832	static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len,	3832	static int sctp_getsockopt_local_addrs_num_old(struct sock *sk, int len,
3833	char __user *optval,	3833	char __user *optval,
3834	int __user *optlen)	3834	int __user *optlen)
3835	{	3835	{
3836	sctp_assoc_t id;	3836	sctp_assoc_t id;
3837	struct sctp_bind_addr *bp;	3837	struct sctp_bind_addr *bp;
3838	struct sctp_association *asoc;	3838	struct sctp_association *asoc;
3839	struct list_head *pos;	3839	struct list_head *pos;
3840	struct sctp_sockaddr_entry *addr;	3840	struct sctp_sockaddr_entry *addr;
3841	rwlock_t *addr_lock;	3841	rwlock_t *addr_lock;
3842	unsigned long flags;	3842	unsigned long flags;
3843	int cnt = 0;	3843	int cnt = 0;
3844		3844
3845	if (len != sizeof(sctp_assoc_t))	3845	if (len != sizeof(sctp_assoc_t))
3846	return -EINVAL;	3846	return -EINVAL;
3847		3847
3848	if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))	3848	if (copy_from_user(&id, optval, sizeof(sctp_assoc_t)))
3849	return -EFAULT;	3849	return -EFAULT;
3850		3850
3851	/*	3851	/*
3852	* For UDP-style sockets, id specifies the association to query.	3852	* For UDP-style sockets, id specifies the association to query.
3853	* If the id field is set to the value '0' then the locally bound	3853	* If the id field is set to the value '0' then the locally bound
3854	* addresses are returned without regard to any particular	3854	* addresses are returned without regard to any particular
3855	* association.	3855	* association.
3856	*/	3856	*/
3857	if (0 == id) {	3857	if (0 == id) {
3858	bp = &sctp_sk(sk)->ep->base.bind_addr;	3858	bp = &sctp_sk(sk)->ep->base.bind_addr;
3859	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;	3859	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
3860	} else {	3860	} else {
3861	asoc = sctp_id2assoc(sk, id);	3861	asoc = sctp_id2assoc(sk, id);
3862	if (!asoc)	3862	if (!asoc)
3863	return -EINVAL;	3863	return -EINVAL;
3864	bp = &asoc->base.bind_addr;	3864	bp = &asoc->base.bind_addr;
3865	addr_lock = &asoc->base.addr_lock;	3865	addr_lock = &asoc->base.addr_lock;
3866	}	3866	}
3867		3867
3868	sctp_read_lock(addr_lock);	3868	sctp_read_lock(addr_lock);
3869		3869
3870	/* If the endpoint is bound to 0.0.0.0 or ::0, count the valid	3870	/* If the endpoint is bound to 0.0.0.0 or ::0, count the valid
3871	* addresses from the global local address list.	3871	* addresses from the global local address list.
3872	*/	3872	*/
3873	if (sctp_list_single_entry(&bp->address_list)) {	3873	if (sctp_list_single_entry(&bp->address_list)) {
3874	addr = list_entry(bp->address_list.next,	3874	addr = list_entry(bp->address_list.next,
3875	struct sctp_sockaddr_entry, list);	3875	struct sctp_sockaddr_entry, list);
3876	if (sctp_is_any(&addr->a)) {	3876	if (sctp_is_any(&addr->a)) {
3877	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);	3877	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
3878	list_for_each(pos, &sctp_local_addr_list) {	3878	list_for_each(pos, &sctp_local_addr_list) {
3879	addr = list_entry(pos,	3879	addr = list_entry(pos,
3880	struct sctp_sockaddr_entry,	3880	struct sctp_sockaddr_entry,
3881	list);	3881	list);
3882	if ((PF_INET == sk->sk_family) &&	3882	if ((PF_INET == sk->sk_family) &&
3883	(AF_INET6 == addr->a.sa.sa_family))	3883	(AF_INET6 == addr->a.sa.sa_family))
3884	continue;	3884	continue;
3885	cnt++;	3885	cnt++;
3886	}	3886	}
3887	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,	3887	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
3888	flags);	3888	flags);
3889	} else {	3889	} else {
3890	cnt = 1;	3890	cnt = 1;
3891	}	3891	}
3892	goto done;	3892	goto done;
3893	}	3893	}
3894		3894
3895	list_for_each(pos, &bp->address_list) {	3895	list_for_each(pos, &bp->address_list) {
3896	cnt ++;	3896	cnt ++;
3897	}	3897	}
3898		3898
3899	done:	3899	done:
3900	sctp_read_unlock(addr_lock);	3900	sctp_read_unlock(addr_lock);
3901	return cnt;	3901	return cnt;
3902	}	3902	}
3903		3903
3904	/* Helper function that copies local addresses to user and returns the number	3904	/* Helper function that copies local addresses to user and returns the number
3905	* of addresses copied.	3905	* of addresses copied.
3906	*/	3906	*/
3907	static int sctp_copy_laddrs_to_user_old(struct sock *sk, __u16 port, int max_addrs,	3907	static int sctp_copy_laddrs_to_user_old(struct sock *sk, __u16 port, int max_addrs,
3908	void __user *to)	3908	void __user *to)
3909	{	3909	{
3910	struct list_head *pos;	3910	struct list_head *pos;
3911	struct sctp_sockaddr_entry *addr;	3911	struct sctp_sockaddr_entry *addr;
3912	unsigned long flags;	3912	unsigned long flags;
3913	union sctp_addr temp;	3913	union sctp_addr temp;
3914	int cnt = 0;	3914	int cnt = 0;
3915	int addrlen;	3915	int addrlen;
3916		3916
3917	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);	3917	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
3918	list_for_each(pos, &sctp_local_addr_list) {	3918	list_for_each(pos, &sctp_local_addr_list) {
3919	addr = list_entry(pos, struct sctp_sockaddr_entry, list);	3919	addr = list_entry(pos, struct sctp_sockaddr_entry, list);
3920	if ((PF_INET == sk->sk_family) &&	3920	if ((PF_INET == sk->sk_family) &&
3921	(AF_INET6 == addr->a.sa.sa_family))	3921	(AF_INET6 == addr->a.sa.sa_family))
3922	continue;	3922	continue;
3923	memcpy(&temp, &addr->a, sizeof(temp));	3923	memcpy(&temp, &addr->a, sizeof(temp));
3924	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),	3924	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
3925	&temp);	3925	&temp);
3926	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;	3926	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
3927	temp.v4.sin_port = htons(port);	3927	temp.v4.sin_port = htons(port);
3928	if (copy_to_user(to, &temp, addrlen)) {	3928	if (copy_to_user(to, &temp, addrlen)) {
3929	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,	3929	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
3930	flags);	3930	flags);
3931	return -EFAULT;	3931	return -EFAULT;
3932	}	3932	}
3933	to += addrlen;	3933	to += addrlen;
3934	cnt ++;	3934	cnt ++;
3935	if (cnt >= max_addrs) break;	3935	if (cnt >= max_addrs) break;
3936	}	3936	}
3937	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);	3937	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
3938		3938
3939	return cnt;	3939	return cnt;
3940	}	3940	}
3941		3941
3942	static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port,	3942	static int sctp_copy_laddrs_to_user(struct sock *sk, __u16 port,
3943	void __user **to, size_t space_left)	3943	void __user **to, size_t space_left)
3944	{	3944	{
3945	struct list_head *pos;	3945	struct list_head *pos;
3946	struct sctp_sockaddr_entry *addr;	3946	struct sctp_sockaddr_entry *addr;
3947	unsigned long flags;	3947	unsigned long flags;
3948	union sctp_addr temp;	3948	union sctp_addr temp;
3949	int cnt = 0;	3949	int cnt = 0;
3950	int addrlen;	3950	int addrlen;
3951		3951
3952	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);	3952	sctp_spin_lock_irqsave(&sctp_local_addr_lock, flags);
3953	list_for_each(pos, &sctp_local_addr_list) {	3953	list_for_each(pos, &sctp_local_addr_list) {
3954	addr = list_entry(pos, struct sctp_sockaddr_entry, list);	3954	addr = list_entry(pos, struct sctp_sockaddr_entry, list);
3955	if ((PF_INET == sk->sk_family) &&	3955	if ((PF_INET == sk->sk_family) &&
3956	(AF_INET6 == addr->a.sa.sa_family))	3956	(AF_INET6 == addr->a.sa.sa_family))
3957	continue;	3957	continue;
3958	memcpy(&temp, &addr->a, sizeof(temp));	3958	memcpy(&temp, &addr->a, sizeof(temp));
3959	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),	3959	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sctp_sk(sk),
3960	&temp);	3960	&temp);
3961	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;	3961	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
3962	if(space_left<addrlen)	3962	if(space_left<addrlen)
3963	return -ENOMEM;	3963	return -ENOMEM;
3964	temp.v4.sin_port = htons(port);	3964	temp.v4.sin_port = htons(port);
3965	if (copy_to_user(*to, &temp, addrlen)) {	3965	if (copy_to_user(*to, &temp, addrlen)) {
3966	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,	3966	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock,
3967	flags);	3967	flags);
3968	return -EFAULT;	3968	return -EFAULT;
3969	}	3969	}
3970	*to += addrlen;	3970	*to += addrlen;
3971	cnt ++;	3971	cnt ++;
3972	space_left -= addrlen;	3972	space_left -= addrlen;
3973	}	3973	}
3974	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);	3974	sctp_spin_unlock_irqrestore(&sctp_local_addr_lock, flags);
3975		3975
3976	return cnt;	3976	return cnt;
3977	}	3977	}
3978		3978
3979	/* Old API for getting list of local addresses. Does not work for 32-bit	3979	/* Old API for getting list of local addresses. Does not work for 32-bit
3980	* programs running on a 64-bit kernel	3980	* programs running on a 64-bit kernel
3981	*/	3981	*/
3982	static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len,	3982	static int sctp_getsockopt_local_addrs_old(struct sock *sk, int len,
3983	char __user optval, int __user optlen)	3983	char __user optval, int __user optlen)
3984	{	3984	{
3985	struct sctp_bind_addr *bp;	3985	struct sctp_bind_addr *bp;
3986	struct sctp_association *asoc;	3986	struct sctp_association *asoc;
3987	struct list_head *pos;	3987	struct list_head *pos;
3988	int cnt = 0;	3988	int cnt = 0;
3989	struct sctp_getaddrs_old getaddrs;	3989	struct sctp_getaddrs_old getaddrs;
3990	struct sctp_sockaddr_entry *addr;	3990	struct sctp_sockaddr_entry *addr;
3991	void __user *to;	3991	void __user *to;
3992	union sctp_addr temp;	3992	union sctp_addr temp;
3993	struct sctp_sock *sp = sctp_sk(sk);	3993	struct sctp_sock *sp = sctp_sk(sk);
3994	int addrlen;	3994	int addrlen;
3995	rwlock_t *addr_lock;	3995	rwlock_t *addr_lock;
3996	int err = 0;	3996	int err = 0;
3997		3997
3998	if (len != sizeof(struct sctp_getaddrs_old))	3998	if (len != sizeof(struct sctp_getaddrs_old))
3999	return -EINVAL;	3999	return -EINVAL;
4000		4000
4001	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))	4001	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs_old)))
4002	return -EFAULT;	4002	return -EFAULT;
4003		4003
4004	if (getaddrs.addr_num <= 0) return -EINVAL;	4004	if (getaddrs.addr_num <= 0) return -EINVAL;
4005	/*	4005	/*
4006	* For UDP-style sockets, id specifies the association to query.	4006	* For UDP-style sockets, id specifies the association to query.
4007	* If the id field is set to the value '0' then the locally bound	4007	* If the id field is set to the value '0' then the locally bound
4008	* addresses are returned without regard to any particular	4008	* addresses are returned without regard to any particular
4009	* association.	4009	* association.
4010	*/	4010	*/
4011	if (0 == getaddrs.assoc_id) {	4011	if (0 == getaddrs.assoc_id) {
4012	bp = &sctp_sk(sk)->ep->base.bind_addr;	4012	bp = &sctp_sk(sk)->ep->base.bind_addr;
4013	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;	4013	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
4014	} else {	4014	} else {
4015	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);	4015	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4016	if (!asoc)	4016	if (!asoc)
4017	return -EINVAL;	4017	return -EINVAL;
4018	bp = &asoc->base.bind_addr;	4018	bp = &asoc->base.bind_addr;
4019	addr_lock = &asoc->base.addr_lock;	4019	addr_lock = &asoc->base.addr_lock;
4020	}	4020	}
4021		4021
4022	to = getaddrs.addrs;	4022	to = getaddrs.addrs;
4023		4023
4024	sctp_read_lock(addr_lock);	4024	sctp_read_lock(addr_lock);
4025		4025
4026	/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid	4026	/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4027	* addresses from the global local address list.	4027	* addresses from the global local address list.
4028	*/	4028	*/
4029	if (sctp_list_single_entry(&bp->address_list)) {	4029	if (sctp_list_single_entry(&bp->address_list)) {
4030	addr = list_entry(bp->address_list.next,	4030	addr = list_entry(bp->address_list.next,
4031	struct sctp_sockaddr_entry, list);	4031	struct sctp_sockaddr_entry, list);
4032	if (sctp_is_any(&addr->a)) {	4032	if (sctp_is_any(&addr->a)) {
4033	cnt = sctp_copy_laddrs_to_user_old(sk, bp->port,	4033	cnt = sctp_copy_laddrs_to_user_old(sk, bp->port,
4034	getaddrs.addr_num,	4034	getaddrs.addr_num,
4035	to);	4035	to);
4036	if (cnt < 0) {	4036	if (cnt < 0) {
4037	err = cnt;	4037	err = cnt;
4038	goto unlock;	4038	goto unlock;
4039	}	4039	}
4040	goto copy_getaddrs;	4040	goto copy_getaddrs;
4041	}	4041	}
4042	}	4042	}
4043		4043
4044	list_for_each(pos, &bp->address_list) {	4044	list_for_each(pos, &bp->address_list) {
4045	addr = list_entry(pos, struct sctp_sockaddr_entry, list);	4045	addr = list_entry(pos, struct sctp_sockaddr_entry, list);
4046	memcpy(&temp, &addr->a, sizeof(temp));	4046	memcpy(&temp, &addr->a, sizeof(temp));
4047	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);	4047	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
4048	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;	4048	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
4049	temp.v4.sin_port = htons(temp.v4.sin_port);	4049	temp.v4.sin_port = htons(temp.v4.sin_port);
4050	if (copy_to_user(to, &temp, addrlen)) {	4050	if (copy_to_user(to, &temp, addrlen)) {
4051	err = -EFAULT;	4051	err = -EFAULT;
4052	goto unlock;	4052	goto unlock;
4053	}	4053	}
4054	to += addrlen;	4054	to += addrlen;
4055	cnt ++;	4055	cnt ++;
4056	if (cnt >= getaddrs.addr_num) break;	4056	if (cnt >= getaddrs.addr_num) break;
4057	}	4057	}
4058		4058
4059	copy_getaddrs:	4059	copy_getaddrs:
4060	getaddrs.addr_num = cnt;	4060	getaddrs.addr_num = cnt;
4061	if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))	4061	if (copy_to_user(optval, &getaddrs, sizeof(struct sctp_getaddrs_old)))
4062	err = -EFAULT;	4062	err = -EFAULT;
4063		4063
4064	unlock:	4064	unlock:
4065	sctp_read_unlock(addr_lock);	4065	sctp_read_unlock(addr_lock);
4066	return err;	4066	return err;
4067	}	4067	}
4068		4068
4069	static int sctp_getsockopt_local_addrs(struct sock *sk, int len,	4069	static int sctp_getsockopt_local_addrs(struct sock *sk, int len,
4070	char __user optval, int __user optlen)	4070	char __user optval, int __user optlen)
4071	{	4071	{
4072	struct sctp_bind_addr *bp;	4072	struct sctp_bind_addr *bp;
4073	struct sctp_association *asoc;	4073	struct sctp_association *asoc;
4074	struct list_head *pos;	4074	struct list_head *pos;
4075	int cnt = 0;	4075	int cnt = 0;
4076	struct sctp_getaddrs getaddrs;	4076	struct sctp_getaddrs getaddrs;
4077	struct sctp_sockaddr_entry *addr;	4077	struct sctp_sockaddr_entry *addr;
4078	void __user *to;	4078	void __user *to;
4079	union sctp_addr temp;	4079	union sctp_addr temp;
4080	struct sctp_sock *sp = sctp_sk(sk);	4080	struct sctp_sock *sp = sctp_sk(sk);
4081	int addrlen;	4081	int addrlen;
4082	rwlock_t *addr_lock;	4082	rwlock_t *addr_lock;
4083	int err = 0;	4083	int err = 0;
4084	size_t space_left;	4084	size_t space_left;
4085	int bytes_copied;	4085	int bytes_copied;
4086		4086
4087	if (len <= sizeof(struct sctp_getaddrs))	4087	if (len <= sizeof(struct sctp_getaddrs))
4088	return -EINVAL;	4088	return -EINVAL;
4089		4089
4090	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))	4090	if (copy_from_user(&getaddrs, optval, sizeof(struct sctp_getaddrs)))
4091	return -EFAULT;	4091	return -EFAULT;
4092		4092
4093	/*	4093	/*
4094	* For UDP-style sockets, id specifies the association to query.	4094	* For UDP-style sockets, id specifies the association to query.
4095	* If the id field is set to the value '0' then the locally bound	4095	* If the id field is set to the value '0' then the locally bound
4096	* addresses are returned without regard to any particular	4096	* addresses are returned without regard to any particular
4097	* association.	4097	* association.
4098	*/	4098	*/
4099	if (0 == getaddrs.assoc_id) {	4099	if (0 == getaddrs.assoc_id) {
4100	bp = &sctp_sk(sk)->ep->base.bind_addr;	4100	bp = &sctp_sk(sk)->ep->base.bind_addr;
4101	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;	4101	addr_lock = &sctp_sk(sk)->ep->base.addr_lock;
4102	} else {	4102	} else {
4103	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);	4103	asoc = sctp_id2assoc(sk, getaddrs.assoc_id);
4104	if (!asoc)	4104	if (!asoc)
4105	return -EINVAL;	4105	return -EINVAL;
4106	bp = &asoc->base.bind_addr;	4106	bp = &asoc->base.bind_addr;
4107	addr_lock = &asoc->base.addr_lock;	4107	addr_lock = &asoc->base.addr_lock;
4108	}	4108	}
4109		4109
4110	to = optval + offsetof(struct sctp_getaddrs,addrs);	4110	to = optval + offsetof(struct sctp_getaddrs,addrs);
4111	space_left = len - sizeof(struct sctp_getaddrs) -	4111	space_left = len - sizeof(struct sctp_getaddrs) -
4112	offsetof(struct sctp_getaddrs,addrs);	4112	offsetof(struct sctp_getaddrs,addrs);
4113		4113
4114	sctp_read_lock(addr_lock);	4114	sctp_read_lock(addr_lock);
4115		4115
4116	/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid	4116	/* If the endpoint is bound to 0.0.0.0 or ::0, get the valid
4117	* addresses from the global local address list.	4117	* addresses from the global local address list.
4118	*/	4118	*/
4119	if (sctp_list_single_entry(&bp->address_list)) {	4119	if (sctp_list_single_entry(&bp->address_list)) {
4120	addr = list_entry(bp->address_list.next,	4120	addr = list_entry(bp->address_list.next,
4121	struct sctp_sockaddr_entry, list);	4121	struct sctp_sockaddr_entry, list);
4122	if (sctp_is_any(&addr->a)) {	4122	if (sctp_is_any(&addr->a)) {
4123	cnt = sctp_copy_laddrs_to_user(sk, bp->port,	4123	cnt = sctp_copy_laddrs_to_user(sk, bp->port,
4124	&to, space_left);	4124	&to, space_left);
4125	if (cnt < 0) {	4125	if (cnt < 0) {
4126	err = cnt;	4126	err = cnt;
4127	goto unlock;	4127	goto unlock;
4128	}	4128	}
4129	goto copy_getaddrs;	4129	goto copy_getaddrs;
4130	}	4130	}
4131	}	4131	}
4132		4132
4133	list_for_each(pos, &bp->address_list) {	4133	list_for_each(pos, &bp->address_list) {
4134	addr = list_entry(pos, struct sctp_sockaddr_entry, list);	4134	addr = list_entry(pos, struct sctp_sockaddr_entry, list);
4135	memcpy(&temp, &addr->a, sizeof(temp));	4135	memcpy(&temp, &addr->a, sizeof(temp));
4136	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);	4136	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp, &temp);
4137	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;	4137	addrlen = sctp_get_af_specific(temp.sa.sa_family)->sockaddr_len;
4138	if(space_left < addrlen)	4138	if(space_left < addrlen)
4139	return -ENOMEM; /fixme: right error?/	4139	return -ENOMEM; /fixme: right error?/
4140	temp.v4.sin_port = htons(temp.v4.sin_port);	4140	temp.v4.sin_port = htons(temp.v4.sin_port);
4141	if (copy_to_user(to, &temp, addrlen)) {	4141	if (copy_to_user(to, &temp, addrlen)) {
4142	err = -EFAULT;	4142	err = -EFAULT;
4143	goto unlock;	4143	goto unlock;
4144	}	4144	}
4145	to += addrlen;	4145	to += addrlen;
4146	cnt ++;	4146	cnt ++;
4147	space_left -= addrlen;	4147	space_left -= addrlen;
4148	}	4148	}
4149		4149
4150	copy_getaddrs:	4150	copy_getaddrs:
4151	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))	4151	if (put_user(cnt, &((struct sctp_getaddrs __user *)optval)->addr_num))
4152	return -EFAULT;	4152	return -EFAULT;
4153	bytes_copied = ((char __user *)to) - optval;	4153	bytes_copied = ((char __user *)to) - optval;
4154	if (put_user(bytes_copied, optlen))	4154	if (put_user(bytes_copied, optlen))
4155	return -EFAULT;	4155	return -EFAULT;
4156		4156
4157	unlock:	4157	unlock:
4158	sctp_read_unlock(addr_lock);	4158	sctp_read_unlock(addr_lock);
4159	return err;	4159	return err;
4160	}	4160	}
4161		4161
4162	/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)	4162	/* 7.1.10 Set Primary Address (SCTP_PRIMARY_ADDR)
4163	*	4163	*
4164	* Requests that the local SCTP stack use the enclosed peer address as	4164	* Requests that the local SCTP stack use the enclosed peer address as
4165	* the association primary. The enclosed address must be one of the	4165	* the association primary. The enclosed address must be one of the
4166	* association peer's addresses.	4166	* association peer's addresses.
4167	*/	4167	*/
4168	static int sctp_getsockopt_primary_addr(struct sock *sk, int len,	4168	static int sctp_getsockopt_primary_addr(struct sock *sk, int len,
4169	char __user optval, int __user optlen)	4169	char __user optval, int __user optlen)
4170	{	4170	{
4171	struct sctp_prim prim;	4171	struct sctp_prim prim;
4172	struct sctp_association *asoc;	4172	struct sctp_association *asoc;
4173	struct sctp_sock *sp = sctp_sk(sk);	4173	struct sctp_sock *sp = sctp_sk(sk);
4174		4174
4175	if (len != sizeof(struct sctp_prim))	4175	if (len != sizeof(struct sctp_prim))
4176	return -EINVAL;	4176	return -EINVAL;
4177		4177
4178	if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))	4178	if (copy_from_user(&prim, optval, sizeof(struct sctp_prim)))
4179	return -EFAULT;	4179	return -EFAULT;
4180		4180
4181	asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);	4181	asoc = sctp_id2assoc(sk, prim.ssp_assoc_id);
4182	if (!asoc)	4182	if (!asoc)
4183	return -EINVAL;	4183	return -EINVAL;
4184		4184
4185	if (!asoc->peer.primary_path)	4185	if (!asoc->peer.primary_path)
4186	return -ENOTCONN;	4186	return -ENOTCONN;
4187		4187
4188	asoc->peer.primary_path->ipaddr.v4.sin_port =	4188	asoc->peer.primary_path->ipaddr.v4.sin_port =
4189	htons(asoc->peer.primary_path->ipaddr.v4.sin_port);	4189	htons(asoc->peer.primary_path->ipaddr.v4.sin_port);
4190	memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,	4190	memcpy(&prim.ssp_addr, &asoc->peer.primary_path->ipaddr,
4191	sizeof(union sctp_addr));	4191	sizeof(union sctp_addr));
4192	asoc->peer.primary_path->ipaddr.v4.sin_port =	4192	asoc->peer.primary_path->ipaddr.v4.sin_port =
4193	ntohs(asoc->peer.primary_path->ipaddr.v4.sin_port);	4193	ntohs(asoc->peer.primary_path->ipaddr.v4.sin_port);
4194		4194
4195	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp,	4195	sctp_get_pf_specific(sk->sk_family)->addr_v4map(sp,
4196	(union sctp_addr *)&prim.ssp_addr);	4196	(union sctp_addr *)&prim.ssp_addr);
4197		4197
4198	if (copy_to_user(optval, &prim, sizeof(struct sctp_prim)))	4198	if (copy_to_user(optval, &prim, sizeof(struct sctp_prim)))
4199	return -EFAULT;	4199	return -EFAULT;
4200		4200
4201	return 0;	4201	return 0;
4202	}	4202	}
4203		4203
4204	/*	4204	/*
4205	* 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)	4205	* 7.1.11 Set Adaption Layer Indicator (SCTP_ADAPTION_LAYER)
4206	*	4206	*
4207	* Requests that the local endpoint set the specified Adaption Layer	4207	* Requests that the local endpoint set the specified Adaption Layer
4208	* Indication parameter for all future INIT and INIT-ACK exchanges.	4208	* Indication parameter for all future INIT and INIT-ACK exchanges.
4209	*/	4209	*/
4210	static int sctp_getsockopt_adaption_layer(struct sock *sk, int len,	4210	static int sctp_getsockopt_adaption_layer(struct sock *sk, int len,
4211	char __user optval, int __user optlen)	4211	char __user optval, int __user optlen)
4212	{	4212	{
4213	struct sctp_setadaption adaption;	4213	struct sctp_setadaption adaption;
4214		4214
4215	if (len != sizeof(struct sctp_setadaption))	4215	if (len != sizeof(struct sctp_setadaption))
4216	return -EINVAL;	4216	return -EINVAL;
4217		4217
4218	adaption.ssb_adaption_ind = sctp_sk(sk)->adaption_ind;	4218	adaption.ssb_adaption_ind = sctp_sk(sk)->adaption_ind;
4219	if (copy_to_user(optval, &adaption, len))	4219	if (copy_to_user(optval, &adaption, len))
4220	return -EFAULT;	4220	return -EFAULT;
4221		4221
4222	return 0;	4222	return 0;
4223	}	4223	}
4224		4224
4225	/*	4225	/*
4226	*	4226	*
4227	* 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)	4227	* 7.1.14 Set default send parameters (SCTP_DEFAULT_SEND_PARAM)
4228	*	4228	*
4229	* Applications that wish to use the sendto() system call may wish to	4229	* Applications that wish to use the sendto() system call may wish to
4230	* specify a default set of parameters that would normally be supplied	4230	* specify a default set of parameters that would normally be supplied
4231	* through the inclusion of ancillary data. This socket option allows	4231	* through the inclusion of ancillary data. This socket option allows
4232	* such an application to set the default sctp_sndrcvinfo structure.	4232	* such an application to set the default sctp_sndrcvinfo structure.
4233		4233
4234		4234
4235	* The application that wishes to use this socket option simply passes	4235	* The application that wishes to use this socket option simply passes
4236	* in to this call the sctp_sndrcvinfo structure defined in Section	4236	* in to this call the sctp_sndrcvinfo structure defined in Section
4237	* 5.2.2) The input parameters accepted by this call include	4237	* 5.2.2) The input parameters accepted by this call include
4238	* sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,	4238	* sinfo_stream, sinfo_flags, sinfo_ppid, sinfo_context,
4239	* sinfo_timetolive. The user must provide the sinfo_assoc_id field in	4239	* sinfo_timetolive. The user must provide the sinfo_assoc_id field in
4240	* to this call if the caller is using the UDP model.	4240	* to this call if the caller is using the UDP model.
4241	*	4241	*
4242	* For getsockopt, it get the default sctp_sndrcvinfo structure.	4242	* For getsockopt, it get the default sctp_sndrcvinfo structure.
4243	*/	4243	*/
4244	static int sctp_getsockopt_default_send_param(struct sock *sk,	4244	static int sctp_getsockopt_default_send_param(struct sock *sk,
4245	int len, char __user *optval,	4245	int len, char __user *optval,
4246	int __user *optlen)	4246	int __user *optlen)
4247	{	4247	{
4248	struct sctp_sndrcvinfo info;	4248	struct sctp_sndrcvinfo info;
4249	struct sctp_association *asoc;	4249	struct sctp_association *asoc;
4250	struct sctp_sock *sp = sctp_sk(sk);	4250	struct sctp_sock *sp = sctp_sk(sk);
4251		4251
4252	if (len != sizeof(struct sctp_sndrcvinfo))	4252	if (len != sizeof(struct sctp_sndrcvinfo))
4253	return -EINVAL;	4253	return -EINVAL;
4254	if (copy_from_user(&info, optval, sizeof(struct sctp_sndrcvinfo)))	4254	if (copy_from_user(&info, optval, sizeof(struct sctp_sndrcvinfo)))
4255	return -EFAULT;	4255	return -EFAULT;
4256		4256
4257	asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);	4257	asoc = sctp_id2assoc(sk, info.sinfo_assoc_id);
4258	if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))	4258	if (!asoc && info.sinfo_assoc_id && sctp_style(sk, UDP))
4259	return -EINVAL;	4259	return -EINVAL;
4260		4260
4261	if (asoc) {	4261	if (asoc) {
4262	info.sinfo_stream = asoc->default_stream;	4262	info.sinfo_stream = asoc->default_stream;
4263	info.sinfo_flags = asoc->default_flags;	4263	info.sinfo_flags = asoc->default_flags;
4264	info.sinfo_ppid = asoc->default_ppid;	4264	info.sinfo_ppid = asoc->default_ppid;
4265	info.sinfo_context = asoc->default_context;	4265	info.sinfo_context = asoc->default_context;
4266	info.sinfo_timetolive = asoc->default_timetolive;	4266	info.sinfo_timetolive = asoc->default_timetolive;
4267	} else {	4267	} else {
4268	info.sinfo_stream = sp->default_stream;	4268	info.sinfo_stream = sp->default_stream;
4269	info.sinfo_flags = sp->default_flags;	4269	info.sinfo_flags = sp->default_flags;
4270	info.sinfo_ppid = sp->default_ppid;	4270	info.sinfo_ppid = sp->default_ppid;
4271	info.sinfo_context = sp->default_context;	4271	info.sinfo_context = sp->default_context;
4272	info.sinfo_timetolive = sp->default_timetolive;	4272	info.sinfo_timetolive = sp->default_timetolive;
4273	}	4273	}
4274		4274
4275	if (copy_to_user(optval, &info, sizeof(struct sctp_sndrcvinfo)))	4275	if (copy_to_user(optval, &info, sizeof(struct sctp_sndrcvinfo)))
4276	return -EFAULT;	4276	return -EFAULT;
4277		4277
4278	return 0;	4278	return 0;
4279	}	4279	}
4280		4280
4281	/*	4281	/*
4282	*	4282	*
4283	* 7.1.5 SCTP_NODELAY	4283	* 7.1.5 SCTP_NODELAY
4284	*	4284	*
4285	* Turn on/off any Nagle-like algorithm. This means that packets are	4285	* Turn on/off any Nagle-like algorithm. This means that packets are
4286	* generally sent as soon as possible and no unnecessary delays are	4286	* generally sent as soon as possible and no unnecessary delays are
4287	* introduced, at the cost of more packets in the network. Expects an	4287	* introduced, at the cost of more packets in the network. Expects an
4288	* integer boolean flag.	4288	* integer boolean flag.
4289	*/	4289	*/
4290		4290
4291	static int sctp_getsockopt_nodelay(struct sock *sk, int len,	4291	static int sctp_getsockopt_nodelay(struct sock *sk, int len,
4292	char __user optval, int __user optlen)	4292	char __user optval, int __user optlen)
4293	{	4293	{
4294	int val;	4294	int val;
4295		4295
4296	if (len < sizeof(int))	4296	if (len < sizeof(int))
4297	return -EINVAL;	4297	return -EINVAL;
4298		4298
4299	len = sizeof(int);	4299	len = sizeof(int);
4300	val = (sctp_sk(sk)->nodelay == 1);	4300	val = (sctp_sk(sk)->nodelay == 1);
4301	if (put_user(len, optlen))	4301	if (put_user(len, optlen))
4302	return -EFAULT;	4302	return -EFAULT;
4303	if (copy_to_user(optval, &val, len))	4303	if (copy_to_user(optval, &val, len))
4304	return -EFAULT;	4304	return -EFAULT;
4305	return 0;	4305	return 0;
4306	}	4306	}
4307		4307
4308	/*	4308	/*
4309	*	4309	*
4310	* 7.1.1 SCTP_RTOINFO	4310	* 7.1.1 SCTP_RTOINFO
4311	*	4311	*
4312	* The protocol parameters used to initialize and bound retransmission	4312	* The protocol parameters used to initialize and bound retransmission
4313	* timeout (RTO) are tunable. sctp_rtoinfo structure is used to access	4313	* timeout (RTO) are tunable. sctp_rtoinfo structure is used to access
4314	* and modify these parameters.	4314	* and modify these parameters.
4315	* All parameters are time values, in milliseconds. A value of 0, when	4315	* All parameters are time values, in milliseconds. A value of 0, when
4316	* modifying the parameters, indicates that the current value should not	4316	* modifying the parameters, indicates that the current value should not
4317	* be changed.	4317	* be changed.
4318	*	4318	*
4319	*/	4319	*/
4320	static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,	4320	static int sctp_getsockopt_rtoinfo(struct sock *sk, int len,
4321	char __user *optval,	4321	char __user *optval,
4322	int __user *optlen) {	4322	int __user *optlen) {
4323	struct sctp_rtoinfo rtoinfo;	4323	struct sctp_rtoinfo rtoinfo;
4324	struct sctp_association *asoc;	4324	struct sctp_association *asoc;
4325		4325
4326	if (len != sizeof (struct sctp_rtoinfo))	4326	if (len != sizeof (struct sctp_rtoinfo))
4327	return -EINVAL;	4327	return -EINVAL;
4328		4328
4329	if (copy_from_user(&rtoinfo, optval, sizeof (struct sctp_rtoinfo)))	4329	if (copy_from_user(&rtoinfo, optval, sizeof (struct sctp_rtoinfo)))
4330	return -EFAULT;	4330	return -EFAULT;
4331		4331
4332	asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);	4332	asoc = sctp_id2assoc(sk, rtoinfo.srto_assoc_id);
4333		4333
4334	if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))	4334	if (!asoc && rtoinfo.srto_assoc_id && sctp_style(sk, UDP))
4335	return -EINVAL;	4335	return -EINVAL;
4336		4336
4337	/* Values corresponding to the specific association. */	4337	/* Values corresponding to the specific association. */
4338	if (asoc) {	4338	if (asoc) {
4339	rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);	4339	rtoinfo.srto_initial = jiffies_to_msecs(asoc->rto_initial);
4340	rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);	4340	rtoinfo.srto_max = jiffies_to_msecs(asoc->rto_max);
4341	rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);	4341	rtoinfo.srto_min = jiffies_to_msecs(asoc->rto_min);
4342	} else {	4342	} else {
4343	/* Values corresponding to the endpoint. */	4343	/* Values corresponding to the endpoint. */
4344	struct sctp_sock *sp = sctp_sk(sk);	4344	struct sctp_sock *sp = sctp_sk(sk);
4345		4345
4346	rtoinfo.srto_initial = sp->rtoinfo.srto_initial;	4346	rtoinfo.srto_initial = sp->rtoinfo.srto_initial;
4347	rtoinfo.srto_max = sp->rtoinfo.srto_max;	4347	rtoinfo.srto_max = sp->rtoinfo.srto_max;
4348	rtoinfo.srto_min = sp->rtoinfo.srto_min;	4348	rtoinfo.srto_min = sp->rtoinfo.srto_min;
4349	}	4349	}
4350		4350
4351	if (put_user(len, optlen))	4351	if (put_user(len, optlen))
4352	return -EFAULT;	4352	return -EFAULT;
4353		4353
4354	if (copy_to_user(optval, &rtoinfo, len))	4354	if (copy_to_user(optval, &rtoinfo, len))
4355	return -EFAULT;	4355	return -EFAULT;
4356		4356
4357	return 0;	4357	return 0;
4358	}	4358	}
4359		4359
4360	/*	4360	/*
4361	*	4361	*
4362	* 7.1.2 SCTP_ASSOCINFO	4362	* 7.1.2 SCTP_ASSOCINFO
4363	*	4363	*
4364	* This option is used to tune the the maximum retransmission attempts	4364	* This option is used to tune the the maximum retransmission attempts
4365	* of the association.	4365	* of the association.
4366	* Returns an error if the new association retransmission value is	4366	* Returns an error if the new association retransmission value is
4367	* greater than the sum of the retransmission value of the peer.	4367	* greater than the sum of the retransmission value of the peer.
4368	* See [SCTP] for more information.	4368	* See [SCTP] for more information.
4369	*	4369	*
4370	*/	4370	*/
4371	static int sctp_getsockopt_associnfo(struct sock *sk, int len,	4371	static int sctp_getsockopt_associnfo(struct sock *sk, int len,
4372	char __user *optval,	4372	char __user *optval,
4373	int __user *optlen)	4373	int __user *optlen)
4374	{	4374	{
4375		4375
4376	struct sctp_assocparams assocparams;	4376	struct sctp_assocparams assocparams;
4377	struct sctp_association *asoc;	4377	struct sctp_association *asoc;
4378	struct list_head *pos;	4378	struct list_head *pos;
4379	int cnt = 0;	4379	int cnt = 0;
4380		4380
4381	if (len != sizeof (struct sctp_assocparams))	4381	if (len != sizeof (struct sctp_assocparams))
4382	return -EINVAL;	4382	return -EINVAL;
4383		4383
4384	if (copy_from_user(&assocparams, optval,	4384	if (copy_from_user(&assocparams, optval,
4385	sizeof (struct sctp_assocparams)))	4385	sizeof (struct sctp_assocparams)))
4386	return -EFAULT;	4386	return -EFAULT;
4387		4387
4388	asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);	4388	asoc = sctp_id2assoc(sk, assocparams.sasoc_assoc_id);
4389		4389
4390	if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))	4390	if (!asoc && assocparams.sasoc_assoc_id && sctp_style(sk, UDP))
4391	return -EINVAL;	4391	return -EINVAL;
4392		4392
4393	/* Values correspoinding to the specific association */	4393	/* Values correspoinding to the specific association */
4394	if (asoc) {	4394	if (asoc) {
4395	assocparams.sasoc_asocmaxrxt = asoc->max_retrans;	4395	assocparams.sasoc_asocmaxrxt = asoc->max_retrans;
4396	assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;	4396	assocparams.sasoc_peer_rwnd = asoc->peer.rwnd;
4397	assocparams.sasoc_local_rwnd = asoc->a_rwnd;	4397	assocparams.sasoc_local_rwnd = asoc->a_rwnd;
4398	assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec	4398	assocparams.sasoc_cookie_life = (asoc->cookie_life.tv_sec
4399	* 1000) +	4399	* 1000) +
4400	(asoc->cookie_life.tv_usec	4400	(asoc->cookie_life.tv_usec
4401	/ 1000);	4401	/ 1000);
4402		4402
4403	list_for_each(pos, &asoc->peer.transport_addr_list) {	4403	list_for_each(pos, &asoc->peer.transport_addr_list) {
4404	cnt ++;	4404	cnt ++;
4405	}	4405	}
4406		4406
4407	assocparams.sasoc_number_peer_destinations = cnt;	4407	assocparams.sasoc_number_peer_destinations = cnt;
4408	} else {	4408	} else {
4409	/* Values corresponding to the endpoint */	4409	/* Values corresponding to the endpoint */
4410	struct sctp_sock *sp = sctp_sk(sk);	4410	struct sctp_sock *sp = sctp_sk(sk);
4411		4411
4412	assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;	4412	assocparams.sasoc_asocmaxrxt = sp->assocparams.sasoc_asocmaxrxt;
4413	assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;	4413	assocparams.sasoc_peer_rwnd = sp->assocparams.sasoc_peer_rwnd;
4414	assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;	4414	assocparams.sasoc_local_rwnd = sp->assocparams.sasoc_local_rwnd;
4415	assocparams.sasoc_cookie_life =	4415	assocparams.sasoc_cookie_life =
4416	sp->assocparams.sasoc_cookie_life;	4416	sp->assocparams.sasoc_cookie_life;
4417	assocparams.sasoc_number_peer_destinations =	4417	assocparams.sasoc_number_peer_destinations =
4418	sp->assocparams.	4418	sp->assocparams.
4419	sasoc_number_peer_destinations;	4419	sasoc_number_peer_destinations;
4420	}	4420	}
4421		4421
4422	if (put_user(len, optlen))	4422	if (put_user(len, optlen))
4423	return -EFAULT;	4423	return -EFAULT;
4424		4424
4425	if (copy_to_user(optval, &assocparams, len))	4425	if (copy_to_user(optval, &assocparams, len))
4426	return -EFAULT;	4426	return -EFAULT;
4427		4427
4428	return 0;	4428	return 0;
4429	}	4429	}
4430		4430
4431	/*	4431	/*
4432	* 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)	4432	* 7.1.16 Set/clear IPv4 mapped addresses (SCTP_I_WANT_MAPPED_V4_ADDR)
4433	*	4433	*
4434	* This socket option is a boolean flag which turns on or off mapped V4	4434	* This socket option is a boolean flag which turns on or off mapped V4
4435	* addresses. If this option is turned on and the socket is type	4435	* addresses. If this option is turned on and the socket is type
4436	* PF_INET6, then IPv4 addresses will be mapped to V6 representation.	4436	* PF_INET6, then IPv4 addresses will be mapped to V6 representation.
4437	* If this option is turned off, then no mapping will be done of V4	4437	* If this option is turned off, then no mapping will be done of V4
4438	* addresses and a user will receive both PF_INET6 and PF_INET type	4438	* addresses and a user will receive both PF_INET6 and PF_INET type
4439	* addresses on the socket.	4439	* addresses on the socket.
4440	*/	4440	*/
4441	static int sctp_getsockopt_mappedv4(struct sock *sk, int len,	4441	static int sctp_getsockopt_mappedv4(struct sock *sk, int len,
4442	char __user optval, int __user optlen)	4442	char __user optval, int __user optlen)
4443	{	4443	{
4444	int val;	4444	int val;
4445	struct sctp_sock *sp = sctp_sk(sk);	4445	struct sctp_sock *sp = sctp_sk(sk);
4446		4446
4447	if (len < sizeof(int))	4447	if (len < sizeof(int))
4448	return -EINVAL;	4448	return -EINVAL;
4449		4449
4450	len = sizeof(int);	4450	len = sizeof(int);
4451	val = sp->v4mapped;	4451	val = sp->v4mapped;
4452	if (put_user(len, optlen))	4452	if (put_user(len, optlen))
4453	return -EFAULT;	4453	return -EFAULT;
4454	if (copy_to_user(optval, &val, len))	4454	if (copy_to_user(optval, &val, len))
4455	return -EFAULT;	4455	return -EFAULT;
4456		4456
4457	return 0;	4457	return 0;
4458	}	4458	}
4459		4459
4460	/*	4460	/*
4461	* 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)	4461	* 7.1.17 Set the maximum fragrmentation size (SCTP_MAXSEG)
4462	*	4462	*
4463	* This socket option specifies the maximum size to put in any outgoing	4463	* This socket option specifies the maximum size to put in any outgoing
4464	* SCTP chunk. If a message is larger than this size it will be	4464	* SCTP chunk. If a message is larger than this size it will be
4465	* fragmented by SCTP into the specified size. Note that the underlying	4465	* fragmented by SCTP into the specified size. Note that the underlying
4466	* SCTP implementation may fragment into smaller sized chunks when the	4466	* SCTP implementation may fragment into smaller sized chunks when the
4467	* PMTU of the underlying association is smaller than the value set by	4467	* PMTU of the underlying association is smaller than the value set by
4468	* the user.	4468	* the user.
4469	*/	4469	*/
4470	static int sctp_getsockopt_maxseg(struct sock *sk, int len,	4470	static int sctp_getsockopt_maxseg(struct sock *sk, int len,
4471	char __user optval, int __user optlen)	4471	char __user optval, int __user optlen)
4472	{	4472	{
4473	int val;	4473	int val;
4474		4474
4475	if (len < sizeof(int))	4475	if (len < sizeof(int))
4476	return -EINVAL;	4476	return -EINVAL;
4477		4477
4478	len = sizeof(int);	4478	len = sizeof(int);
4479		4479
4480	val = sctp_sk(sk)->user_frag;	4480	val = sctp_sk(sk)->user_frag;
4481	if (put_user(len, optlen))	4481	if (put_user(len, optlen))
4482	return -EFAULT;	4482	return -EFAULT;
4483	if (copy_to_user(optval, &val, len))	4483	if (copy_to_user(optval, &val, len))
4484	return -EFAULT;	4484	return -EFAULT;
4485		4485
4486	return 0;	4486	return 0;
4487	}	4487	}
4488		4488
4489	SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,	4489	SCTP_STATIC int sctp_getsockopt(struct sock *sk, int level, int optname,
4490	char __user optval, int __user optlen)	4490	char __user optval, int __user optlen)
4491	{	4491	{
4492	int retval = 0;	4492	int retval = 0;
4493	int len;	4493	int len;
4494		4494
4495	SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n",	4495	SCTP_DEBUG_PRINTK("sctp_getsockopt(sk: %p... optname: %d)\n",
4496	sk, optname);	4496	sk, optname);
4497		4497
4498	/* I can hardly begin to describe how wrong this is. This is	4498	/* I can hardly begin to describe how wrong this is. This is
4499	* so broken as to be worse than useless. The API draft	4499	* so broken as to be worse than useless. The API draft
4500	* REALLY is NOT helpful here... I am not convinced that the	4500	* REALLY is NOT helpful here... I am not convinced that the
4501	* semantics of getsockopt() with a level OTHER THAN SOL_SCTP	4501	* semantics of getsockopt() with a level OTHER THAN SOL_SCTP
4502	* are at all well-founded.	4502	* are at all well-founded.
4503	*/	4503	*/
4504	if (level != SOL_SCTP) {	4504	if (level != SOL_SCTP) {
4505	struct sctp_af *af = sctp_sk(sk)->pf->af;	4505	struct sctp_af *af = sctp_sk(sk)->pf->af;
4506		4506
4507	retval = af->getsockopt(sk, level, optname, optval, optlen);	4507	retval = af->getsockopt(sk, level, optname, optval, optlen);
4508	return retval;	4508	return retval;
4509	}	4509	}
4510		4510
4511	if (get_user(len, optlen))	4511	if (get_user(len, optlen))
4512	return -EFAULT;	4512	return -EFAULT;
4513		4513
4514	sctp_lock_sock(sk);	4514	sctp_lock_sock(sk);
4515		4515
4516	switch (optname) {	4516	switch (optname) {
4517	case SCTP_STATUS:	4517	case SCTP_STATUS:
4518	retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);	4518	retval = sctp_getsockopt_sctp_status(sk, len, optval, optlen);
4519	break;	4519	break;
4520	case SCTP_DISABLE_FRAGMENTS:	4520	case SCTP_DISABLE_FRAGMENTS:
4521	retval = sctp_getsockopt_disable_fragments(sk, len, optval,	4521	retval = sctp_getsockopt_disable_fragments(sk, len, optval,
4522	optlen);	4522	optlen);
4523	break;	4523	break;
4524	case SCTP_EVENTS:	4524	case SCTP_EVENTS:
4525	retval = sctp_getsockopt_events(sk, len, optval, optlen);	4525	retval = sctp_getsockopt_events(sk, len, optval, optlen);
4526	break;	4526	break;
4527	case SCTP_AUTOCLOSE:	4527	case SCTP_AUTOCLOSE:
4528	retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);	4528	retval = sctp_getsockopt_autoclose(sk, len, optval, optlen);
4529	break;	4529	break;
4530	case SCTP_SOCKOPT_PEELOFF:	4530	case SCTP_SOCKOPT_PEELOFF:
4531	retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);	4531	retval = sctp_getsockopt_peeloff(sk, len, optval, optlen);
4532	break;	4532	break;
4533	case SCTP_PEER_ADDR_PARAMS:	4533	case SCTP_PEER_ADDR_PARAMS:
4534	retval = sctp_getsockopt_peer_addr_params(sk, len, optval,	4534	retval = sctp_getsockopt_peer_addr_params(sk, len, optval,
4535	optlen);	4535	optlen);
4536	break;	4536	break;
4537	case SCTP_DELAYED_ACK_TIME:	4537	case SCTP_DELAYED_ACK_TIME:
4538	retval = sctp_getsockopt_delayed_ack_time(sk, len, optval,	4538	retval = sctp_getsockopt_delayed_ack_time(sk, len, optval,
4539	optlen);	4539	optlen);
4540	break;	4540	break;
4541	case SCTP_INITMSG:	4541	case SCTP_INITMSG:
4542	retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);	4542	retval = sctp_getsockopt_initmsg(sk, len, optval, optlen);
4543	break;	4543	break;
4544	case SCTP_GET_PEER_ADDRS_NUM_OLD:	4544	case SCTP_GET_PEER_ADDRS_NUM_OLD:
4545	retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval,	4545	retval = sctp_getsockopt_peer_addrs_num_old(sk, len, optval,
4546	optlen);	4546	optlen);
4547	break;	4547	break;
4548	case SCTP_GET_LOCAL_ADDRS_NUM_OLD:	4548	case SCTP_GET_LOCAL_ADDRS_NUM_OLD:
4549	retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval,	4549	retval = sctp_getsockopt_local_addrs_num_old(sk, len, optval,
4550	optlen);	4550	optlen);
4551	break;	4551	break;
4552	case SCTP_GET_PEER_ADDRS_OLD:	4552	case SCTP_GET_PEER_ADDRS_OLD:
4553	retval = sctp_getsockopt_peer_addrs_old(sk, len, optval,	4553	retval = sctp_getsockopt_peer_addrs_old(sk, len, optval,
4554	optlen);	4554	optlen);
4555	break;	4555	break;
4556	case SCTP_GET_LOCAL_ADDRS_OLD:	4556	case SCTP_GET_LOCAL_ADDRS_OLD:
4557	retval = sctp_getsockopt_local_addrs_old(sk, len, optval,	4557	retval = sctp_getsockopt_local_addrs_old(sk, len, optval,
4558	optlen);	4558	optlen);
4559	break;	4559	break;
4560	case SCTP_GET_PEER_ADDRS:	4560	case SCTP_GET_PEER_ADDRS:
4561	retval = sctp_getsockopt_peer_addrs(sk, len, optval,	4561	retval = sctp_getsockopt_peer_addrs(sk, len, optval,
4562	optlen);	4562	optlen);
4563	break;	4563	break;
4564	case SCTP_GET_LOCAL_ADDRS:	4564	case SCTP_GET_LOCAL_ADDRS:
4565	retval = sctp_getsockopt_local_addrs(sk, len, optval,	4565	retval = sctp_getsockopt_local_addrs(sk, len, optval,
4566	optlen);	4566	optlen);
4567	break;	4567	break;
4568	case SCTP_DEFAULT_SEND_PARAM:	4568	case SCTP_DEFAULT_SEND_PARAM:
4569	retval = sctp_getsockopt_default_send_param(sk, len,	4569	retval = sctp_getsockopt_default_send_param(sk, len,
4570	optval, optlen);	4570	optval, optlen);
4571	break;	4571	break;
4572	case SCTP_PRIMARY_ADDR:	4572	case SCTP_PRIMARY_ADDR:
4573	retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);	4573	retval = sctp_getsockopt_primary_addr(sk, len, optval, optlen);
4574	break;	4574	break;
4575	case SCTP_NODELAY:	4575	case SCTP_NODELAY:
4576	retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);	4576	retval = sctp_getsockopt_nodelay(sk, len, optval, optlen);
4577	break;	4577	break;
4578	case SCTP_RTOINFO:	4578	case SCTP_RTOINFO:
4579	retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);	4579	retval = sctp_getsockopt_rtoinfo(sk, len, optval, optlen);
4580	break;	4580	break;
4581	case SCTP_ASSOCINFO:	4581	case SCTP_ASSOCINFO:
4582	retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);	4582	retval = sctp_getsockopt_associnfo(sk, len, optval, optlen);
4583	break;	4583	break;
4584	case SCTP_I_WANT_MAPPED_V4_ADDR:	4584	case SCTP_I_WANT_MAPPED_V4_ADDR:
4585	retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);	4585	retval = sctp_getsockopt_mappedv4(sk, len, optval, optlen);
4586	break;	4586	break;
4587	case SCTP_MAXSEG:	4587	case SCTP_MAXSEG:
4588	retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);	4588	retval = sctp_getsockopt_maxseg(sk, len, optval, optlen);
4589	break;	4589	break;
4590	case SCTP_GET_PEER_ADDR_INFO:	4590	case SCTP_GET_PEER_ADDR_INFO:
4591	retval = sctp_getsockopt_peer_addr_info(sk, len, optval,	4591	retval = sctp_getsockopt_peer_addr_info(sk, len, optval,
4592	optlen);	4592	optlen);
4593	break;	4593	break;
4594	case SCTP_ADAPTION_LAYER:	4594	case SCTP_ADAPTION_LAYER:
4595	retval = sctp_getsockopt_adaption_layer(sk, len, optval,	4595	retval = sctp_getsockopt_adaption_layer(sk, len, optval,
4596	optlen);	4596	optlen);
4597	break;	4597	break;
4598	default:	4598	default:
4599	retval = -ENOPROTOOPT;	4599	retval = -ENOPROTOOPT;
4600	break;	4600	break;
4601	};	4601	};
4602		4602
4603	sctp_release_sock(sk);	4603	sctp_release_sock(sk);
4604	return retval;	4604	return retval;
4605	}	4605	}
4606		4606
4607	static void sctp_hash(struct sock *sk)	4607	static void sctp_hash(struct sock *sk)
4608	{	4608	{
4609	/* STUB */	4609	/* STUB */
4610	}	4610	}
4611		4611
4612	static void sctp_unhash(struct sock *sk)	4612	static void sctp_unhash(struct sock *sk)
4613	{	4613	{
4614	/* STUB */	4614	/* STUB */
4615	}	4615	}
4616		4616
4617	/* Check if port is acceptable. Possibly find first available port.	4617	/* Check if port is acceptable. Possibly find first available port.
4618	*	4618	*
4619	* The port hash table (contained in the 'global' SCTP protocol storage	4619	* The port hash table (contained in the 'global' SCTP protocol storage
4620	* returned by struct sctp_protocol *sctp_get_protocol()). The hash	4620	* returned by struct sctp_protocol *sctp_get_protocol()). The hash
4621	* table is an array of 4096 lists (sctp_bind_hashbucket). Each	4621	* table is an array of 4096 lists (sctp_bind_hashbucket). Each
4622	* list (the list number is the port number hashed out, so as you	4622	* list (the list number is the port number hashed out, so as you
4623	* would expect from a hash function, all the ports in a given list have	4623	* would expect from a hash function, all the ports in a given list have
4624	* such a number that hashes out to the same list number; you were	4624	* such a number that hashes out to the same list number; you were
4625	* expecting that, right?); so each list has a set of ports, with a	4625	* expecting that, right?); so each list has a set of ports, with a
4626	* link to the socket (struct sock) that uses it, the port number and	4626	* link to the socket (struct sock) that uses it, the port number and
4627	* a fastreuse flag (FIXME: NPI ipg).	4627	* a fastreuse flag (FIXME: NPI ipg).
4628	*/	4628	*/
4629	static struct sctp_bind_bucket *sctp_bucket_create(	4629	static struct sctp_bind_bucket *sctp_bucket_create(
4630	struct sctp_bind_hashbucket *head, unsigned short snum);	4630	struct sctp_bind_hashbucket *head, unsigned short snum);
4631		4631
4632	static long sctp_get_port_local(struct sock sk, union sctp_addr addr)	4632	static long sctp_get_port_local(struct sock sk, union sctp_addr addr)
4633	{	4633	{
4634	struct sctp_bind_hashbucket head; / hash list */	4634	struct sctp_bind_hashbucket head; / hash list */
4635	struct sctp_bind_bucket pp; / hash list port iterator */	4635	struct sctp_bind_bucket pp; / hash list port iterator */
4636	unsigned short snum;	4636	unsigned short snum;
4637	int ret;	4637	int ret;
4638		4638
4639	/* NOTE: Remember to put this back to net order. */	4639	/* NOTE: Remember to put this back to net order. */
4640	addr->v4.sin_port = ntohs(addr->v4.sin_port);	4640	addr->v4.sin_port = ntohs(addr->v4.sin_port);
4641	snum = addr->v4.sin_port;	4641	snum = addr->v4.sin_port;
4642		4642
4643	SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum);	4643	SCTP_DEBUG_PRINTK("sctp_get_port() begins, snum=%d\n", snum);
4644	sctp_local_bh_disable();	4644	sctp_local_bh_disable();
4645		4645
4646	if (snum == 0) {	4646	if (snum == 0) {
4647	/* Search for an available port.	4647	/* Search for an available port.
4648	*	4648	*
4649	* 'sctp_port_rover' was the last port assigned, so	4649	* 'sctp_port_rover' was the last port assigned, so
4650	* we start to search from 'sctp_port_rover +	4650	* we start to search from 'sctp_port_rover +
4651	* 1'. What we do is first check if port 'rover' is	4651	* 1'. What we do is first check if port 'rover' is
4652	* already in the hash table; if not, we use that; if	4652	* already in the hash table; if not, we use that; if
4653	* it is, we try next.	4653	* it is, we try next.
4654	*/	4654	*/
4655	int low = sysctl_local_port_range[0];	4655	int low = sysctl_local_port_range[0];
4656	int high = sysctl_local_port_range[1];	4656	int high = sysctl_local_port_range[1];
4657	int remaining = (high - low) + 1;	4657	int remaining = (high - low) + 1;
4658	int rover;	4658	int rover;
4659	int index;	4659	int index;
4660		4660
4661	sctp_spin_lock(&sctp_port_alloc_lock);	4661	sctp_spin_lock(&sctp_port_alloc_lock);
4662	rover = sctp_port_rover;	4662	rover = sctp_port_rover;
4663	do {	4663	do {
4664	rover++;	4664	rover++;
4665	if ((rover < low) \|\| (rover > high))	4665	if ((rover < low) \|\| (rover > high))
4666	rover = low;	4666	rover = low;
4667	index = sctp_phashfn(rover);	4667	index = sctp_phashfn(rover);
4668	head = &sctp_port_hashtable[index];	4668	head = &sctp_port_hashtable[index];
4669	sctp_spin_lock(&head->lock);	4669	sctp_spin_lock(&head->lock);
4670	for (pp = head->chain; pp; pp = pp->next)	4670	for (pp = head->chain; pp; pp = pp->next)
4671	if (pp->port == rover)	4671	if (pp->port == rover)
4672	goto next;	4672	goto next;
4673	break;	4673	break;
4674	next:	4674	next:
4675	sctp_spin_unlock(&head->lock);	4675	sctp_spin_unlock(&head->lock);
4676	} while (--remaining > 0);	4676	} while (--remaining > 0);
4677	sctp_port_rover = rover;	4677	sctp_port_rover = rover;
4678	sctp_spin_unlock(&sctp_port_alloc_lock);	4678	sctp_spin_unlock(&sctp_port_alloc_lock);
4679		4679
4680	/* Exhausted local port range during search? */	4680	/* Exhausted local port range during search? */
4681	ret = 1;	4681	ret = 1;
4682	if (remaining <= 0)	4682	if (remaining <= 0)
4683	goto fail;	4683	goto fail;
4684		4684
4685	/* OK, here is the one we will use. HEAD (the port	4685	/* OK, here is the one we will use. HEAD (the port
4686	* hash table list entry) is non-NULL and we hold it's	4686	* hash table list entry) is non-NULL and we hold it's
4687	* mutex.	4687	* mutex.
4688	*/	4688	*/
4689	snum = rover;	4689	snum = rover;
4690	} else {	4690	} else {
4691	/* We are given an specific port number; we verify	4691	/* We are given an specific port number; we verify
4692	* that it is not being used. If it is used, we will	4692	* that it is not being used. If it is used, we will
4693	* exahust the search in the hash list corresponding	4693	* exahust the search in the hash list corresponding
4694	* to the port number (snum) - we detect that with the	4694	* to the port number (snum) - we detect that with the
4695	* port iterator, pp being NULL.	4695	* port iterator, pp being NULL.
4696	*/	4696	*/
4697	head = &sctp_port_hashtable[sctp_phashfn(snum)];	4697	head = &sctp_port_hashtable[sctp_phashfn(snum)];
4698	sctp_spin_lock(&head->lock);	4698	sctp_spin_lock(&head->lock);
4699	for (pp = head->chain; pp; pp = pp->next) {	4699	for (pp = head->chain; pp; pp = pp->next) {
4700	if (pp->port == snum)	4700	if (pp->port == snum)
4701	goto pp_found;	4701	goto pp_found;
4702	}	4702	}
4703	}	4703	}
4704	pp = NULL;	4704	pp = NULL;
4705	goto pp_not_found;	4705	goto pp_not_found;
4706	pp_found:	4706	pp_found:
4707	if (!hlist_empty(&pp->owner)) {	4707	if (!hlist_empty(&pp->owner)) {
4708	/* We had a port hash table hit - there is an	4708	/* We had a port hash table hit - there is an
4709	* available port (pp != NULL) and it is being	4709	* available port (pp != NULL) and it is being
4710	* used by other socket (pp->owner not empty); that other	4710	* used by other socket (pp->owner not empty); that other
4711	* socket is going to be sk2.	4711	* socket is going to be sk2.
4712	*/	4712	*/
4713	int reuse = sk->sk_reuse;	4713	int reuse = sk->sk_reuse;
4714	struct sock *sk2;	4714	struct sock *sk2;
4715	struct hlist_node *node;	4715	struct hlist_node *node;
4716		4716
4717	SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");	4717	SCTP_DEBUG_PRINTK("sctp_get_port() found a possible match\n");
4718	if (pp->fastreuse && sk->sk_reuse)	4718	if (pp->fastreuse && sk->sk_reuse)
4719	goto success;	4719	goto success;
4720		4720
4721	/* Run through the list of sockets bound to the port	4721	/* Run through the list of sockets bound to the port
4722	* (pp->port) [via the pointers bind_next and	4722	* (pp->port) [via the pointers bind_next and
4723	* bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,	4723	* bind_pprev in the struct sock *sk2 (pp->sk)]. On each one,
4724	* we get the endpoint they describe and run through	4724	* we get the endpoint they describe and run through
4725	* the endpoint's list of IP (v4 or v6) addresses,	4725	* the endpoint's list of IP (v4 or v6) addresses,
4726	* comparing each of the addresses with the address of	4726	* comparing each of the addresses with the address of
4727	* the socket sk. If we find a match, then that means	4727	* the socket sk. If we find a match, then that means
4728	* that this port/socket (sk) combination are already	4728	* that this port/socket (sk) combination are already
4729	* in an endpoint.	4729	* in an endpoint.
4730	*/	4730	*/
4731	sk_for_each_bound(sk2, node, &pp->owner) {	4731	sk_for_each_bound(sk2, node, &pp->owner) {
4732	struct sctp_endpoint *ep2;	4732	struct sctp_endpoint *ep2;
4733	ep2 = sctp_sk(sk2)->ep;	4733	ep2 = sctp_sk(sk2)->ep;
4734		4734
4735	if (reuse && sk2->sk_reuse)	4735	if (reuse && sk2->sk_reuse)
4736	continue;	4736	continue;
4737		4737
4738	if (sctp_bind_addr_match(&ep2->base.bind_addr, addr,	4738	if (sctp_bind_addr_match(&ep2->base.bind_addr, addr,
4739	sctp_sk(sk))) {	4739	sctp_sk(sk))) {
4740	ret = (long)sk2;	4740	ret = (long)sk2;
4741	goto fail_unlock;	4741	goto fail_unlock;
4742	}	4742	}
4743	}	4743	}
4744	SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n");	4744	SCTP_DEBUG_PRINTK("sctp_get_port(): Found a match\n");
4745	}	4745	}
4746	pp_not_found:	4746	pp_not_found:
4747	/* If there was a hash table miss, create a new port. */	4747	/* If there was a hash table miss, create a new port. */
4748	ret = 1;	4748	ret = 1;
4749	if (!pp && !(pp = sctp_bucket_create(head, snum)))	4749	if (!pp && !(pp = sctp_bucket_create(head, snum)))
4750	goto fail_unlock;	4750	goto fail_unlock;
4751		4751
4752	/* In either case (hit or miss), make sure fastreuse is 1 only	4752	/* In either case (hit or miss), make sure fastreuse is 1 only
4753	* if sk->sk_reuse is too (that is, if the caller requested	4753	* if sk->sk_reuse is too (that is, if the caller requested
4754	* SO_REUSEADDR on this socket -sk-).	4754	* SO_REUSEADDR on this socket -sk-).
4755	*/	4755	*/
4756	if (hlist_empty(&pp->owner))	4756	if (hlist_empty(&pp->owner))
4757	pp->fastreuse = sk->sk_reuse ? 1 : 0;	4757	pp->fastreuse = sk->sk_reuse ? 1 : 0;
4758	else if (pp->fastreuse && !sk->sk_reuse)	4758	else if (pp->fastreuse && !sk->sk_reuse)
4759	pp->fastreuse = 0;	4759	pp->fastreuse = 0;
4760		4760
4761	/* We are set, so fill up all the data in the hash table	4761	/* We are set, so fill up all the data in the hash table
4762	* entry, tie the socket list information with the rest of the	4762	* entry, tie the socket list information with the rest of the
4763	* sockets FIXME: Blurry, NPI (ipg).	4763	* sockets FIXME: Blurry, NPI (ipg).
4764	*/	4764	*/
4765	success:	4765	success:
4766	inet_sk(sk)->num = snum;	4766	inet_sk(sk)->num = snum;
4767	if (!sctp_sk(sk)->bind_hash) {	4767	if (!sctp_sk(sk)->bind_hash) {
4768	sk_add_bind_node(sk, &pp->owner);	4768	sk_add_bind_node(sk, &pp->owner);
4769	sctp_sk(sk)->bind_hash = pp;	4769	sctp_sk(sk)->bind_hash = pp;
4770	}	4770	}
4771	ret = 0;	4771	ret = 0;
4772		4772
4773	fail_unlock:	4773	fail_unlock:
4774	sctp_spin_unlock(&head->lock);	4774	sctp_spin_unlock(&head->lock);
4775		4775
4776	fail:	4776	fail:
4777	sctp_local_bh_enable();	4777	sctp_local_bh_enable();
4778	addr->v4.sin_port = htons(addr->v4.sin_port);	4778	addr->v4.sin_port = htons(addr->v4.sin_port);
4779	return ret;	4779	return ret;
4780	}	4780	}
4781		4781
4782	/* Assign a 'snum' port to the socket. If snum == 0, an ephemeral	4782	/* Assign a 'snum' port to the socket. If snum == 0, an ephemeral
4783	* port is requested.	4783	* port is requested.
4784	*/	4784	*/
4785	static int sctp_get_port(struct sock *sk, unsigned short snum)	4785	static int sctp_get_port(struct sock *sk, unsigned short snum)
4786	{	4786	{
4787	long ret;	4787	long ret;
4788	union sctp_addr addr;	4788	union sctp_addr addr;
4789	struct sctp_af *af = sctp_sk(sk)->pf->af;	4789	struct sctp_af *af = sctp_sk(sk)->pf->af;
4790		4790
4791	/* Set up a dummy address struct from the sk. */	4791	/* Set up a dummy address struct from the sk. */
4792	af->from_sk(&addr, sk);	4792	af->from_sk(&addr, sk);
4793	addr.v4.sin_port = htons(snum);	4793	addr.v4.sin_port = htons(snum);
4794		4794
4795	/* Note: sk->sk_num gets filled in if ephemeral port request. */	4795	/* Note: sk->sk_num gets filled in if ephemeral port request. */
4796	ret = sctp_get_port_local(sk, &addr);	4796	ret = sctp_get_port_local(sk, &addr);
4797		4797
4798	return (ret ? 1 : 0);	4798	return (ret ? 1 : 0);
4799	}	4799	}
4800		4800
4801	/*	4801	/*
4802	* 3.1.3 listen() - UDP Style Syntax	4802	* 3.1.3 listen() - UDP Style Syntax
4803	*	4803	*
4804	* By default, new associations are not accepted for UDP style sockets.	4804	* By default, new associations are not accepted for UDP style sockets.
4805	* An application uses listen() to mark a socket as being able to	4805	* An application uses listen() to mark a socket as being able to
4806	* accept new associations.	4806	* accept new associations.
4807	*/	4807	*/
4808	SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)	4808	SCTP_STATIC int sctp_seqpacket_listen(struct sock *sk, int backlog)
4809	{	4809	{
4810	struct sctp_sock *sp = sctp_sk(sk);	4810	struct sctp_sock *sp = sctp_sk(sk);
4811	struct sctp_endpoint *ep = sp->ep;	4811	struct sctp_endpoint *ep = sp->ep;
4812		4812
4813	/* Only UDP style sockets that are not peeled off are allowed to	4813	/* Only UDP style sockets that are not peeled off are allowed to
4814	* listen().	4814	* listen().
4815	*/	4815	*/
4816	if (!sctp_style(sk, UDP))	4816	if (!sctp_style(sk, UDP))
4817	return -EINVAL;	4817	return -EINVAL;
4818		4818
4819	/* If backlog is zero, disable listening. */	4819	/* If backlog is zero, disable listening. */
4820	if (!backlog) {	4820	if (!backlog) {
4821	if (sctp_sstate(sk, CLOSED))	4821	if (sctp_sstate(sk, CLOSED))
4822	return 0;	4822	return 0;
4823		4823
4824	sctp_unhash_endpoint(ep);	4824	sctp_unhash_endpoint(ep);
4825	sk->sk_state = SCTP_SS_CLOSED;	4825	sk->sk_state = SCTP_SS_CLOSED;
4826	}	4826	}
4827		4827
4828	/* Return if we are already listening. */	4828	/* Return if we are already listening. */
4829	if (sctp_sstate(sk, LISTENING))	4829	if (sctp_sstate(sk, LISTENING))
4830	return 0;	4830	return 0;
4831		4831
4832	/*	4832	/*
4833	* If a bind() or sctp_bindx() is not called prior to a listen()	4833	* If a bind() or sctp_bindx() is not called prior to a listen()
4834	* call that allows new associations to be accepted, the system	4834	* call that allows new associations to be accepted, the system
4835	* picks an ephemeral port and will choose an address set equivalent	4835	* picks an ephemeral port and will choose an address set equivalent
4836	* to binding with a wildcard address.	4836	* to binding with a wildcard address.
4837	*	4837	*
4838	* This is not currently spelled out in the SCTP sockets	4838	* This is not currently spelled out in the SCTP sockets
4839	* extensions draft, but follows the practice as seen in TCP	4839	* extensions draft, but follows the practice as seen in TCP
4840	* sockets.	4840	* sockets.
4841	*/	4841	*/
4842	if (!ep->base.bind_addr.port) {	4842	if (!ep->base.bind_addr.port) {
4843	if (sctp_autobind(sk))	4843	if (sctp_autobind(sk))
4844	return -EAGAIN;	4844	return -EAGAIN;
4845	}	4845	}
4846	sk->sk_state = SCTP_SS_LISTENING;	4846	sk->sk_state = SCTP_SS_LISTENING;
4847	sctp_hash_endpoint(ep);	4847	sctp_hash_endpoint(ep);
4848	return 0;	4848	return 0;
4849	}	4849	}
4850		4850
4851	/*	4851	/*
4852	* 4.1.3 listen() - TCP Style Syntax	4852	* 4.1.3 listen() - TCP Style Syntax
4853	*	4853	*
4854	* Applications uses listen() to ready the SCTP endpoint for accepting	4854	* Applications uses listen() to ready the SCTP endpoint for accepting
4855	* inbound associations.	4855	* inbound associations.
4856	*/	4856	*/
4857	SCTP_STATIC int sctp_stream_listen(struct sock *sk, int backlog)	4857	SCTP_STATIC int sctp_stream_listen(struct sock *sk, int backlog)
4858	{	4858	{
4859	struct sctp_sock *sp = sctp_sk(sk);	4859	struct sctp_sock *sp = sctp_sk(sk);
4860	struct sctp_endpoint *ep = sp->ep;	4860	struct sctp_endpoint *ep = sp->ep;
4861		4861
4862	/* If backlog is zero, disable listening. */	4862	/* If backlog is zero, disable listening. */
4863	if (!backlog) {	4863	if (!backlog) {
4864	if (sctp_sstate(sk, CLOSED))	4864	if (sctp_sstate(sk, CLOSED))
4865	return 0;	4865	return 0;
4866		4866
4867	sctp_unhash_endpoint(ep);	4867	sctp_unhash_endpoint(ep);
4868	sk->sk_state = SCTP_SS_CLOSED;	4868	sk->sk_state = SCTP_SS_CLOSED;
4869	}	4869	}
4870		4870
4871	if (sctp_sstate(sk, LISTENING))	4871	if (sctp_sstate(sk, LISTENING))
4872	return 0;	4872	return 0;
4873		4873
4874	/*	4874	/*
4875	* If a bind() or sctp_bindx() is not called prior to a listen()	4875	* If a bind() or sctp_bindx() is not called prior to a listen()
4876	* call that allows new associations to be accepted, the system	4876	* call that allows new associations to be accepted, the system
4877	* picks an ephemeral port and will choose an address set equivalent	4877	* picks an ephemeral port and will choose an address set equivalent
4878	* to binding with a wildcard address.	4878	* to binding with a wildcard address.
4879	*	4879	*
4880	* This is not currently spelled out in the SCTP sockets	4880	* This is not currently spelled out in the SCTP sockets
4881	* extensions draft, but follows the practice as seen in TCP	4881	* extensions draft, but follows the practice as seen in TCP
4882	* sockets.	4882	* sockets.
4883	*/	4883	*/
4884	if (!ep->base.bind_addr.port) {	4884	if (!ep->base.bind_addr.port) {
4885	if (sctp_autobind(sk))	4885	if (sctp_autobind(sk))
4886	return -EAGAIN;	4886	return -EAGAIN;
4887	}	4887	}
4888	sk->sk_state = SCTP_SS_LISTENING;	4888	sk->sk_state = SCTP_SS_LISTENING;
4889	sk->sk_max_ack_backlog = backlog;	4889	sk->sk_max_ack_backlog = backlog;
4890	sctp_hash_endpoint(ep);	4890	sctp_hash_endpoint(ep);
4891	return 0;	4891	return 0;
4892	}	4892	}
4893		4893
4894	/*	4894	/*
4895	* Move a socket to LISTENING state.	4895	* Move a socket to LISTENING state.
4896	*/	4896	*/
4897	int sctp_inet_listen(struct socket *sock, int backlog)	4897	int sctp_inet_listen(struct socket *sock, int backlog)
4898	{	4898	{
4899	struct sock *sk = sock->sk;	4899	struct sock *sk = sock->sk;
4900	struct crypto_hash *tfm = NULL;	4900	struct crypto_hash *tfm = NULL;
4901	int err = -EINVAL;	4901	int err = -EINVAL;
4902		4902
4903	if (unlikely(backlog < 0))	4903	if (unlikely(backlog < 0))
4904	goto out;	4904	goto out;
4905		4905
4906	sctp_lock_sock(sk);	4906	sctp_lock_sock(sk);
4907		4907
4908	if (sock->state != SS_UNCONNECTED)	4908	if (sock->state != SS_UNCONNECTED)
4909	goto out;	4909	goto out;
4910		4910
4911	/* Allocate HMAC for generating cookie. */	4911	/* Allocate HMAC for generating cookie. */
4912	if (sctp_hmac_alg) {	4912	if (sctp_hmac_alg) {
4913	tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC);	4913	tfm = crypto_alloc_hash(sctp_hmac_alg, 0, CRYPTO_ALG_ASYNC);
4914	if (!tfm) {	4914	if (!tfm) {
4915	err = -ENOSYS;	4915	err = -ENOSYS;
4916	goto out;	4916	goto out;
4917	}	4917	}
4918	}	4918	}
4919		4919
4920	switch (sock->type) {	4920	switch (sock->type) {
4921	case SOCK_SEQPACKET:	4921	case SOCK_SEQPACKET:
4922	err = sctp_seqpacket_listen(sk, backlog);	4922	err = sctp_seqpacket_listen(sk, backlog);
4923	break;	4923	break;
4924	case SOCK_STREAM:	4924	case SOCK_STREAM:
4925	err = sctp_stream_listen(sk, backlog);	4925	err = sctp_stream_listen(sk, backlog);
4926	break;	4926	break;
4927	default:	4927	default:
4928	break;	4928	break;
4929	};	4929	};
4930	if (err)	4930	if (err)
4931	goto cleanup;	4931	goto cleanup;
4932		4932
4933	/* Store away the transform reference. */	4933	/* Store away the transform reference. */
4934	sctp_sk(sk)->hmac = tfm;	4934	sctp_sk(sk)->hmac = tfm;
4935	out:	4935	out:
4936	sctp_release_sock(sk);	4936	sctp_release_sock(sk);
4937	return err;	4937	return err;
4938	cleanup:	4938	cleanup:
4939	crypto_free_hash(tfm);	4939	crypto_free_hash(tfm);
4940	goto out;	4940	goto out;
4941	}	4941	}
4942		4942
4943	/*	4943	/*
4944	* This function is done by modeling the current datagram_poll() and the	4944	* This function is done by modeling the current datagram_poll() and the
4945	* tcp_poll(). Note that, based on these implementations, we don't	4945	* tcp_poll(). Note that, based on these implementations, we don't
4946	* lock the socket in this function, even though it seems that,	4946	* lock the socket in this function, even though it seems that,
4947	* ideally, locking or some other mechanisms can be used to ensure	4947	* ideally, locking or some other mechanisms can be used to ensure
4948	* the integrity of the counters (sndbuf and wmem_alloc) used	4948	* the integrity of the counters (sndbuf and wmem_alloc) used
4949	* in this place. We assume that we don't need locks either until proven	4949	* in this place. We assume that we don't need locks either until proven
4950	* otherwise.	4950	* otherwise.
4951	*	4951	*
4952	* Another thing to note is that we include the Async I/O support	4952	* Another thing to note is that we include the Async I/O support
4953	* here, again, by modeling the current TCP/UDP code. We don't have	4953	* here, again, by modeling the current TCP/UDP code. We don't have
4954	* a good way to test with it yet.	4954	* a good way to test with it yet.
4955	*/	4955	*/
4956	unsigned int sctp_poll(struct file file, struct socket sock, poll_table *wait)	4956	unsigned int sctp_poll(struct file file, struct socket sock, poll_table *wait)
4957	{	4957	{
4958	struct sock *sk = sock->sk;	4958	struct sock *sk = sock->sk;
4959	struct sctp_sock *sp = sctp_sk(sk);	4959	struct sctp_sock *sp = sctp_sk(sk);
4960	unsigned int mask;	4960	unsigned int mask;
4961		4961
4962	poll_wait(file, sk->sk_sleep, wait);	4962	poll_wait(file, sk->sk_sleep, wait);
4963		4963
4964	/* A TCP-style listening socket becomes readable when the accept queue	4964	/* A TCP-style listening socket becomes readable when the accept queue
4965	* is not empty.	4965	* is not empty.
4966	*/	4966	*/
4967	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))	4967	if (sctp_style(sk, TCP) && sctp_sstate(sk, LISTENING))
4968	return (!list_empty(&sp->ep->asocs)) ?	4968	return (!list_empty(&sp->ep->asocs)) ?
4969	(POLLIN \| POLLRDNORM) : 0;	4969	(POLLIN \| POLLRDNORM) : 0;
4970		4970
4971	mask = 0;	4971	mask = 0;
4972		4972
4973	/* Is there any exceptional events? */	4973	/* Is there any exceptional events? */
4974	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))	4974	if (sk->sk_err \|\| !skb_queue_empty(&sk->sk_error_queue))
4975	mask \|= POLLERR;	4975	mask \|= POLLERR;
4976	if (sk->sk_shutdown & RCV_SHUTDOWN)	4976	if (sk->sk_shutdown & RCV_SHUTDOWN)
4977	mask \|= POLLRDHUP;	4977	mask \|= POLLRDHUP;
4978	if (sk->sk_shutdown == SHUTDOWN_MASK)	4978	if (sk->sk_shutdown == SHUTDOWN_MASK)
4979	mask \|= POLLHUP;	4979	mask \|= POLLHUP;
4980		4980
4981	/* Is it readable? Reconsider this code with TCP-style support. */	4981	/* Is it readable? Reconsider this code with TCP-style support. */
4982	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|	4982	if (!skb_queue_empty(&sk->sk_receive_queue) \|\|
4983	(sk->sk_shutdown & RCV_SHUTDOWN))	4983	(sk->sk_shutdown & RCV_SHUTDOWN))
4984	mask \|= POLLIN \| POLLRDNORM;	4984	mask \|= POLLIN \| POLLRDNORM;
4985		4985
4986	/* The association is either gone or not ready. */	4986	/* The association is either gone or not ready. */
4987	if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))	4987	if (!sctp_style(sk, UDP) && sctp_sstate(sk, CLOSED))
4988	return mask;	4988	return mask;
4989		4989
4990	/* Is it writable? */	4990	/* Is it writable? */
4991	if (sctp_writeable(sk)) {	4991	if (sctp_writeable(sk)) {
4992	mask \|= POLLOUT \| POLLWRNORM;	4992	mask \|= POLLOUT \| POLLWRNORM;
4993	} else {	4993	} else {
4994	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);	4994	set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
4995	/*	4995	/*
4996	* Since the socket is not locked, the buffer	4996	* Since the socket is not locked, the buffer
4997	* might be made available after the writeable check and	4997	* might be made available after the writeable check and
4998	* before the bit is set. This could cause a lost I/O	4998	* before the bit is set. This could cause a lost I/O
4999	* signal. tcp_poll() has a race breaker for this race	4999	* signal. tcp_poll() has a race breaker for this race
5000	* condition. Based on their implementation, we put	5000	* condition. Based on their implementation, we put
5001	* in the following code to cover it as well.	5001	* in the following code to cover it as well.
5002	*/	5002	*/
5003	if (sctp_writeable(sk))	5003	if (sctp_writeable(sk))
5004	mask \|= POLLOUT \| POLLWRNORM;	5004	mask \|= POLLOUT \| POLLWRNORM;
5005	}	5005	}
5006	return mask;	5006	return mask;
5007	}	5007	}
5008		5008
5009	/********************************************************************	5009	/********************************************************************
5010	* 2nd Level Abstractions	5010	* 2nd Level Abstractions
5011	********************************************************************/	5011	********************************************************************/
5012		5012
5013	static struct sctp_bind_bucket *sctp_bucket_create(	5013	static struct sctp_bind_bucket *sctp_bucket_create(
5014	struct sctp_bind_hashbucket *head, unsigned short snum)	5014	struct sctp_bind_hashbucket *head, unsigned short snum)
5015	{	5015	{
5016	struct sctp_bind_bucket *pp;	5016	struct sctp_bind_bucket *pp;
5017		5017
5018	pp = kmem_cache_alloc(sctp_bucket_cachep, SLAB_ATOMIC);	5018	pp = kmem_cache_alloc(sctp_bucket_cachep, SLAB_ATOMIC);
5019	SCTP_DBG_OBJCNT_INC(bind_bucket);	5019	SCTP_DBG_OBJCNT_INC(bind_bucket);
5020	if (pp) {	5020	if (pp) {
5021	pp->port = snum;	5021	pp->port = snum;
5022	pp->fastreuse = 0;	5022	pp->fastreuse = 0;
5023	INIT_HLIST_HEAD(&pp->owner);	5023	INIT_HLIST_HEAD(&pp->owner);
5024	if ((pp->next = head->chain) != NULL)	5024	if ((pp->next = head->chain) != NULL)
5025	pp->next->pprev = &pp->next;	5025	pp->next->pprev = &pp->next;
5026	head->chain = pp;	5026	head->chain = pp;
5027	pp->pprev = &head->chain;	5027	pp->pprev = &head->chain;
5028	}	5028	}
5029	return pp;	5029	return pp;
5030	}	5030	}
5031		5031
5032	/* Caller must hold hashbucket lock for this tb with local BH disabled */	5032	/* Caller must hold hashbucket lock for this tb with local BH disabled */
5033	static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)	5033	static void sctp_bucket_destroy(struct sctp_bind_bucket *pp)
5034	{	5034	{
5035	if (pp && hlist_empty(&pp->owner)) {	5035	if (pp && hlist_empty(&pp->owner)) {
5036	if (pp->next)	5036	if (pp->next)
5037	pp->next->pprev = pp->pprev;	5037	pp->next->pprev = pp->pprev;
5038	*(pp->pprev) = pp->next;	5038	*(pp->pprev) = pp->next;
5039	kmem_cache_free(sctp_bucket_cachep, pp);	5039	kmem_cache_free(sctp_bucket_cachep, pp);
5040	SCTP_DBG_OBJCNT_DEC(bind_bucket);	5040	SCTP_DBG_OBJCNT_DEC(bind_bucket);
5041	}	5041	}
5042	}	5042	}
5043		5043
5044	/* Release this socket's reference to a local port. */	5044	/* Release this socket's reference to a local port. */
5045	static inline void __sctp_put_port(struct sock *sk)	5045	static inline void __sctp_put_port(struct sock *sk)
5046	{	5046	{
5047	struct sctp_bind_hashbucket *head =	5047	struct sctp_bind_hashbucket *head =
5048	&sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->num)];	5048	&sctp_port_hashtable[sctp_phashfn(inet_sk(sk)->num)];
5049	struct sctp_bind_bucket *pp;	5049	struct sctp_bind_bucket *pp;
5050		5050
5051	sctp_spin_lock(&head->lock);	5051	sctp_spin_lock(&head->lock);
5052	pp = sctp_sk(sk)->bind_hash;	5052	pp = sctp_sk(sk)->bind_hash;
5053	__sk_del_bind_node(sk);	5053	__sk_del_bind_node(sk);
5054	sctp_sk(sk)->bind_hash = NULL;	5054	sctp_sk(sk)->bind_hash = NULL;
5055	inet_sk(sk)->num = 0;	5055	inet_sk(sk)->num = 0;
5056	sctp_bucket_destroy(pp);	5056	sctp_bucket_destroy(pp);
5057	sctp_spin_unlock(&head->lock);	5057	sctp_spin_unlock(&head->lock);
5058	}	5058	}
5059		5059
5060	void sctp_put_port(struct sock *sk)	5060	void sctp_put_port(struct sock *sk)
5061	{	5061	{
5062	sctp_local_bh_disable();	5062	sctp_local_bh_disable();
5063	__sctp_put_port(sk);	5063	__sctp_put_port(sk);
5064	sctp_local_bh_enable();	5064	sctp_local_bh_enable();
5065	}	5065	}
5066		5066
5067	/*	5067	/*
5068	* The system picks an ephemeral port and choose an address set equivalent	5068	* The system picks an ephemeral port and choose an address set equivalent
5069	* to binding with a wildcard address.	5069	* to binding with a wildcard address.
5070	* One of those addresses will be the primary address for the association.	5070	* One of those addresses will be the primary address for the association.
5071	* This automatically enables the multihoming capability of SCTP.	5071	* This automatically enables the multihoming capability of SCTP.
5072	*/	5072	*/
5073	static int sctp_autobind(struct sock *sk)	5073	static int sctp_autobind(struct sock *sk)
5074	{	5074	{
5075	union sctp_addr autoaddr;	5075	union sctp_addr autoaddr;
5076	struct sctp_af *af;	5076	struct sctp_af *af;
5077	unsigned short port;	5077	unsigned short port;
5078		5078
5079	/* Initialize a local sockaddr structure to INADDR_ANY. */	5079	/* Initialize a local sockaddr structure to INADDR_ANY. */
5080	af = sctp_sk(sk)->pf->af;	5080	af = sctp_sk(sk)->pf->af;
5081		5081
5082	port = htons(inet_sk(sk)->num);	5082	port = htons(inet_sk(sk)->num);
5083	af->inaddr_any(&autoaddr, port);	5083	af->inaddr_any(&autoaddr, port);
5084		5084
5085	return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);	5085	return sctp_do_bind(sk, &autoaddr, af->sockaddr_len);
5086	}	5086	}
5087		5087
5088	/* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.	5088	/* Parse out IPPROTO_SCTP CMSG headers. Perform only minimal validation.
5089	*	5089	*
5090	* From RFC 2292	5090	* From RFC 2292
5091	* 4.2 The cmsghdr Structure *	5091	* 4.2 The cmsghdr Structure *
5092	*	5092	*
5093	* When ancillary data is sent or received, any number of ancillary data	5093	* When ancillary data is sent or received, any number of ancillary data
5094	* objects can be specified by the msg_control and msg_controllen members of	5094	* objects can be specified by the msg_control and msg_controllen members of
5095	* the msghdr structure, because each object is preceded by	5095	* the msghdr structure, because each object is preceded by
5096	* a cmsghdr structure defining the object's length (the cmsg_len member).	5096	* a cmsghdr structure defining the object's length (the cmsg_len member).
5097	* Historically Berkeley-derived implementations have passed only one object	5097	* Historically Berkeley-derived implementations have passed only one object
5098	* at a time, but this API allows multiple objects to be	5098	* at a time, but this API allows multiple objects to be
5099	* passed in a single call to sendmsg() or recvmsg(). The following example	5099	* passed in a single call to sendmsg() or recvmsg(). The following example
5100	* shows two ancillary data objects in a control buffer.	5100	* shows two ancillary data objects in a control buffer.
5101	*	5101	*
5102	* \|<--------------------------- msg_controllen -------------------------->\|	5102	* \|<--------------------------- msg_controllen -------------------------->\|
5103	* \| \|	5103	* \| \|
5104	*	5104	*
5105	* \|<----- ancillary data object ----->\|<----- ancillary data object ----->\|	5105	* \|<----- ancillary data object ----->\|<----- ancillary data object ----->\|
5106	*	5106	*
5107	* \|<---------- CMSG_SPACE() --------->\|<---------- CMSG_SPACE() --------->\|	5107	* \|<---------- CMSG_SPACE() --------->\|<---------- CMSG_SPACE() --------->\|
5108	* \| \| \|	5108	* \| \| \|
5109	*	5109	*
5110	* \|<---------- cmsg_len ---------->\| \|<--------- cmsg_len ----------->\| \|	5110	* \|<---------- cmsg_len ---------->\| \|<--------- cmsg_len ----------->\| \|
5111	*	5111	*
5112	* \|<--------- CMSG_LEN() --------->\| \|<-------- CMSG_LEN() ---------->\| \|	5112	* \|<--------- CMSG_LEN() --------->\| \|<-------- CMSG_LEN() ---------->\| \|
5113	* \| \| \| \| \|	5113	* \| \| \| \| \|
5114	*	5114	*
5115	* +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+	5115	* +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5116	* \|cmsg_\|cmsg_\|cmsg_\|XX\| \|XX\|cmsg_\|cmsg_\|cmsg_\|XX\| \|XX\|	5116	* \|cmsg_\|cmsg_\|cmsg_\|XX\| \|XX\|cmsg_\|cmsg_\|cmsg_\|XX\| \|XX\|
5117	*	5117	*
5118	* \|len \|level\|type \|XX\|cmsg_data[]\|XX\|len \|level\|type \|XX\|cmsg_data[]\|XX\|	5118	* \|len \|level\|type \|XX\|cmsg_data[]\|XX\|len \|level\|type \|XX\|cmsg_data[]\|XX\|
5119	*	5119	*
5120	* +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+	5120	* +-----+-----+-----+--+-----------+--+-----+-----+-----+--+-----------+--+
5121	* ^	5121	* ^
5122	* \|	5122	* \|
5123	*	5123	*
5124	* msg_control	5124	* msg_control
5125	* points here	5125	* points here
5126	*/	5126	*/
5127	SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg,	5127	SCTP_STATIC int sctp_msghdr_parse(const struct msghdr *msg,
5128	sctp_cmsgs_t *cmsgs)	5128	sctp_cmsgs_t *cmsgs)
5129	{	5129	{
5130	struct cmsghdr *cmsg;	5130	struct cmsghdr *cmsg;
5131		5131
5132	for (cmsg = CMSG_FIRSTHDR(msg);	5132	for (cmsg = CMSG_FIRSTHDR(msg);
5133	cmsg != NULL;	5133	cmsg != NULL;
5134	cmsg = CMSG_NXTHDR((struct msghdr*)msg, cmsg)) {	5134	cmsg = CMSG_NXTHDR((struct msghdr*)msg, cmsg)) {
5135	if (!CMSG_OK(msg, cmsg))	5135	if (!CMSG_OK(msg, cmsg))
5136	return -EINVAL;	5136	return -EINVAL;
5137		5137
5138	/* Should we parse this header or ignore? */	5138	/* Should we parse this header or ignore? */
5139	if (cmsg->cmsg_level != IPPROTO_SCTP)	5139	if (cmsg->cmsg_level != IPPROTO_SCTP)
5140	continue;	5140	continue;
5141		5141
5142	/* Strictly check lengths following example in SCM code. */	5142	/* Strictly check lengths following example in SCM code. */
5143	switch (cmsg->cmsg_type) {	5143	switch (cmsg->cmsg_type) {
5144	case SCTP_INIT:	5144	case SCTP_INIT:
5145	/* SCTP Socket API Extension	5145	/* SCTP Socket API Extension
5146	* 5.2.1 SCTP Initiation Structure (SCTP_INIT)	5146	* 5.2.1 SCTP Initiation Structure (SCTP_INIT)
5147	*	5147	*
5148	* This cmsghdr structure provides information for	5148	* This cmsghdr structure provides information for
5149	* initializing new SCTP associations with sendmsg().	5149	* initializing new SCTP associations with sendmsg().
5150	* The SCTP_INITMSG socket option uses this same data	5150	* The SCTP_INITMSG socket option uses this same data
5151	* structure. This structure is not used for	5151	* structure. This structure is not used for
5152	* recvmsg().	5152	* recvmsg().
5153	*	5153	*
5154	* cmsg_level cmsg_type cmsg_data[]	5154	* cmsg_level cmsg_type cmsg_data[]
5155	* ------------ ------------ ----------------------	5155	* ------------ ------------ ----------------------
5156	* IPPROTO_SCTP SCTP_INIT struct sctp_initmsg	5156	* IPPROTO_SCTP SCTP_INIT struct sctp_initmsg
5157	*/	5157	*/
5158	if (cmsg->cmsg_len !=	5158	if (cmsg->cmsg_len !=
5159	CMSG_LEN(sizeof(struct sctp_initmsg)))	5159	CMSG_LEN(sizeof(struct sctp_initmsg)))
5160	return -EINVAL;	5160	return -EINVAL;
5161	cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg);	5161	cmsgs->init = (struct sctp_initmsg *)CMSG_DATA(cmsg);
5162	break;	5162	break;
5163		5163
5164	case SCTP_SNDRCV:	5164	case SCTP_SNDRCV:
5165	/* SCTP Socket API Extension	5165	/* SCTP Socket API Extension
5166	* 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV)	5166	* 5.2.2 SCTP Header Information Structure(SCTP_SNDRCV)
5167	*	5167	*
5168	* This cmsghdr structure specifies SCTP options for	5168	* This cmsghdr structure specifies SCTP options for
5169	* sendmsg() and describes SCTP header information	5169	* sendmsg() and describes SCTP header information
5170	* about a received message through recvmsg().	5170	* about a received message through recvmsg().
5171	*	5171	*
5172	* cmsg_level cmsg_type cmsg_data[]	5172	* cmsg_level cmsg_type cmsg_data[]
5173	* ------------ ------------ ----------------------	5173	* ------------ ------------ ----------------------
5174	* IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo	5174	* IPPROTO_SCTP SCTP_SNDRCV struct sctp_sndrcvinfo
5175	*/	5175	*/
5176	if (cmsg->cmsg_len !=	5176	if (cmsg->cmsg_len !=
5177	CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))	5177	CMSG_LEN(sizeof(struct sctp_sndrcvinfo)))
5178	return -EINVAL;	5178	return -EINVAL;
5179		5179
5180	cmsgs->info =	5180	cmsgs->info =
5181	(struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);	5181	(struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
5182		5182
5183	/* Minimally, validate the sinfo_flags. */	5183	/* Minimally, validate the sinfo_flags. */
5184	if (cmsgs->info->sinfo_flags &	5184	if (cmsgs->info->sinfo_flags &
5185	~(SCTP_UNORDERED \| SCTP_ADDR_OVER \|	5185	~(SCTP_UNORDERED \| SCTP_ADDR_OVER \|
5186	SCTP_ABORT \| SCTP_EOF))	5186	SCTP_ABORT \| SCTP_EOF))
5187	return -EINVAL;	5187	return -EINVAL;
5188	break;	5188	break;
5189		5189
5190	default:	5190	default:
5191	return -EINVAL;	5191	return -EINVAL;
5192	};	5192	};
5193	}	5193	}
5194	return 0;	5194	return 0;
5195	}	5195	}
5196		5196
5197	/*	5197	/*
5198	* Wait for a packet..	5198	* Wait for a packet..
5199	* Note: This function is the same function as in core/datagram.c	5199	* Note: This function is the same function as in core/datagram.c
5200	* with a few modifications to make lksctp work.	5200	* with a few modifications to make lksctp work.
5201	*/	5201	*/
5202	static int sctp_wait_for_packet(struct sock * sk, int err, long timeo_p)	5202	static int sctp_wait_for_packet(struct sock * sk, int err, long timeo_p)
5203	{	5203	{
5204	int error;	5204	int error;
5205	DEFINE_WAIT(wait);	5205	DEFINE_WAIT(wait);
5206		5206
5207	prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);	5207	prepare_to_wait_exclusive(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
5208		5208
5209	/* Socket errors? */	5209	/* Socket errors? */
5210	error = sock_error(sk);	5210	error = sock_error(sk);
5211	if (error)	5211	if (error)
5212	goto out;	5212	goto out;
5213		5213
5214	if (!skb_queue_empty(&sk->sk_receive_queue))	5214	if (!skb_queue_empty(&sk->sk_receive_queue))
5215	goto ready;	5215	goto ready;
5216		5216
5217	/* Socket shut down? */	5217	/* Socket shut down? */
5218	if (sk->sk_shutdown & RCV_SHUTDOWN)	5218	if (sk->sk_shutdown & RCV_SHUTDOWN)
5219	goto out;	5219	goto out;
5220		5220
5221	/* Sequenced packets can come disconnected. If so we report the	5221	/* Sequenced packets can come disconnected. If so we report the
5222	* problem.	5222	* problem.
5223	*/	5223	*/
5224	error = -ENOTCONN;	5224	error = -ENOTCONN;
5225		5225
5226	/* Is there a good reason to think that we may receive some data? */	5226	/* Is there a good reason to think that we may receive some data? */
5227	if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))	5227	if (list_empty(&sctp_sk(sk)->ep->asocs) && !sctp_sstate(sk, LISTENING))
5228	goto out;	5228	goto out;
5229		5229
5230	/* Handle signals. */	5230	/* Handle signals. */
5231	if (signal_pending(current))	5231	if (signal_pending(current))
5232	goto interrupted;	5232	goto interrupted;
5233		5233
5234	/* Let another process have a go. Since we are going to sleep	5234	/* Let another process have a go. Since we are going to sleep
5235	* anyway. Note: This may cause odd behaviors if the message	5235	* anyway. Note: This may cause odd behaviors if the message
5236	* does not fit in the user's buffer, but this seems to be the	5236	* does not fit in the user's buffer, but this seems to be the
5237	* only way to honor MSG_DONTWAIT realistically.	5237	* only way to honor MSG_DONTWAIT realistically.
5238	*/	5238	*/
5239	sctp_release_sock(sk);	5239	sctp_release_sock(sk);
5240	timeo_p = schedule_timeout(timeo_p);	5240	timeo_p = schedule_timeout(timeo_p);
5241	sctp_lock_sock(sk);	5241	sctp_lock_sock(sk);
5242		5242
5243	ready:	5243	ready:
5244	finish_wait(sk->sk_sleep, &wait);	5244	finish_wait(sk->sk_sleep, &wait);
5245	return 0;	5245	return 0;
5246		5246
5247	interrupted:	5247	interrupted:
5248	error = sock_intr_errno(*timeo_p);	5248	error = sock_intr_errno(*timeo_p);
5249		5249
5250	out:	5250	out:
5251	finish_wait(sk->sk_sleep, &wait);	5251	finish_wait(sk->sk_sleep, &wait);
5252	*err = error;	5252	*err = error;
5253	return error;	5253	return error;
5254	}	5254	}
5255		5255
5256	/* Receive a datagram.	5256	/* Receive a datagram.
5257	* Note: This is pretty much the same routine as in core/datagram.c	5257	* Note: This is pretty much the same routine as in core/datagram.c
5258	* with a few changes to make lksctp work.	5258	* with a few changes to make lksctp work.
5259	*/	5259	*/
5260	static struct sk_buff sctp_skb_recv_datagram(struct sock sk, int flags,	5260	static struct sk_buff sctp_skb_recv_datagram(struct sock sk, int flags,
5261	int noblock, int *err)	5261	int noblock, int *err)
5262	{	5262	{
5263	int error;	5263	int error;
5264	struct sk_buff *skb;	5264	struct sk_buff *skb;
5265	long timeo;	5265	long timeo;
5266		5266
5267	timeo = sock_rcvtimeo(sk, noblock);	5267	timeo = sock_rcvtimeo(sk, noblock);
5268		5268
5269	SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n",	5269	SCTP_DEBUG_PRINTK("Timeout: timeo: %ld, MAX: %ld.\n",
5270	timeo, MAX_SCHEDULE_TIMEOUT);	5270	timeo, MAX_SCHEDULE_TIMEOUT);
5271		5271
5272	do {	5272	do {
5273	/* Again only user level code calls this function,	5273	/* Again only user level code calls this function,
5274	* so nothing interrupt level	5274	* so nothing interrupt level
5275	* will suddenly eat the receive_queue.	5275	* will suddenly eat the receive_queue.
5276	*	5276	*
5277	* Look at current nfs client by the way...	5277	* Look at current nfs client by the way...
5278	* However, this function was corrent in any case. 8)	5278	* However, this function was corrent in any case. 8)
5279	*/	5279	*/
5280	if (flags & MSG_PEEK) {	5280	if (flags & MSG_PEEK) {
5281	spin_lock_bh(&sk->sk_receive_queue.lock);	5281	spin_lock_bh(&sk->sk_receive_queue.lock);
5282	skb = skb_peek(&sk->sk_receive_queue);	5282	skb = skb_peek(&sk->sk_receive_queue);
5283	if (skb)	5283	if (skb)
5284	atomic_inc(&skb->users);	5284	atomic_inc(&skb->users);
5285	spin_unlock_bh(&sk->sk_receive_queue.lock);	5285	spin_unlock_bh(&sk->sk_receive_queue.lock);
5286	} else {	5286	} else {
5287	skb = skb_dequeue(&sk->sk_receive_queue);	5287	skb = skb_dequeue(&sk->sk_receive_queue);
5288	}	5288	}
5289		5289
5290	if (skb)	5290	if (skb)
5291	return skb;	5291	return skb;
5292		5292
5293	/* Caller is allowed not to check sk->sk_err before calling. */	5293	/* Caller is allowed not to check sk->sk_err before calling. */
5294	error = sock_error(sk);	5294	error = sock_error(sk);
5295	if (error)	5295	if (error)
5296	goto no_packet;	5296	goto no_packet;
5297		5297
5298	if (sk->sk_shutdown & RCV_SHUTDOWN)	5298	if (sk->sk_shutdown & RCV_SHUTDOWN)
5299	break;	5299	break;
5300		5300
5301	/* User doesn't want to wait. */	5301	/* User doesn't want to wait. */
5302	error = -EAGAIN;	5302	error = -EAGAIN;
5303	if (!timeo)	5303	if (!timeo)
5304	goto no_packet;	5304	goto no_packet;
5305	} while (sctp_wait_for_packet(sk, err, &timeo) == 0);	5305	} while (sctp_wait_for_packet(sk, err, &timeo) == 0);
5306		5306
5307	return NULL;	5307	return NULL;
5308		5308
5309	no_packet:	5309	no_packet:
5310	*err = error;	5310	*err = error;
5311	return NULL;	5311	return NULL;
5312	}	5312	}
5313		5313
5314	/* If sndbuf has changed, wake up per association sndbuf waiters. */	5314	/* If sndbuf has changed, wake up per association sndbuf waiters. */
5315	static void __sctp_write_space(struct sctp_association *asoc)	5315	static void __sctp_write_space(struct sctp_association *asoc)
5316	{	5316	{
5317	struct sock *sk = asoc->base.sk;	5317	struct sock *sk = asoc->base.sk;
5318	struct socket *sock = sk->sk_socket;	5318	struct socket *sock = sk->sk_socket;
5319		5319
5320	if ((sctp_wspace(asoc) > 0) && sock) {	5320	if ((sctp_wspace(asoc) > 0) && sock) {
5321	if (waitqueue_active(&asoc->wait))	5321	if (waitqueue_active(&asoc->wait))
5322	wake_up_interruptible(&asoc->wait);	5322	wake_up_interruptible(&asoc->wait);
5323		5323
5324	if (sctp_writeable(sk)) {	5324	if (sctp_writeable(sk)) {
5325	if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))	5325	if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
5326	wake_up_interruptible(sk->sk_sleep);	5326	wake_up_interruptible(sk->sk_sleep);
5327		5327
5328	/* Note that we try to include the Async I/O support	5328	/* Note that we try to include the Async I/O support
5329	* here by modeling from the current TCP/UDP code.	5329	* here by modeling from the current TCP/UDP code.
5330	* We have not tested with it yet.	5330	* We have not tested with it yet.
5331	*/	5331	*/
5332	if (sock->fasync_list &&	5332	if (sock->fasync_list &&
5333	!(sk->sk_shutdown & SEND_SHUTDOWN))	5333	!(sk->sk_shutdown & SEND_SHUTDOWN))
5334	sock_wake_async(sock, 2, POLL_OUT);	5334	sock_wake_async(sock, 2, POLL_OUT);
5335	}	5335	}
5336	}	5336	}
5337	}	5337	}
5338		5338
5339	/* Do accounting for the sndbuf space.	5339	/* Do accounting for the sndbuf space.
5340	* Decrement the used sndbuf space of the corresponding association by the	5340	* Decrement the used sndbuf space of the corresponding association by the
5341	* data size which was just transmitted(freed).	5341	* data size which was just transmitted(freed).
5342	*/	5342	*/
5343	static void sctp_wfree(struct sk_buff *skb)	5343	static void sctp_wfree(struct sk_buff *skb)
5344	{	5344	{
5345	struct sctp_association *asoc;	5345	struct sctp_association *asoc;
5346	struct sctp_chunk *chunk;	5346	struct sctp_chunk *chunk;
5347	struct sock *sk;	5347	struct sock *sk;
5348		5348
5349	/* Get the saved chunk pointer. */	5349	/* Get the saved chunk pointer. */
5350	chunk = ((struct sctp_chunk *)(skb->cb));	5350	chunk = ((struct sctp_chunk *)(skb->cb));
5351	asoc = chunk->asoc;	5351	asoc = chunk->asoc;
5352	sk = asoc->base.sk;	5352	sk = asoc->base.sk;
5353	asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) +	5353	asoc->sndbuf_used -= SCTP_DATA_SNDSIZE(chunk) +
5354	sizeof(struct sk_buff) +	5354	sizeof(struct sk_buff) +
5355	sizeof(struct sctp_chunk);	5355	sizeof(struct sctp_chunk);
5356		5356
5357	atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);	5357	atomic_sub(sizeof(struct sctp_chunk), &sk->sk_wmem_alloc);
5358		5358
5359	sock_wfree(skb);	5359	sock_wfree(skb);
5360	__sctp_write_space(asoc);	5360	__sctp_write_space(asoc);
5361		5361
5362	sctp_association_put(asoc);	5362	sctp_association_put(asoc);
5363	}	5363	}
5364		5364
5365	/* Helper function to wait for space in the sndbuf. */	5365	/* Helper function to wait for space in the sndbuf. */
5366	static int sctp_wait_for_sndbuf(struct sctp_association asoc, long timeo_p,	5366	static int sctp_wait_for_sndbuf(struct sctp_association asoc, long timeo_p,
5367	size_t msg_len)	5367	size_t msg_len)
5368	{	5368	{
5369	struct sock *sk = asoc->base.sk;	5369	struct sock *sk = asoc->base.sk;
5370	int err = 0;	5370	int err = 0;
5371	long current_timeo = *timeo_p;	5371	long current_timeo = *timeo_p;
5372	DEFINE_WAIT(wait);	5372	DEFINE_WAIT(wait);
5373		5373
5374	SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n",	5374	SCTP_DEBUG_PRINTK("wait_for_sndbuf: asoc=%p, timeo=%ld, msg_len=%zu\n",
5375	asoc, (long)(*timeo_p), msg_len);	5375	asoc, (long)(*timeo_p), msg_len);
5376		5376
5377	/* Increment the association's refcnt. */	5377	/* Increment the association's refcnt. */
5378	sctp_association_hold(asoc);	5378	sctp_association_hold(asoc);
5379		5379
5380	/* Wait on the association specific sndbuf space. */	5380	/* Wait on the association specific sndbuf space. */
5381	for (;;) {	5381	for (;;) {
5382	prepare_to_wait_exclusive(&asoc->wait, &wait,	5382	prepare_to_wait_exclusive(&asoc->wait, &wait,
5383	TASK_INTERRUPTIBLE);	5383	TASK_INTERRUPTIBLE);
5384	if (!*timeo_p)	5384	if (!*timeo_p)
5385	goto do_nonblock;	5385	goto do_nonblock;
5386	if (sk->sk_err \|\| asoc->state >= SCTP_STATE_SHUTDOWN_PENDING \|\|	5386	if (sk->sk_err \|\| asoc->state >= SCTP_STATE_SHUTDOWN_PENDING \|\|
5387	asoc->base.dead)	5387	asoc->base.dead)
5388	goto do_error;	5388	goto do_error;
5389	if (signal_pending(current))	5389	if (signal_pending(current))
5390	goto do_interrupted;	5390	goto do_interrupted;
5391	if (msg_len <= sctp_wspace(asoc))	5391	if (msg_len <= sctp_wspace(asoc))
5392	break;	5392	break;
5393		5393
5394	/* Let another process have a go. Since we are going	5394	/* Let another process have a go. Since we are going
5395	* to sleep anyway.	5395	* to sleep anyway.
5396	*/	5396	*/
5397	sctp_release_sock(sk);	5397	sctp_release_sock(sk);
5398	current_timeo = schedule_timeout(current_timeo);	5398	current_timeo = schedule_timeout(current_timeo);
5399	BUG_ON(sk != asoc->base.sk);	5399	BUG_ON(sk != asoc->base.sk);
5400	sctp_lock_sock(sk);	5400	sctp_lock_sock(sk);
5401		5401
5402	*timeo_p = current_timeo;	5402	*timeo_p = current_timeo;
5403	}	5403	}
5404		5404
5405	out:	5405	out:
5406	finish_wait(&asoc->wait, &wait);	5406	finish_wait(&asoc->wait, &wait);
5407		5407
5408	/* Release the association's refcnt. */	5408	/* Release the association's refcnt. */
5409	sctp_association_put(asoc);	5409	sctp_association_put(asoc);
5410		5410
5411	return err;	5411	return err;
5412		5412
5413	do_error:	5413	do_error:
5414	err = -EPIPE;	5414	err = -EPIPE;
5415	goto out;	5415	goto out;
5416		5416
5417	do_interrupted:	5417	do_interrupted:
5418	err = sock_intr_errno(*timeo_p);	5418	err = sock_intr_errno(*timeo_p);
5419	goto out;	5419	goto out;
5420		5420
5421	do_nonblock:	5421	do_nonblock:
5422	err = -EAGAIN;	5422	err = -EAGAIN;
5423	goto out;	5423	goto out;
5424	}	5424	}
5425		5425
5426	/* If socket sndbuf has changed, wake up all per association waiters. */	5426	/* If socket sndbuf has changed, wake up all per association waiters. */
5427	void sctp_write_space(struct sock *sk)	5427	void sctp_write_space(struct sock *sk)
5428	{	5428	{
5429	struct sctp_association *asoc;	5429	struct sctp_association *asoc;
5430	struct list_head *pos;	5430	struct list_head *pos;
5431		5431
5432	/* Wake up the tasks in each wait queue. */	5432	/* Wake up the tasks in each wait queue. */
5433	list_for_each(pos, &((sctp_sk(sk))->ep->asocs)) {	5433	list_for_each(pos, &((sctp_sk(sk))->ep->asocs)) {
5434	asoc = list_entry(pos, struct sctp_association, asocs);	5434	asoc = list_entry(pos, struct sctp_association, asocs);
5435	__sctp_write_space(asoc);	5435	__sctp_write_space(asoc);
5436	}	5436	}
5437	}	5437	}
5438		5438
5439	/* Is there any sndbuf space available on the socket?	5439	/* Is there any sndbuf space available on the socket?
5440	*	5440	*
5441	* Note that sk_wmem_alloc is the sum of the send buffers on all of the	5441	* Note that sk_wmem_alloc is the sum of the send buffers on all of the
5442	* associations on the same socket. For a UDP-style socket with	5442	* associations on the same socket. For a UDP-style socket with
5443	* multiple associations, it is possible for it to be "unwriteable"	5443	* multiple associations, it is possible for it to be "unwriteable"
5444	* prematurely. I assume that this is acceptable because	5444	* prematurely. I assume that this is acceptable because
5445	* a premature "unwriteable" is better than an accidental "writeable" which	5445	* a premature "unwriteable" is better than an accidental "writeable" which
5446	* would cause an unwanted block under certain circumstances. For the 1-1	5446	* would cause an unwanted block under certain circumstances. For the 1-1
5447	* UDP-style sockets or TCP-style sockets, this code should work.	5447	* UDP-style sockets or TCP-style sockets, this code should work.
5448	* - Daisy	5448	* - Daisy
5449	*/	5449	*/
5450	static int sctp_writeable(struct sock *sk)	5450	static int sctp_writeable(struct sock *sk)
5451	{	5451	{
5452	int amt = 0;	5452	int amt = 0;
5453		5453
5454	amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);	5454	amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
5455	if (amt < 0)	5455	if (amt < 0)
5456	amt = 0;	5456	amt = 0;
5457	return amt;	5457	return amt;
5458	}	5458	}
5459		5459
5460	/* Wait for an association to go into ESTABLISHED state. If timeout is 0,	5460	/* Wait for an association to go into ESTABLISHED state. If timeout is 0,
5461	* returns immediately with EINPROGRESS.	5461	* returns immediately with EINPROGRESS.
5462	*/	5462	*/
5463	static int sctp_wait_for_connect(struct sctp_association asoc, long timeo_p)	5463	static int sctp_wait_for_connect(struct sctp_association asoc, long timeo_p)
5464	{	5464	{
5465	struct sock *sk = asoc->base.sk;	5465	struct sock *sk = asoc->base.sk;
5466	int err = 0;	5466	int err = 0;
5467	long current_timeo = *timeo_p;	5467	long current_timeo = *timeo_p;
5468	DEFINE_WAIT(wait);	5468	DEFINE_WAIT(wait);
5469		5469
5470	SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __FUNCTION__, asoc,	5470	SCTP_DEBUG_PRINTK("%s: asoc=%p, timeo=%ld\n", __FUNCTION__, asoc,
5471	(long)(*timeo_p));	5471	(long)(*timeo_p));
5472		5472
5473	/* Increment the association's refcnt. */	5473	/* Increment the association's refcnt. */
5474	sctp_association_hold(asoc);	5474	sctp_association_hold(asoc);
5475		5475
5476	for (;;) {	5476	for (;;) {
5477	prepare_to_wait_exclusive(&asoc->wait, &wait,	5477	prepare_to_wait_exclusive(&asoc->wait, &wait,
5478	TASK_INTERRUPTIBLE);	5478	TASK_INTERRUPTIBLE);
5479	if (!*timeo_p)	5479	if (!*timeo_p)
5480	goto do_nonblock;	5480	goto do_nonblock;
5481	if (sk->sk_shutdown & RCV_SHUTDOWN)	5481	if (sk->sk_shutdown & RCV_SHUTDOWN)
5482	break;	5482	break;
5483	if (sk->sk_err \|\| asoc->state >= SCTP_STATE_SHUTDOWN_PENDING \|\|	5483	if (sk->sk_err \|\| asoc->state >= SCTP_STATE_SHUTDOWN_PENDING \|\|
5484	asoc->base.dead)	5484	asoc->base.dead)
5485	goto do_error;	5485	goto do_error;
5486	if (signal_pending(current))	5486	if (signal_pending(current))
5487	goto do_interrupted;	5487	goto do_interrupted;
5488		5488
5489	if (sctp_state(asoc, ESTABLISHED))	5489	if (sctp_state(asoc, ESTABLISHED))
5490	break;	5490	break;
5491		5491
5492	/* Let another process have a go. Since we are going	5492	/* Let another process have a go. Since we are going
5493	* to sleep anyway.	5493	* to sleep anyway.
5494	*/	5494	*/
5495	sctp_release_sock(sk);	5495	sctp_release_sock(sk);
5496	current_timeo = schedule_timeout(current_timeo);	5496	current_timeo = schedule_timeout(current_timeo);
5497	sctp_lock_sock(sk);	5497	sctp_lock_sock(sk);
5498		5498
5499	*timeo_p = current_timeo;	5499	*timeo_p = current_timeo;
5500	}	5500	}
5501		5501
5502	out:	5502	out:
5503	finish_wait(&asoc->wait, &wait);	5503	finish_wait(&asoc->wait, &wait);
5504		5504
5505	/* Release the association's refcnt. */	5505	/* Release the association's refcnt. */
5506	sctp_association_put(asoc);	5506	sctp_association_put(asoc);
5507		5507
5508	return err;	5508	return err;
5509		5509
5510	do_error:	5510	do_error:
5511	if (asoc->init_err_counter + 1 > asoc->max_init_attempts)	5511	if (asoc->init_err_counter + 1 > asoc->max_init_attempts)
5512	err = -ETIMEDOUT;	5512	err = -ETIMEDOUT;
5513	else	5513	else
5514	err = -ECONNREFUSED;	5514	err = -ECONNREFUSED;
5515	goto out;	5515	goto out;
5516		5516
5517	do_interrupted:	5517	do_interrupted:
5518	err = sock_intr_errno(*timeo_p);	5518	err = sock_intr_errno(*timeo_p);
5519	goto out;	5519	goto out;
5520		5520
5521	do_nonblock:	5521	do_nonblock:
5522	err = -EINPROGRESS;	5522	err = -EINPROGRESS;
5523	goto out;	5523	goto out;
5524	}	5524	}
5525		5525
5526	static int sctp_wait_for_accept(struct sock *sk, long timeo)	5526	static int sctp_wait_for_accept(struct sock *sk, long timeo)
5527	{	5527	{
5528	struct sctp_endpoint *ep;	5528	struct sctp_endpoint *ep;
5529	int err = 0;	5529	int err = 0;
5530	DEFINE_WAIT(wait);	5530	DEFINE_WAIT(wait);
5531		5531
5532	ep = sctp_sk(sk)->ep;	5532	ep = sctp_sk(sk)->ep;
5533		5533
5534		5534
5535	for (;;) {	5535	for (;;) {
5536	prepare_to_wait_exclusive(sk->sk_sleep, &wait,	5536	prepare_to_wait_exclusive(sk->sk_sleep, &wait,
5537	TASK_INTERRUPTIBLE);	5537	TASK_INTERRUPTIBLE);
5538		5538
5539	if (list_empty(&ep->asocs)) {	5539	if (list_empty(&ep->asocs)) {
5540	sctp_release_sock(sk);	5540	sctp_release_sock(sk);
5541	timeo = schedule_timeout(timeo);	5541	timeo = schedule_timeout(timeo);
5542	sctp_lock_sock(sk);	5542	sctp_lock_sock(sk);
5543	}	5543	}
5544		5544
5545	err = -EINVAL;	5545	err = -EINVAL;
5546	if (!sctp_sstate(sk, LISTENING))	5546	if (!sctp_sstate(sk, LISTENING))
5547	break;	5547	break;
5548		5548
5549	err = 0;	5549	err = 0;
5550	if (!list_empty(&ep->asocs))	5550	if (!list_empty(&ep->asocs))
5551	break;	5551	break;
5552		5552
5553	err = sock_intr_errno(timeo);	5553	err = sock_intr_errno(timeo);
5554	if (signal_pending(current))	5554	if (signal_pending(current))
5555	break;	5555	break;
5556		5556
5557	err = -EAGAIN;	5557	err = -EAGAIN;
5558	if (!timeo)	5558	if (!timeo)
5559	break;	5559	break;
5560	}	5560	}
5561		5561
5562	finish_wait(sk->sk_sleep, &wait);	5562	finish_wait(sk->sk_sleep, &wait);
5563		5563
5564	return err;	5564	return err;
5565	}	5565	}
5566		5566
5567	void sctp_wait_for_close(struct sock *sk, long timeout)	5567	void sctp_wait_for_close(struct sock *sk, long timeout)
5568	{	5568	{
5569	DEFINE_WAIT(wait);	5569	DEFINE_WAIT(wait);
5570		5570
5571	do {	5571	do {
5572	prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);	5572	prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
5573	if (list_empty(&sctp_sk(sk)->ep->asocs))	5573	if (list_empty(&sctp_sk(sk)->ep->asocs))
5574	break;	5574	break;
5575	sctp_release_sock(sk);	5575	sctp_release_sock(sk);
5576	timeout = schedule_timeout(timeout);	5576	timeout = schedule_timeout(timeout);
5577	sctp_lock_sock(sk);	5577	sctp_lock_sock(sk);
5578	} while (!signal_pending(current) && timeout);	5578	} while (!signal_pending(current) && timeout);
5579		5579
5580	finish_wait(sk->sk_sleep, &wait);	5580	finish_wait(sk->sk_sleep, &wait);
5581	}	5581	}
5582		5582
5583	/* Populate the fields of the newsk from the oldsk and migrate the assoc	5583	/* Populate the fields of the newsk from the oldsk and migrate the assoc
5584	* and its messages to the newsk.	5584	* and its messages to the newsk.
5585	*/	5585	*/
5586	static void sctp_sock_migrate(struct sock oldsk, struct sock newsk,	5586	static void sctp_sock_migrate(struct sock oldsk, struct sock newsk,
5587	struct sctp_association *assoc,	5587	struct sctp_association *assoc,
5588	sctp_socket_type_t type)	5588	sctp_socket_type_t type)
5589	{	5589	{
5590	struct sctp_sock *oldsp = sctp_sk(oldsk);	5590	struct sctp_sock *oldsp = sctp_sk(oldsk);
5591	struct sctp_sock *newsp = sctp_sk(newsk);	5591	struct sctp_sock *newsp = sctp_sk(newsk);
5592	struct sctp_bind_bucket pp; / hash list port iterator */	5592	struct sctp_bind_bucket pp; / hash list port iterator */
5593	struct sctp_endpoint *newep = newsp->ep;	5593	struct sctp_endpoint *newep = newsp->ep;
5594	struct sk_buff skb, tmp;	5594	struct sk_buff skb, tmp;
5595	struct sctp_ulpevent *event;	5595	struct sctp_ulpevent *event;
5596	int flags = 0;	5596	int flags = 0;
5597		5597
5598	/* Migrate socket buffer sizes and all the socket level options to the	5598	/* Migrate socket buffer sizes and all the socket level options to the
5599	* new socket.	5599	* new socket.
5600	*/	5600	*/
5601	newsk->sk_sndbuf = oldsk->sk_sndbuf;	5601	newsk->sk_sndbuf = oldsk->sk_sndbuf;
5602	newsk->sk_rcvbuf = oldsk->sk_rcvbuf;	5602	newsk->sk_rcvbuf = oldsk->sk_rcvbuf;
5603	/* Brute force copy old sctp opt. */	5603	/* Brute force copy old sctp opt. */
5604	inet_sk_copy_descendant(newsk, oldsk);	5604	inet_sk_copy_descendant(newsk, oldsk);
5605		5605
5606	/* Restore the ep value that was overwritten with the above structure	5606	/* Restore the ep value that was overwritten with the above structure
5607	* copy.	5607	* copy.
5608	*/	5608	*/
5609	newsp->ep = newep;	5609	newsp->ep = newep;
5610	newsp->hmac = NULL;	5610	newsp->hmac = NULL;
5611		5611
5612	/* Hook this new socket in to the bind_hash list. */	5612	/* Hook this new socket in to the bind_hash list. */
5613	pp = sctp_sk(oldsk)->bind_hash;	5613	pp = sctp_sk(oldsk)->bind_hash;
5614	sk_add_bind_node(newsk, &pp->owner);	5614	sk_add_bind_node(newsk, &pp->owner);
5615	sctp_sk(newsk)->bind_hash = pp;	5615	sctp_sk(newsk)->bind_hash = pp;
5616	inet_sk(newsk)->num = inet_sk(oldsk)->num;	5616	inet_sk(newsk)->num = inet_sk(oldsk)->num;
5617		5617
5618	/* Copy the bind_addr list from the original endpoint to the new	5618	/* Copy the bind_addr list from the original endpoint to the new
5619	* endpoint so that we can handle restarts properly	5619	* endpoint so that we can handle restarts properly
5620	*/	5620	*/
5621	if (PF_INET6 == assoc->base.sk->sk_family)	5621	if (PF_INET6 == assoc->base.sk->sk_family)
5622	flags = SCTP_ADDR6_ALLOWED;	5622	flags = SCTP_ADDR6_ALLOWED;
5623	if (assoc->peer.ipv4_address)	5623	if (assoc->peer.ipv4_address)
5624	flags \|= SCTP_ADDR4_PEERSUPP;	5624	flags \|= SCTP_ADDR4_PEERSUPP;
5625	if (assoc->peer.ipv6_address)	5625	if (assoc->peer.ipv6_address)
5626	flags \|= SCTP_ADDR6_PEERSUPP;	5626	flags \|= SCTP_ADDR6_PEERSUPP;
5627	sctp_bind_addr_copy(&newsp->ep->base.bind_addr,	5627	sctp_bind_addr_copy(&newsp->ep->base.bind_addr,
5628	&oldsp->ep->base.bind_addr,	5628	&oldsp->ep->base.bind_addr,
5629	SCTP_SCOPE_GLOBAL, GFP_KERNEL, flags);	5629	SCTP_SCOPE_GLOBAL, GFP_KERNEL, flags);
5630		5630
5631	/* Move any messages in the old socket's receive queue that are for the	5631	/* Move any messages in the old socket's receive queue that are for the
5632	* peeled off association to the new socket's receive queue.	5632	* peeled off association to the new socket's receive queue.
5633	*/	5633	*/
5634	sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {	5634	sctp_skb_for_each(skb, &oldsk->sk_receive_queue, tmp) {
5635	event = sctp_skb2event(skb);	5635	event = sctp_skb2event(skb);
5636	if (event->asoc == assoc) {	5636	if (event->asoc == assoc) {
5637	sock_rfree(skb);	5637	sock_rfree(skb);
5638	__skb_unlink(skb, &oldsk->sk_receive_queue);	5638	__skb_unlink(skb, &oldsk->sk_receive_queue);
5639	__skb_queue_tail(&newsk->sk_receive_queue, skb);	5639	__skb_queue_tail(&newsk->sk_receive_queue, skb);
5640	skb_set_owner_r(skb, newsk);	5640	skb_set_owner_r(skb, newsk);
5641	}	5641	}
5642	}	5642	}
5643		5643
5644	/* Clean up any messages pending delivery due to partial	5644	/* Clean up any messages pending delivery due to partial
5645	* delivery. Three cases:	5645	* delivery. Three cases:
5646	* 1) No partial deliver; no work.	5646	* 1) No partial deliver; no work.
5647	* 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.	5647	* 2) Peeling off partial delivery; keep pd_lobby in new pd_lobby.
5648	* 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.	5648	* 3) Peeling off non-partial delivery; move pd_lobby to receive_queue.
5649	*/	5649	*/
5650	skb_queue_head_init(&newsp->pd_lobby);	5650	skb_queue_head_init(&newsp->pd_lobby);
5651	sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode;	5651	sctp_sk(newsk)->pd_mode = assoc->ulpq.pd_mode;
5652		5652
5653	if (sctp_sk(oldsk)->pd_mode) {	5653	if (sctp_sk(oldsk)->pd_mode) {
5654	struct sk_buff_head *queue;	5654	struct sk_buff_head *queue;
5655		5655
5656	/* Decide which queue to move pd_lobby skbs to. */	5656	/* Decide which queue to move pd_lobby skbs to. */
5657	if (assoc->ulpq.pd_mode) {	5657	if (assoc->ulpq.pd_mode) {
5658	queue = &newsp->pd_lobby;	5658	queue = &newsp->pd_lobby;
5659	} else	5659	} else
5660	queue = &newsk->sk_receive_queue;	5660	queue = &newsk->sk_receive_queue;
5661		5661
5662	/* Walk through the pd_lobby, looking for skbs that	5662	/* Walk through the pd_lobby, looking for skbs that
5663	* need moved to the new socket.	5663	* need moved to the new socket.
5664	*/	5664	*/
5665	sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {	5665	sctp_skb_for_each(skb, &oldsp->pd_lobby, tmp) {
5666	event = sctp_skb2event(skb);	5666	event = sctp_skb2event(skb);
5667	if (event->asoc == assoc) {	5667	if (event->asoc == assoc) {
5668	sock_rfree(skb);	5668	sock_rfree(skb);
5669	__skb_unlink(skb, &oldsp->pd_lobby);	5669	__skb_unlink(skb, &oldsp->pd_lobby);
5670	__skb_queue_tail(queue, skb);	5670	__skb_queue_tail(queue, skb);
5671	skb_set_owner_r(skb, newsk);	5671	skb_set_owner_r(skb, newsk);
5672	}	5672	}
5673	}	5673	}
5674		5674
5675	/* Clear up any skbs waiting for the partial	5675	/* Clear up any skbs waiting for the partial
5676	* delivery to finish.	5676	* delivery to finish.
5677	*/	5677	*/
5678	if (assoc->ulpq.pd_mode)	5678	if (assoc->ulpq.pd_mode)
5679	sctp_clear_pd(oldsk);	5679	sctp_clear_pd(oldsk);
5680		5680
5681	}	5681	}
5682		5682
5683	/* Set the type of socket to indicate that it is peeled off from the	5683	/* Set the type of socket to indicate that it is peeled off from the
5684	* original UDP-style socket or created with the accept() call on a	5684	* original UDP-style socket or created with the accept() call on a
5685	* TCP-style socket..	5685	* TCP-style socket..
5686	*/	5686	*/
5687	newsp->type = type;	5687	newsp->type = type;
5688		5688
5689	/* Mark the new socket "in-use" by the user so that any packets	5689	/* Mark the new socket "in-use" by the user so that any packets
5690	* that may arrive on the association after we've moved it are	5690	* that may arrive on the association after we've moved it are
5691	* queued to the backlog. This prevents a potential race between	5691	* queued to the backlog. This prevents a potential race between
5692	* backlog processing on the old socket and new-packet processing	5692	* backlog processing on the old socket and new-packet processing
5693	* on the new socket.	5693	* on the new socket.
5694	*/	5694	*/
5695	sctp_lock_sock(newsk);	5695	sctp_lock_sock(newsk);
5696	sctp_assoc_migrate(assoc, newsk);	5696	sctp_assoc_migrate(assoc, newsk);
5697		5697
5698	/* If the association on the newsk is already closed before accept()	5698	/* If the association on the newsk is already closed before accept()
5699	* is called, set RCV_SHUTDOWN flag.	5699	* is called, set RCV_SHUTDOWN flag.
5700	*/	5700	*/
5701	if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP))	5701	if (sctp_state(assoc, CLOSED) && sctp_style(newsk, TCP))
5702	newsk->sk_shutdown \|= RCV_SHUTDOWN;	5702	newsk->sk_shutdown \|= RCV_SHUTDOWN;
5703		5703
5704	newsk->sk_state = SCTP_SS_ESTABLISHED;	5704	newsk->sk_state = SCTP_SS_ESTABLISHED;
5705	sctp_release_sock(newsk);	5705	sctp_release_sock(newsk);
5706	}	5706	}
5707		5707
5708	/* This proto struct describes the ULP interface for SCTP. */	5708	/* This proto struct describes the ULP interface for SCTP. */
5709	struct proto sctp_prot = {	5709	struct proto sctp_prot = {
5710	.name = "SCTP",	5710	.name = "SCTP",
5711	.owner = THIS_MODULE,	5711	.owner = THIS_MODULE,
5712	.close = sctp_close,	5712	.close = sctp_close,
5713	.connect = sctp_connect,	5713	.connect = sctp_connect,
5714	.disconnect = sctp_disconnect,	5714	.disconnect = sctp_disconnect,
5715	.accept = sctp_accept,	5715	.accept = sctp_accept,
5716	.ioctl = sctp_ioctl,	5716	.ioctl = sctp_ioctl,
5717	.init = sctp_init_sock,	5717	.init = sctp_init_sock,
5718	.destroy = sctp_destroy_sock,	5718	.destroy = sctp_destroy_sock,
5719	.shutdown = sctp_shutdown,	5719	.shutdown = sctp_shutdown,
5720	.setsockopt = sctp_setsockopt,	5720	.setsockopt = sctp_setsockopt,
5721	.getsockopt = sctp_getsockopt,	5721	.getsockopt = sctp_getsockopt,
5722	.sendmsg = sctp_sendmsg,	5722	.sendmsg = sctp_sendmsg,
5723	.recvmsg = sctp_recvmsg,	5723	.recvmsg = sctp_recvmsg,
5724	.bind = sctp_bind,	5724	.bind = sctp_bind,
5725	.backlog_rcv = sctp_backlog_rcv,	5725	.backlog_rcv = sctp_backlog_rcv,
5726	.hash = sctp_hash,	5726	.hash = sctp_hash,
5727	.unhash = sctp_unhash,	5727	.unhash = sctp_unhash,
5728	.get_port = sctp_get_port,	5728	.get_port = sctp_get_port,
5729	.obj_size = sizeof(struct sctp_sock),	5729	.obj_size = sizeof(struct sctp_sock),
5730	};	5730	};
5731		5731
5732	#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)	5732	#if defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE)
5733	struct proto sctpv6_prot = {	5733	struct proto sctpv6_prot = {
5734	.name = "SCTPv6",	5734	.name = "SCTPv6",
5735	.owner = THIS_MODULE,	5735	.owner = THIS_MODULE,
5736	.close = sctp_close,	5736	.close = sctp_close,
5737	.connect = sctp_connect,	5737	.connect = sctp_connect,
5738	.disconnect = sctp_disconnect,	5738	.disconnect = sctp_disconnect,
5739	.accept = sctp_accept,	5739	.accept = sctp_accept,
5740	.ioctl = sctp_ioctl,	5740	.ioctl = sctp_ioctl,
5741	.init = sctp_init_sock,	5741	.init = sctp_init_sock,
5742	.destroy = sctp_destroy_sock,	5742	.destroy = sctp_destroy_sock,
5743	.shutdown = sctp_shutdown,	5743	.shutdown = sctp_shutdown,
5744	.setsockopt = sctp_setsockopt,	5744	.setsockopt = sctp_setsockopt,
5745	.getsockopt = sctp_getsockopt,	5745	.getsockopt = sctp_getsockopt,
5746	.sendmsg = sctp_sendmsg,	5746	.sendmsg = sctp_sendmsg,
5747	.recvmsg = sctp_recvmsg,	5747	.recvmsg = sctp_recvmsg,
5748	.bind = sctp_bind,	5748	.bind = sctp_bind,
5749	.backlog_rcv = sctp_backlog_rcv,	5749	.backlog_rcv = sctp_backlog_rcv,
5750	.hash = sctp_hash,	5750	.hash = sctp_hash,
5751	.unhash = sctp_unhash,	5751	.unhash = sctp_unhash,
5752	.get_port = sctp_get_port,	5752	.get_port = sctp_get_port,
5753	.obj_size = sizeof(struct sctp6_sock),	5753	.obj_size = sizeof(struct sctp6_sock),
5754	};	5754	};
5755	#endif /* defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE) */	5755	#endif /* defined(CONFIG_IPV6) \|\| defined(CONFIG_IPV6_MODULE) */
5756		5756