Merge master.kernel.org:/home/davem/BK/sctp-2.5

into home.transmeta.com:/home/torvalds/v2.5/linux

Documentation/networking/sctp.txt

+Linux Kernel SCTP 
+
+This is the current BETA release of the Linux Kernel SCTP reference
+implementation.  
+
+SCTP (Stream Control Transmission Protocol) is a IP based, message oriented,
+reliable transport protocol, with congestion control, support for
+transparent multi-homing, and multiple ordered streams of messages.
+RFC2960 defines the core protocol.  The IETF SIGTRAN working group originally
+developed the SCTP protocol and later handed the protocol over to the 
+Transport Area (TSVWG) working group for the continued evolvement of SCTP as a 
+general purpose transport.  
+
+See the IETF website (http://www.ietf.org) for further documents on SCTP. 
+See http://www.ietf.org/rfc/rfc2960.txt 
+
+The initial project goal is to create an Linux kernel reference implementation
+of SCTP that is RFC 2960 compliant and provides an programming interface 
+referred to as the  UDP-style API of the Sockets Extensions for SCTP, as 
+proposed in IETF Internet-Drafts.    
+
+
+Caveats:  
+
+-lksctp can be built as statically or as a module.  However, be aware that 
+module removal of lksctp is not yet a safe activity.   
+
+-There is tentative support for IPv6, but most work has gone towards 
+implementation and testing lksctp on IPv4.   
+
+
+For more information, please visit the lksctp project website:
+   http://www.sf.net/projects/lksctp
+
+Or contact the lksctp developers through the mailing list:
+   <lksctp-developers@lists.sourceforge.net> 
+
+

include/linux/in.h

@@ -37,11 +37,12 @@ enum {
 
   IPPROTO_IPV6	 = 41,		/* IPv6-in-IPv4 tunnelling		*/
 
-  IPPROTO_PIM    = 103,		/* Protocol Independent Multicast	*/
-
   IPPROTO_ESP = 50,            /* Encapsulation Security Payload protocol */
   IPPROTO_AH = 51,             /* Authentication Header protocol       */
+  IPPROTO_PIM    = 103,		/* Protocol Independent Multicast	*/
+
   IPPROTO_COMP   = 108,                /* Compression Header protocol */
+  IPPROTO_SCTP   = 132,		/* Stream Control Transport Protocol	*/
 
   IPPROTO_RAW	 = 255,		/* Raw IP packets			*/
   IPPROTO_MAX

include/linux/net.h

@@ -137,6 +137,7 @@ extern int   	sock_sendmsg(struct socket *, struct msghdr *m, int len);
 extern int	sock_recvmsg(struct socket *, struct msghdr *m, int len, int flags);
 extern int	sock_readv_writev(int type, struct inode * inode, struct file * file,
 				  const struct iovec * iov, long count, long size);
+extern int 	sock_map_fd(struct socket *sock);
 
 extern int	net_ratelimit(void);
 extern unsigned long net_random(void);

include/linux/socket.h

@@ -227,6 +227,7 @@ struct ucred {
 #define SOL_UDP		17
 #define SOL_IPV6	41
 #define SOL_ICMPV6	58
+#define SOL_SCTP	132
 #define SOL_RAW		255
 #define SOL_IPX		256
 #define SOL_AX25	257

include/linux/sysctl.h

@@ -172,6 +172,7 @@ enum
 	NET_TR=14,
 	NET_DECNET=15,
 	NET_ECONET=16,
+	NET_SCTP=17, 
 };
 
 /* /proc/sys/kernel/random */
@@ -516,6 +517,21 @@ enum {
 	NET_DECNET_CONF_DEV_STATE = 7
 };
 
+/* /proc/sys/net/sctp */
+enum {
+	NET_SCTP_RTO_INITIAL = 1,
+	NET_SCTP_RTO_MIN     = 2,
+	NET_SCTP_RTO_MAX     = 3,
+	NET_SCTP_RTO_ALPHA   = 4,
+	NET_SCTP_RTO_BETA    = 5,
+	NET_SCTP_VALID_COOKIE_LIFE       =  6,
+	NET_SCTP_ASSOCIATION_MAX_RETRANS =  7,
+	NET_SCTP_PATH_MAX_RETRANS        =  8,
+	NET_SCTP_MAX_INIT_RETRANSMITS    =  9,
+	NET_SCTP_HB_INTERVAL             = 10,
+	NET_SCTP_MAX_BURST               = 11,
+};
+
 /* CTL_PROC names: */
 
 /* CTL_FS names: */

include/net/inet_common.h

@@ -43,6 +43,14 @@ extern void			inet_sock_release(struct sock *sk);
 extern void			inet_sock_destruct(struct sock *sk);
 extern atomic_t			inet_sock_nr;
 
+extern int			inet_bind(struct socket *sock, 
+					  struct sockaddr *uaddr, int addr_len);
+extern int			inet_getname(struct socket *sock, 
+					     struct sockaddr *uaddr, 
+					     int *uaddr_len, int peer);
+extern int			inet_ioctl(struct socket *sock, 
+					   unsigned int cmd, unsigned long arg);
+
 #endif
 
 

include/net/ipv6.h

@@ -4,7 +4,7 @@
  *	Authors:
  *	Pedro Roque		<roque@di.fc.ul.pt>
  *
- *	$Id: ipv6.h,v 1.23 2000/12/13 18:31:48 davem Exp $
+ *	$Id: ipv6.h,v 1.1 2002/05/20 15:13:07 jgrimm Exp $
  *
  *	This program is free software; you can redistribute it and/or
  *      modify it under the terms of the GNU General Public License
@@ -336,6 +336,14 @@ extern void			ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err, u16
 						u32 info, u8 *payload);
 extern void			ipv6_local_error(struct sock *sk, int err, struct flowi *fl, u32 info);
 
+extern int inet6_release(struct socket *sock);
+extern int inet6_bind(struct socket *sock, struct sockaddr *uaddr, 
+		      int addr_len);
+extern int inet6_getname(struct socket *sock, struct sockaddr *uaddr,
+			 int *uaddr_len, int peer);
+extern int inet6_ioctl(struct socket *sock, unsigned int cmd, 
+		       unsigned long arg);
+
 #endif /* __KERNEL__ */
 #endif /* _NET_IPV6_H */
 

include/net/sctp/sctp_command.h

+/* SCTP kernel reference Implementation Copyright (C) 1999-2001
+ * Cisco, Motorola, and IBM
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * $Header: /cvsroot/lksctp/lksctp/sctp_cvs/include/net/sctp/sctp_command.h,v 1.19 2002/08/16 19:30:49 jgrimm Exp $
+ * 
+ * These are the definitions needed for the command object.
+ * 
+ * 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 one of the
+ * following email addresses:
+ * 
+ * La Monte H.P. Yarroll <piggy@acm.org>
+ * Karl Knutson <karl@athena.chicago.il.us>
+ * 
+ * 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_command_h__
+#define __net_sctp_command_h__
+
+#include <net/sctp/sctp_constants.h>
+#include <net/sctp/sctp_structs.h>
+
+
+typedef enum {
+	SCTP_CMD_NOP = 0,	/* Do nothing. */
+	SCTP_CMD_NEW_ASOC,	/* Register a new association.  */
+	SCTP_CMD_DELETE_TCB,	/* Delete the current association. */
+	SCTP_CMD_NEW_STATE,	/* Enter a new state.  */
+	SCTP_CMD_REPORT_TSN,	/* Record the arrival of a TSN.  */
+	SCTP_CMD_GEN_SACK,	/* Send a Selective ACK (maybe).  */
+	SCTP_CMD_PROCESS_SACK,	/* Process an inbound SACK.  */
+	SCTP_CMD_GEN_INIT_ACK,	/* Generate an INIT ACK chunk.  */
+	SCTP_CMD_PEER_INIT,	/* Process a INIT from the peer.  */
+	SCTP_CMD_GEN_COOKIE_ECHO, /* Generate a COOKIE ECHO chunk. */
+	SCTP_CMD_CHUNK_ULP,	/* Send a chunk to the sockets layer.  */
+	SCTP_CMD_EVENT_ULP,	/* Send a notification to the sockets layer. */
+	SCTP_CMD_REPLY,		/* Send a chunk to our peer.  */
+	SCTP_CMD_SEND_PKT,	/* Send a full packet to our peer.  */
+	SCTP_CMD_RETRAN,	/* Mark a transport for retransmission.  */
+	SCTP_CMD_ECN_CE,        /* Do delayed CE processing.   */
+	SCTP_CMD_ECN_ECNE,	/* Do delayed ECNE processing. */
+	SCTP_CMD_ECN_CWR,	/* Do delayed CWR processing.  */
+	SCTP_CMD_TIMER_START,	/* Start a timer.  */
+	SCTP_CMD_TIMER_RESTART,	/* Restart a timer. */
+	SCTP_CMD_TIMER_STOP,	/* Stop a timer. */
+	SCTP_CMD_COUNTER_RESET, /* Reset a counter. */
+	SCTP_CMD_COUNTER_INC,   /* Increment a counter. */
+	SCTP_CMD_INIT_RESTART,  /* High level, do init timer work. */
+	SCTP_CMD_INIT_FAILED,   /* High level, do init failure work. */
+	SCTP_CMD_REPORT_DUP,	/* Report a duplicate TSN.  */
+	SCTP_CMD_REPORT_BIGGAP, /* Narc on a TSN (it was too high).  */
+	SCTP_CMD_SET_BIND_ADDR, /* Set the association bind_addr.  */
+	SCTP_CMD_STRIKE,	/* Mark a strike against a transport.  */
+	SCTP_CMD_TRANSMIT,      /* Transmit the outqueue. */
+	SCTP_CMD_HB_TIMERS_START,    /* Start the heartbeat timers.  */
+	SCTP_CMD_TRANSPORT_RESET,    /* Reset the status of a transport. */
+	SCTP_CMD_TRANSPORT_ON,       /* Mark the transport as active. */
+	SCTP_CMD_REPORT_ERROR,   /* Pass this error back out of the sm. */
+	SCTP_CMD_REPORT_BAD_TAG, /* Verification tags didn't match. */
+	SCTP_CMD_PROCESS_CTSN,   /* Sideeffect from shutdown. */
+	SCTP_CMD_ASSOC_FAILED,	 /* Handle association failure. */
+	SCTP_CMD_DISCARD_PACKET, /* Discard the whole packet. */
+	SCTP_CMD_GEN_SHUTDOWN,   /* Generate a SHUTDOWN chunk. */
+	SCTP_CMD_UPDATE_ASSOC,   /* Update association information. */
+	SCTP_CMD_PURGE_OUTQUEUE, /* Purge all data waiting to be sent. */
+	SCTP_CMD_SETUP_T2,       /* Hi-level, setup T2-shutdown parms.  */
+
+	SCTP_CMD_LAST
+} sctp_verb_t;
+
+#define SCTP_CMD_MAX		(SCTP_CMD_LAST - 1)
+#define SCTP_CMD_NUM_VERBS	(SCTP_CMD_MAX + 1)
+
+/* How many commands can you put in an sctp_cmd_seq_t?
+ * This is a rather arbitrary number, ideally derived from a careful
+ * analysis of the state functions, but in reality just taken from
+ * thin air in the hopes othat we don't trigger a kernel panic.
+ */
+#define SCTP_MAX_NUM_COMMANDS 14
+
+typedef union {
+	__s32 i32;
+	__u32 u32;
+	__u16 u16;
+	__u8 u8;
+	int error;
+	sctp_state_t state;
+	sctp_event_timeout_t to;
+	sctp_counter_t counter;
+	void *ptr;
+	sctp_chunk_t *chunk;
+	sctp_association_t *asoc;
+	sctp_transport_t *transport;
+	sctp_bind_addr_t  *bp;
+	sctp_init_chunk_t *init;
+	sctp_ulpevent_t *ulpevent;
+	sctp_packet_t *packet;
+	sctp_sackhdr_t *sackh;
+} sctp_arg_t;
+
+/* We are simulating ML type constructors here.
+ *
+ * SCTP_ARG_CONSTRUCTOR(NAME, TYPE, ELT) builds a function called
+ * SCTP_NAME() which takes an argument of type TYPE and returns an
+ * sctp_arg_t.  It does this by inserting the sole argument into the
+ * ELT union element of a local sctp_arg_t.
+ *
+ * E.g., SCTP_ARG_CONSTRUCTOR(I32, __s32, i32) builds SCTP_I32(arg),
+ * which takes an __s32 and returns a sctp_arg_t containing the
+ * __s32.  So, after foo = SCTP_I32(arg), foo.i32 == arg.
+ */
+static inline sctp_arg_t SCTP_NULL(void)
+{
+	sctp_arg_t retval; retval.ptr = NULL; return retval;
+}
+static inline sctp_arg_t SCTP_NOFORCE(void)
+{
+	sctp_arg_t retval; retval.i32 = 0; return retval;
+}
+static inline sctp_arg_t SCTP_FORCE(void)
+{
+	sctp_arg_t retval; retval.i32 = 1; return retval;
+}
+
+#define SCTP_ARG_CONSTRUCTOR(name, type, elt) \
+static inline sctp_arg_t	\
+SCTP_## name (type arg)		\
+{ sctp_arg_t retval; retval.elt = arg; return retval; }
+
+SCTP_ARG_CONSTRUCTOR(I32,	__s32, i32)
+SCTP_ARG_CONSTRUCTOR(U32,	__u32, u32)
+SCTP_ARG_CONSTRUCTOR(U16,	__u16, u16)
+SCTP_ARG_CONSTRUCTOR(U8,	__u8, u8)
+SCTP_ARG_CONSTRUCTOR(ERROR,     int, error)
+SCTP_ARG_CONSTRUCTOR(STATE,	sctp_state_t, state)
+SCTP_ARG_CONSTRUCTOR(COUNTER,	sctp_counter_t, counter)
+SCTP_ARG_CONSTRUCTOR(TO,	sctp_event_timeout_t, to)
+SCTP_ARG_CONSTRUCTOR(PTR,	void *, ptr)
+SCTP_ARG_CONSTRUCTOR(CHUNK,	sctp_chunk_t *, chunk)
+SCTP_ARG_CONSTRUCTOR(ASOC,	sctp_association_t *, asoc)
+SCTP_ARG_CONSTRUCTOR(TRANSPORT,	sctp_transport_t *, transport)
+SCTP_ARG_CONSTRUCTOR(BA,	sctp_bind_addr_t *, bp)
+SCTP_ARG_CONSTRUCTOR(PEER_INIT,	sctp_init_chunk_t *, init)
+SCTP_ARG_CONSTRUCTOR(ULPEVENT,  sctp_ulpevent_t *, ulpevent)
+SCTP_ARG_CONSTRUCTOR(PACKET,	sctp_packet_t *, packet)
+SCTP_ARG_CONSTRUCTOR(SACKH,	sctp_sackhdr_t *, sackh)
+
+typedef struct {
+	sctp_arg_t obj;
+	sctp_verb_t verb;
+} sctp_cmd_t;
+
+typedef struct {
+	sctp_cmd_t cmds[SCTP_MAX_NUM_COMMANDS];
+	__u8 next_free_slot;
+	__u8 next_cmd;
+} sctp_cmd_seq_t;
+
+
+/* Create a new sctp_command_sequence.
+ * Return NULL if creating a new sequence fails.
+ */
+sctp_cmd_seq_t *sctp_new_cmd_seq(int priority);
+
+/* Initialize a block of memory as a command sequence.
+ * Return 0 if the initialization fails.
+ */
+int sctp_init_cmd_seq(sctp_cmd_seq_t *seq);
+
+/* Add a command to an sctp_cmd_seq_t.
+ * Return 0 if the command sequence is full.
+ *
+ * Use the SCTP_* constructors defined by SCTP_ARG_CONSTRUCTOR() above
+ * to wrap data which goes in the obj argument.
+ */
+int sctp_add_cmd(sctp_cmd_seq_t *seq, sctp_verb_t verb, sctp_arg_t obj);
+
+/* Rewind an sctp_cmd_seq_t to iterate from the start.
+ * Return 0 if the rewind fails.
+ */
+int sctp_rewind_sequence(sctp_cmd_seq_t *seq);
+
+/* Return the next command structure in an sctp_cmd_seq.
+ * Return NULL at the end of the sequence.
+ */
+sctp_cmd_t *sctp_next_cmd(sctp_cmd_seq_t *seq);
+
+/* Dispose of a command sequence.  */
+void sctp_free_cmd_seq(sctp_cmd_seq_t *seq);
+
+#endif /* __net_sctp_command_h__ */
+

include/net/sctp/sctp_sla1.h

+/* SCTP reference Implementation 
+ * Copyright (C) 1999 Cisco, Inc. 
+ * Copyright (C) 1999 Motorola, Inc.
+ *
+ * This file originates from Randy Stewart's SCTP reference Implementation.
+ * 
+ * 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: 
+ *    Randy Stewart <rstewar1@email.mot.com>
+ *    Ken Morneau   <kmorneau@cisco.com> 
+ *    Qiaobing Xie  <qxie1@email.mot.com>
+ */
+
+#ifndef __SLA1_h__
+#define __SLA1_h__
+
+struct SLA_1_Context {
+	unsigned int A;
+	unsigned int B;
+	unsigned int C;
+	unsigned int D;
+	unsigned int E;
+	unsigned int H0;
+	unsigned int H1;
+	unsigned int H2;
+	unsigned int H3;
+	unsigned int H4;
+	unsigned int words[80];
+	unsigned int TEMP;
+
+	/* block I am collecting to process */
+	char SLAblock[64];
+
+	/* collected so far */
+	int howManyInBlock;
+	unsigned int runningTotal;
+};
+
+
+#define F1(B,C,D) (((B & C) | ((~B) & D)))       /* 0  <= t <= 19 */
+#define F2(B,C,D) (B ^ C ^ D)                   /* 20 <= t <= 39 */
+#define F3(B,C,D) ((B & C) | (B & D) | (C & D)) /* 40 <= t <= 59 */
+#define F4(B,C,D) (B ^ C ^ D)                   /*600 <= t <= 79 */
+/* circular shift */
+
+#define CSHIFT(A,B) ((B << A) | (B >> (32-A)))
+
+#define K1 0x5a827999       /* 0  <= t <= 19 */
+#define K2 0x6ed9eba1       /* 20 <= t <= 39 */
+#define K3 0x8f1bbcdc       /* 40 <= t <= 59 */
+#define K4 0xca62c1d6       /* 60 <= t <= 79 */
+
+#define H0INIT 0x67452301
+#define H1INIT 0xefcdab89
+#define H2INIT 0x98badcfe
+#define H3INIT 0x10325476
+#define H4INIT 0xc3d2e1f0
+
+extern void SLA1_Init(struct SLA_1_Context *);
+extern void SLA1_Process(struct SLA_1_Context *, const unsigned char *, int);
+extern void SLA1_Final(struct SLA_1_Context *, unsigned char *);
+
+#endif

include/net/sctp/sctp_tsnmap.h

+/* SCTP kernel reference Implementation Copyright (C) 1999-2001
+ * Cisco, Motorola, Intel, and International Business Machines Corp.
+ * 
+ * This file is part of the SCTP kernel reference Implementation
+ * 
+ * $Header: /cvsroot/lksctp/lksctp/sctp_cvs/include/net/sctp/sctp_tsnmap.h,v 1.8 2002/07/16 14:51:58 jgrimm Exp $
+ * 
+ * These are the definitions needed for the tsnmap type.  The tsnmap is used
+ * to track out of order TSNs received.
+ * 
+ * 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 one of the
+ * following email addresses:
+ * 
+ * Jon Grimm <jgrimm@us.ibm.com>
+ * La Monte H.P. Yarroll <piggy@acm.org>
+ * Karl Knutson <karl@athena.chicago.il.us>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+#include <net/sctp/sctp_constants.h>
+
+#ifndef __sctp_tsnmap_h__
+#define __sctp_tsnmap_h__
+
+
+
+/* RFC 2960 12.2 Parameters necessary per association (i.e. the TCB)
+ * Mapping  An array of bits or bytes indicating which out of
+ * Array    order TSN's have been received (relative to the
+ *          Last Rcvd TSN). If no gaps exist, i.e. no out of
+ *          order packets have been received, this array
+ *          will be set to all zero. This structure may be
+ *          in the form of a circular buffer or bit array.
+ */
+typedef struct sctp_tsnmap {
+
+
+	/* This array counts the number of chunks with each TSN.
+	 * It points at one of the two buffers with which we will
+	 * ping-pong between.
+	 */
+	__u8 *tsn_map;
+
+	/* This marks the tsn which overflows the tsn_map, when the
+	 * cumulative ack point reaches this point we know we can switch
+	 * maps (tsn_map and overflow_map swap).
+	 */
+	__u32 overflow_tsn;
+
+	/* This is the overflow array for tsn_map.
+	 * It points at one of the other ping-pong buffers.
+	 */
+	__u8 *overflow_map;
+
+	/* This is the TSN at tsn_map[0].  */
+	__u32 base_tsn;
+
+	/* Last Rcvd   : This is the last TSN received in
+	 * TSN	       : sequence. This value is set initially by
+	 *             : taking the peer's Initial TSN, received in
+	 *             : the INIT or INIT ACK chunk, and subtracting
+	 *             : one from it.
+	 *
+	 * Throughout most of the specification this is called the
+	 * "Cumulative TSN ACK Point".  In this case, we
+	 * ignore the advice in 12.2 in favour of the term
+	 * used in the bulk of the text.
+	 */
+	__u32 cumulative_tsn_ack_point;
+
+	/* This is the minimum number of TSNs we can track.  This corresponds
+	 * to the size of tsn_map.   Note: the overflow_map allows us to
+	 * potentially track more than this quantity.
+	 */
+	__u16 len;
+
+	/* This is the highest TSN we've marked.  */
+	__u32 max_tsn_seen;
+
+	/* No. of data chunks pending receipt. used by SCTP_STATUS sockopt */
+	__u16 pending_data;
+
+	int malloced;
+
+	__u8 raw_map[0];
+} sctp_tsnmap_t;
+
+typedef struct sctp_tsnmap_iter {
+	__u32 start;
+} sctp_tsnmap_iter_t;
+
+
+/* Create a new tsnmap.  */
+sctp_tsnmap_t *sctp_tsnmap_new(__u16 len, __u32 initial_tsn,
+			       int priority);
+
+/* Dispose of a tsnmap.  */
+void sctp_tsnmap_free(sctp_tsnmap_t *map);
+
+/* This macro assists in creation of external storage for variable length
+ * internal buffers.  We double allocate so the overflow map works.
+ */
+#define sctp_tsnmap_storage_size(count) (sizeof(__u8) * (count) * 2)
+
+/* Initialize a block of memory as a tsnmap.  */
+sctp_tsnmap_t *sctp_tsnmap_init(sctp_tsnmap_t *map, __u16 len, __u32 initial_tsn);
+
+
+
+/* Test the tracking state of this TSN.
+ * Returns:
+ *   0 if the TSN has not yet been seen
+ *  >0 if the TSN has been seen (duplicate)
+ *  <0 if the TSN is invalid (too large to track)
+ */
+int sctp_tsnmap_check(const sctp_tsnmap_t *map, __u32 tsn);
+
+/* Mark this TSN as seen.  */
+void sctp_tsnmap_mark(sctp_tsnmap_t *map, __u32 tsn);
+
+/* Retrieve the Cumulative TSN ACK Point.  */
+__u32 sctp_tsnmap_get_ctsn(const sctp_tsnmap_t *map);
+
+/* Retrieve the highest TSN we've seen.  */
+__u32 sctp_tsnmap_get_max_tsn_seen(const sctp_tsnmap_t *map);
+
+/* Is there a gap in the TSN map? */
+int sctp_tsnmap_has_gap(const sctp_tsnmap_t *map);
+
+/* Initialize a gap ack block interator from user-provided memory.  */
+void sctp_tsnmap_iter_init(const sctp_tsnmap_t *map, sctp_tsnmap_iter_t *iter);
+
+/* Get the next gap ack blocks.  We return 0 if there are no more
+ * gap ack blocks.
+ */
+int sctp_tsnmap_next_gap_ack(const sctp_tsnmap_t *map, sctp_tsnmap_iter_t *iter,
+			     __u16 *start, __u16 *end);
+
+
+#endif /* __sctp_tsnmap_h__ */
+
+
+

include/net/sctp/sctp_ulpevent.h

+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 International Business Machines, Corp.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * $Header: /cvsroot/lksctp/lksctp/sctp_cvs/include/net/sctp/sctp_ulpevent.h,v 1.5 2002/07/12 14:50:25 jgrimm Exp $
+ * 
+ * These are the definitions needed for the sctp_ulpevent type.  The 
+ * sctp_ulpevent type is used to carry information from the state machine
+ * upwards to the ULP. 
+ * 
+ * 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 one of the
+ * following email addresses:
+ * 
+ * Jon Grimm <jgrimm@us.ibm.com>
+ * La Monte H.P. Yarroll <piggy@acm.org>
+ * Karl Knutson <karl@athena.chicago.il.us>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+
+#ifndef __sctp_ulpevent_h__
+#define __sctp_ulpevent_h__
+
+/* A structure to carry information to the ULP (e.g. Sockets API) */
+/* Warning: This sits inside an skb.cb[] area.  Be very careful of
+ * growing this structure as it is at the maximum limit now.
+ */
+typedef struct sctp_ulpevent {
+	int malloced;
+	sctp_association_t *asoc;
+	struct sk_buff *parent;
+	struct sctp_sndrcvinfo sndrcvinfo;
+	int chunk_flags; /* Temp. until we get a new chunk_t */
+	int msg_flags;
+} sctp_ulpevent_t;
+
+
+sctp_ulpevent_t *sctp_ulpevent_new(int size, int msg_flags, int priority);
+
+sctp_ulpevent_t *sctp_ulpevent_init(sctp_ulpevent_t *event, struct sk_buff *skb, int msg_flags);
+
+void sctp_ulpevent_free(sctp_ulpevent_t *event);
+
+int sctp_ulpevent_is_notification(const sctp_ulpevent_t *event);
+
+sctp_ulpevent_t *sctp_ulpevent_make_assoc_change(
+				const struct SCTP_association *asoc,
+				__u16 flags,
+				__u16 state,
+				__u16 error,
+				__u16 outbound,
+				__u16 inbound,
+				int priority);
+
+sctp_ulpevent_t *sctp_ulpevent_make_peer_addr_change(
+				const struct SCTP_association *asoc,
+				const struct sockaddr_storage *aaddr,
+				int flags,
+				int state,
+				int error,
+				int priority);
+
+sctp_ulpevent_t *sctp_ulpevent_make_remote_error(
+				const struct SCTP_association *asoc,
+				struct SCTP_chunk *chunk,
+				__u16 flags,
+				int priority);
+sctp_ulpevent_t *sctp_ulpevent_make_send_failed(
+				const struct SCTP_association *asoc,
+				struct SCTP_chunk *chunk,
+				__u16 flags,
+				__u32 error,
+				int priority);
+
+sctp_ulpevent_t *sctp_ulpevent_make_shutdown_event(
+				const struct SCTP_association *asoc,
+				__u16 flags,
+				int priority);
+
+sctp_ulpevent_t *sctp_ulpevent_make_rcvmsg(struct SCTP_association *asoc,
+					   struct SCTP_chunk *chunk,
+					   int priority);
+
+void sctp_ulpevent_read_sndrcvinfo(const sctp_ulpevent_t *event,
+				   struct msghdr *msghdr);
+
+__u16 sctp_ulpevent_get_notification_type(const sctp_ulpevent_t *event);
+
+
+
+/* Given an event subscription, is this event enabled? */
+static inline int sctp_ulpevent_is_enabled(const sctp_ulpevent_t *event,
+					   const struct sctp_event_subscribe *mask)
+{
+	const char *amask = (const char *) mask;
+	__u16 sn_type;
+	int enabled = 1;
+
+	if (sctp_ulpevent_is_notification(event)) {
+		sn_type = sctp_ulpevent_get_notification_type(event);
+		enabled = amask[sn_type - SCTP_SN_TYPE_BASE];
+	}
+	return enabled;
+}
+
+
+#endif /* __sctp_ulpevent_h__ */
+
+
+
+
+
+
+

include/net/sctp/sctp_ulpqueue.h

+/* SCTP kernel reference Implementation
+ * Copyright (c) 1999-2000 Cisco, Inc.
+ * Copyright (c) 1999-2001 Motorola, Inc.
+ * Copyright (c) 2001 International Business Machines, Corp.
+ * Copyright (c) 2001 Intel Corp.
+ * Copyright (c) 2001 Nokia, Inc.
+ * Copyright (c) 2001 La Monte H.P. Yarroll
+ *
+ * $Header: /cvsroot/lksctp/lksctp/sctp_cvs/include/net/sctp/sctp_ulpqueue.h,v 1.2 2002/07/12 14:50:25 jgrimm Exp $
+ * 
+ * These are the definitions needed for the sctp_ulpqueue type.  The 
+ * sctp_ulpqueue is the interface between the Upper Layer Protocol, or ULP,
+ * and the core SCTP state machine.  This is the component which handles
+ * reassembly and ordering.  
+ * 
+ * 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 one of the
+ * following email addresses:
+ * 
+ * Jon Grimm <jgrimm@us.ibm.com>
+ * La Monte H.P. Yarroll <piggy@acm.org>
+ * 
+ * Any bugs reported given to us we will try to fix... any fixes shared will
+ * be incorporated into the next SCTP release.
+ */
+
+#ifndef __sctp_ulpqueue_h__
+#define __sctp_ulpqueue_h__
+
+/* A structure to carry information to the ULP (e.g. Sockets API) */
+typedef struct sctp_ulpqueue {
+	int malloced;
+	spinlock_t lock;
+	sctp_association_t *asoc;
+	struct sk_buff_head reasm;
+	struct sk_buff_head lobby;
+	__u16 ssn[0];
+} sctp_ulpqueue_t;
+
+/* This macro assists in creation of external storage for variable length
+ * internal buffers.
+ */
+#define sctp_ulpqueue_storage_size(inbound) (sizeof(__u16) * (inbound))
+
+sctp_ulpqueue_t *sctp_ulpqueue_new(sctp_association_t *asoc,
+				   __u16 inbound,
+				   int priority);
+
+sctp_ulpqueue_t *sctp_ulpqueue_init(sctp_ulpqueue_t *ulpq,
+				    sctp_association_t *asoc,
+				    __u16 inbound);
+
+void sctp_ulpqueue_free(sctp_ulpqueue_t *);
+
+
+/* Add a new DATA chunk for processing. */
+int sctp_ulpqueue_tail_data(sctp_ulpqueue_t *,
+			    sctp_chunk_t *chunk,
+			    int priority);
+
+
+/* Add a new event for propogation to the ULP. */
+int sctp_ulpqueue_tail_event(sctp_ulpqueue_t *, 
+			     sctp_ulpevent_t *event);
+
+
+/* Is the ulpqueue empty. */
+int sctp_ulpqueue_is_empty(sctp_ulpqueue_t *);
+
+int sctp_ulpqueue_is_data_empty(sctp_ulpqueue_t *);
+
+#endif /* __sctp_ulpqueue_h__ */
+
+
+
+
+
+
+ 

net/Config.in

@@ -26,6 +26,9 @@ if [ "$CONFIG_INET" = "y" ]; then
 	 source net/ipv6/Config.in
       fi
    fi
+   if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+      source net/sctp/Config.in
+   fi
 fi
 if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
    bool 'Asynchronous Transfer Mode (ATM) (EXPERIMENTAL)' CONFIG_ATM

net/Makefile

@@ -35,6 +35,7 @@ obj-$(CONFIG_DECNET)		+= decnet/
 obj-$(CONFIG_ECONET)		+= econet/
 obj-$(CONFIG_VLAN_8021Q)	+= 8021q/
 obj-$(CONFIG_LLC)		+= llc/
+obj-$(CONFIG_IP_SCTP)		+= sctp/
 
 ifeq ($(CONFIG_NET),y)
 obj-$(CONFIG_MODULES)		+= netsyms.o

net/ipv4/af_inet.c

@@ -493,7 +493,7 @@ int inet_release(struct socket *sock)
 /* It is off by default, see below. */
 int sysctl_ip_nonlocal_bind;
 
-static int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
+int inet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 {
 	struct sockaddr_in *addr = (struct sockaddr_in *)uaddr;
 	struct sock *sk = sock->sk;
@@ -729,7 +729,7 @@ int inet_accept(struct socket *sock, struct socket *newsock, int flags)
 /*
  *	This does both peername and sockname.
  */
-static int inet_getname(struct socket *sock, struct sockaddr *uaddr,
+int inet_getname(struct socket *sock, struct sockaddr *uaddr,
 			int *uaddr_len, int peer)
 {
 	struct sock *sk		= sock->sk;
@@ -846,7 +846,7 @@ int inet_shutdown(struct socket *sock, int how)
  *	There's a good 20K of config code hanging around the kernel.
  */
 
-static int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
+int inet_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
 	struct sock *sk = sock->sk;
 	int err = 0;

net/sctp/Config.in

+#
+# SCTP configuration
+#
+mainmenu_option next_comment
+comment '   SCTP Configuration (EXPERIMENTAL)'
+
+if [ "$CONFIG_IPV6" != "n" ]; then
+   define_bool CONFIG_IPV6_SCTP__ $CONFIG_IPV6
+else
+   define_bool CONFIG_IPV6_SCTP__ y
+fi
+
+dep_tristate '  The SCTP Protocol (EXPERIMENTAL)' CONFIG_IP_SCTP $CONFIG_IPV6_SCTP__
+if [ "$CONFIG_IP_SCTP" != "n" ]; then
+   bool '    SCTP: Use old checksum (Adler-32)' CONFIG_SCTP_ADLER32
+   bool '    SCTP: Debug messages' CONFIG_SCTP_DBG_MSG
+   bool '    SCTP: Debug object counts' CONFIG_SCTP_DBG_OBJCNT
+fi
+
+endmenu