Merge /pub/scm/linux/kernel/git/torvalds/linux-2.6

30 files changed, 1599 insertions, 600 deletions

diff --git a/include/net/ax25.h b/include/net/ax25.h
index 9e6368a54547..828a3a93dda1 100644
--- a/include/net/ax25.h
+++ b/include/net/ax25.h
@@ -220,7 +220,7 @@ static __inline__ void ax25_cb_put(ax25_cb *ax25)
         }
 }
 
-static inline unsigned short ax25_type_trans(struct sk_buff *skb, struct net_device *dev)
+static inline __be16 ax25_type_trans(struct sk_buff *skb, struct net_device *dev)
 {
         skb->dev      = dev;
         skb->pkt_type = PACKET_HOST;
diff --git a/include/net/bluetooth/bluetooth.h b/include/net/bluetooth/bluetooth.h
index 42a84c53678b..06b24f637026 100644
--- a/include/net/bluetooth/bluetooth.h
+++ b/include/net/bluetooth/bluetooth.h
@@ -57,12 +57,6 @@
 #define BT_DBG(fmt, arg...)  printk(KERN_INFO "%s: " fmt "\n" , __FUNCTION__ , ## arg)
 #define BT_ERR(fmt, arg...)  printk(KERN_ERR  "%s: " fmt "\n" , __FUNCTION__ , ## arg)
 
-#ifdef HCI_DATA_DUMP
-#define BT_DMP(buf, len) bt_dump(__FUNCTION__, buf, len)
-#else
-#define BT_DMP(D...)
-#endif
-
 extern struct proc_dir_entry *proc_bt;
 
 /* Connection and socket states */
@@ -174,8 +168,6 @@ static inline int skb_frags_no(struct sk_buff *skb)
         return n;
 }
 
-void bt_dump(char *pref, __u8 *buf, int count);
-
 int bt_err(__u16 code);
 
 #endif /* __BLUETOOTH_H */
diff --git a/include/net/ieee80211.h b/include/net/ieee80211.h
new file mode 100644
index 000000000000..db09580ad14b
--- /dev/null
+++ b/include/net/ieee80211.h
@@ -0,0 +1,856 @@
+/*
+ * Merged with mainline ieee80211.h in Aug 2004.  Original ieee802_11
+ * remains copyright by the original authors
+ *
+ * Portions of the merged code are based on Host AP (software wireless
+ * LAN access point) driver for Intersil Prism2/2.5/3.
+ *
+ * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
+ * <jkmaline@cc.hut.fi>
+ * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
+ *
+ * Adaption to a generic IEEE 802.11 stack by James Ketrenos
+ * <jketreno@linux.intel.com>
+ * Copyright (c) 2004, Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation. See README and COPYING for
+ * more details.
+ */
+#ifndef IEEE80211_H
+#define IEEE80211_H
+
+#include <linux/if_ether.h> /* ETH_ALEN */
+#include <linux/kernel.h>   /* ARRAY_SIZE */
+
+#if WIRELESS_EXT < 17
+#define IW_QUAL_QUAL_INVALID   0x10
+#define IW_QUAL_LEVEL_INVALID  0x20
+#define IW_QUAL_NOISE_INVALID  0x40
+#define IW_QUAL_QUAL_UPDATED   0x1
+#define IW_QUAL_LEVEL_UPDATED  0x2
+#define IW_QUAL_NOISE_UPDATED  0x4
+#endif
+
+#define IEEE80211_DATA_LEN              2304
+/* Maximum size for the MA-UNITDATA primitive, 802.11 standard section
+   6.2.1.1.2.
+
+   The figure in section 7.1.2 suggests a body size of up to 2312
+   bytes is allowed, which is a bit confusing, I suspect this
+   represents the 2304 bytes of real data, plus a possible 8 bytes of
+   WEP IV and ICV. (this interpretation suggested by Ramiro Barreiro) */
+
+
+#define IEEE80211_HLEN                  30
+#define IEEE80211_FRAME_LEN             (IEEE80211_DATA_LEN + IEEE80211_HLEN)
+
+struct ieee80211_hdr {
+        u16 frame_ctl;
+        u16 duration_id;
+        u8 addr1[ETH_ALEN];
+        u8 addr2[ETH_ALEN];
+        u8 addr3[ETH_ALEN];
+        u16 seq_ctl;
+        u8 addr4[ETH_ALEN];
+} __attribute__ ((packed));
+
+struct ieee80211_hdr_3addr {
+        u16 frame_ctl;
+        u16 duration_id;
+        u8 addr1[ETH_ALEN];
+        u8 addr2[ETH_ALEN];
+        u8 addr3[ETH_ALEN];
+        u16 seq_ctl;
+} __attribute__ ((packed));
+
+enum eap_type {
+        EAP_PACKET = 0,
+        EAPOL_START,
+        EAPOL_LOGOFF,
+        EAPOL_KEY,
+        EAPOL_ENCAP_ASF_ALERT
+};
+
+static const char *eap_types[] = {
+        [EAP_PACKET]            = "EAP-Packet",
+        [EAPOL_START]           = "EAPOL-Start",
+        [EAPOL_LOGOFF]          = "EAPOL-Logoff",
+        [EAPOL_KEY]             = "EAPOL-Key",
+        [EAPOL_ENCAP_ASF_ALERT] = "EAPOL-Encap-ASF-Alert"
+};
+
+static inline const char *eap_get_type(int type)
+{
+        return (type >= ARRAY_SIZE(eap_types)) ? "Unknown" : eap_types[type];
+}
+
+struct eapol {
+        u8 snap[6];
+        u16 ethertype;
+        u8 version;
+        u8 type;
+        u16 length;
+} __attribute__ ((packed));
+
+#define IEEE80211_1ADDR_LEN 10
+#define IEEE80211_2ADDR_LEN 16
+#define IEEE80211_3ADDR_LEN 24
+#define IEEE80211_4ADDR_LEN 30
+#define IEEE80211_FCS_LEN    4
+
+#define MIN_FRAG_THRESHOLD     256U
+#define MAX_FRAG_THRESHOLD     2346U
+
+/* Frame control field constants */
+#define IEEE80211_FCTL_VERS             0x0002
+#define IEEE80211_FCTL_FTYPE            0x000c
+#define IEEE80211_FCTL_STYPE            0x00f0
+#define IEEE80211_FCTL_TODS             0x0100
+#define IEEE80211_FCTL_FROMDS           0x0200
+#define IEEE80211_FCTL_MOREFRAGS        0x0400
+#define IEEE80211_FCTL_RETRY            0x0800
+#define IEEE80211_FCTL_PM               0x1000
+#define IEEE80211_FCTL_MOREDATA 0x2000
+#define IEEE80211_FCTL_WEP              0x4000
+#define IEEE80211_FCTL_ORDER            0x8000
+
+#define IEEE80211_FTYPE_MGMT            0x0000
+#define IEEE80211_FTYPE_CTL             0x0004
+#define IEEE80211_FTYPE_DATA            0x0008
+
+/* management */
+#define IEEE80211_STYPE_ASSOC_REQ       0x0000
+#define IEEE80211_STYPE_ASSOC_RESP      0x0010
+#define IEEE80211_STYPE_REASSOC_REQ     0x0020
+#define IEEE80211_STYPE_REASSOC_RESP    0x0030
+#define IEEE80211_STYPE_PROBE_REQ       0x0040
+#define IEEE80211_STYPE_PROBE_RESP      0x0050
+#define IEEE80211_STYPE_BEACON          0x0080
+#define IEEE80211_STYPE_ATIM            0x0090
+#define IEEE80211_STYPE_DISASSOC        0x00A0
+#define IEEE80211_STYPE_AUTH            0x00B0
+#define IEEE80211_STYPE_DEAUTH          0x00C0
+
+/* control */
+#define IEEE80211_STYPE_PSPOLL          0x00A0
+#define IEEE80211_STYPE_RTS             0x00B0
+#define IEEE80211_STYPE_CTS             0x00C0
+#define IEEE80211_STYPE_ACK             0x00D0
+#define IEEE80211_STYPE_CFEND           0x00E0
+#define IEEE80211_STYPE_CFENDACK        0x00F0
+
+/* data */
+#define IEEE80211_STYPE_DATA            0x0000
+#define IEEE80211_STYPE_DATA_CFACK      0x0010
+#define IEEE80211_STYPE_DATA_CFPOLL     0x0020
+#define IEEE80211_STYPE_DATA_CFACKPOLL  0x0030
+#define IEEE80211_STYPE_NULLFUNC        0x0040
+#define IEEE80211_STYPE_CFACK           0x0050
+#define IEEE80211_STYPE_CFPOLL          0x0060
+#define IEEE80211_STYPE_CFACKPOLL       0x0070
+
+#define IEEE80211_SCTL_FRAG             0x000F
+#define IEEE80211_SCTL_SEQ              0xFFF0
+
+
+/* debug macros */
+
+#ifdef CONFIG_IEEE80211_DEBUG
+extern u32 ieee80211_debug_level;
+#define IEEE80211_DEBUG(level, fmt, args...) \
+do { if (ieee80211_debug_level & (level)) \
+  printk(KERN_DEBUG "ieee80211: %c %s " fmt, \
+         in_interrupt() ? 'I' : 'U', __FUNCTION__ , ## args); } while (0)
+#else
+#define IEEE80211_DEBUG(level, fmt, args...) do {} while (0)
+#endif  /* CONFIG_IEEE80211_DEBUG */
+
+/*
+ * To use the debug system;
+ *
+ * If you are defining a new debug classification, simply add it to the #define
+ * list here in the form of:
+ *
+ * #define IEEE80211_DL_xxxx VALUE
+ *
+ * shifting value to the left one bit from the previous entry.  xxxx should be
+ * the name of the classification (for example, WEP)
+ *
+ * You then need to either add a IEEE80211_xxxx_DEBUG() macro definition for your
+ * classification, or use IEEE80211_DEBUG(IEEE80211_DL_xxxx, ...) whenever you want
+ * to send output to that classification.
+ *
+ * To add your debug level to the list of levels seen when you perform
+ *
+ * % cat /proc/net/ipw/debug_level
+ *
+ * you simply need to add your entry to the ipw_debug_levels array.
+ *
+ * If you do not see debug_level in /proc/net/ipw then you do not have
+ * CONFIG_IEEE80211_DEBUG defined in your kernel configuration
+ *
+ */
+
+#define IEEE80211_DL_INFO          (1<<0)
+#define IEEE80211_DL_WX            (1<<1)
+#define IEEE80211_DL_SCAN          (1<<2)
+#define IEEE80211_DL_STATE         (1<<3)
+#define IEEE80211_DL_MGMT          (1<<4)
+#define IEEE80211_DL_FRAG          (1<<5)
+#define IEEE80211_DL_EAP           (1<<6)
+#define IEEE80211_DL_DROP          (1<<7)
+
+#define IEEE80211_DL_TX            (1<<8)
+#define IEEE80211_DL_RX            (1<<9)
+
+#define IEEE80211_ERROR(f, a...) printk(KERN_ERR "ieee80211: " f, ## a)
+#define IEEE80211_WARNING(f, a...) printk(KERN_WARNING "ieee80211: " f, ## a)
+#define IEEE80211_DEBUG_INFO(f, a...)   IEEE80211_DEBUG(IEEE80211_DL_INFO, f, ## a)
+
+#define IEEE80211_DEBUG_WX(f, a...)     IEEE80211_DEBUG(IEEE80211_DL_WX, f, ## a)
+#define IEEE80211_DEBUG_SCAN(f, a...)   IEEE80211_DEBUG(IEEE80211_DL_SCAN, f, ## a)
+#define IEEE80211_DEBUG_STATE(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_STATE, f, ## a)
+#define IEEE80211_DEBUG_MGMT(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_MGMT, f, ## a)
+#define IEEE80211_DEBUG_FRAG(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_FRAG, f, ## a)
+#define IEEE80211_DEBUG_EAP(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_EAP, f, ## a)
+#define IEEE80211_DEBUG_DROP(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_DROP, f, ## a)
+#define IEEE80211_DEBUG_TX(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_TX, f, ## a)
+#define IEEE80211_DEBUG_RX(f, a...)  IEEE80211_DEBUG(IEEE80211_DL_RX, f, ## a)
+#include <linux/netdevice.h>
+#include <linux/wireless.h>
+#include <linux/if_arp.h> /* ARPHRD_ETHER */
+
+#ifndef WIRELESS_SPY
+#define WIRELESS_SPY            // enable iwspy support
+#endif
+#include <net/iw_handler.h>     // new driver API
+
+#ifndef ETH_P_PAE
+#define ETH_P_PAE 0x888E /* Port Access Entity (IEEE 802.1X) */
+#endif /* ETH_P_PAE */
+
+#define ETH_P_PREAUTH 0x88C7 /* IEEE 802.11i pre-authentication */
+
+#ifndef ETH_P_80211_RAW
+#define ETH_P_80211_RAW (ETH_P_ECONET + 1)
+#endif
+
+/* IEEE 802.11 defines */
+
+#define P80211_OUI_LEN 3
+
+struct ieee80211_snap_hdr {
+
+        u8    dsap;   /* always 0xAA */
+        u8    ssap;   /* always 0xAA */
+        u8    ctrl;   /* always 0x03 */
+        u8    oui[P80211_OUI_LEN];    /* organizational universal id */
+
+} __attribute__ ((packed));
+
+#define SNAP_SIZE sizeof(struct ieee80211_snap_hdr)
+
+#define WLAN_FC_GET_TYPE(fc) ((fc) & IEEE80211_FCTL_FTYPE)
+#define WLAN_FC_GET_STYPE(fc) ((fc) & IEEE80211_FCTL_STYPE)
+
+#define WLAN_GET_SEQ_FRAG(seq) ((seq) & IEEE80211_SCTL_FRAG)
+#define WLAN_GET_SEQ_SEQ(seq)  ((seq) & IEEE80211_SCTL_SEQ)
+
+/* Authentication algorithms */
+#define WLAN_AUTH_OPEN 0
+#define WLAN_AUTH_SHARED_KEY 1
+
+#define WLAN_AUTH_CHALLENGE_LEN 128
+
+#define WLAN_CAPABILITY_BSS (1<<0)
+#define WLAN_CAPABILITY_IBSS (1<<1)
+#define WLAN_CAPABILITY_CF_POLLABLE (1<<2)
+#define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3)
+#define WLAN_CAPABILITY_PRIVACY (1<<4)
+#define WLAN_CAPABILITY_SHORT_PREAMBLE (1<<5)
+#define WLAN_CAPABILITY_PBCC (1<<6)
+#define WLAN_CAPABILITY_CHANNEL_AGILITY (1<<7)
+
+/* Status codes */
+#define WLAN_STATUS_SUCCESS 0
+#define WLAN_STATUS_UNSPECIFIED_FAILURE 1
+#define WLAN_STATUS_CAPS_UNSUPPORTED 10
+#define WLAN_STATUS_REASSOC_NO_ASSOC 11
+#define WLAN_STATUS_ASSOC_DENIED_UNSPEC 12
+#define WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG 13
+#define WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION 14
+#define WLAN_STATUS_CHALLENGE_FAIL 15
+#define WLAN_STATUS_AUTH_TIMEOUT 16
+#define WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA 17
+#define WLAN_STATUS_ASSOC_DENIED_RATES 18
+/* 802.11b */
+#define WLAN_STATUS_ASSOC_DENIED_NOSHORT 19
+#define WLAN_STATUS_ASSOC_DENIED_NOPBCC 20
+#define WLAN_STATUS_ASSOC_DENIED_NOAGILITY 21
+
+/* Reason codes */
+#define WLAN_REASON_UNSPECIFIED 1
+#define WLAN_REASON_PREV_AUTH_NOT_VALID 2
+#define WLAN_REASON_DEAUTH_LEAVING 3
+#define WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY 4
+#define WLAN_REASON_DISASSOC_AP_BUSY 5
+#define WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA 6
+#define WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA 7
+#define WLAN_REASON_DISASSOC_STA_HAS_LEFT 8
+#define WLAN_REASON_STA_REQ_ASSOC_WITHOUT_AUTH 9
+
+
+#define IEEE80211_STATMASK_SIGNAL (1<<0)
+#define IEEE80211_STATMASK_RSSI (1<<1)
+#define IEEE80211_STATMASK_NOISE (1<<2)
+#define IEEE80211_STATMASK_RATE (1<<3)
+#define IEEE80211_STATMASK_WEMASK 0x7
+
+
+#define IEEE80211_CCK_MODULATION    (1<<0)
+#define IEEE80211_OFDM_MODULATION   (1<<1)
+
+#define IEEE80211_24GHZ_BAND     (1<<0)
+#define IEEE80211_52GHZ_BAND     (1<<1)
+
+#define IEEE80211_CCK_RATE_1MB                  0x02
+#define IEEE80211_CCK_RATE_2MB                  0x04
+#define IEEE80211_CCK_RATE_5MB                  0x0B
+#define IEEE80211_CCK_RATE_11MB                 0x16
+#define IEEE80211_OFDM_RATE_6MB                 0x0C
+#define IEEE80211_OFDM_RATE_9MB                 0x12
+#define IEEE80211_OFDM_RATE_12MB                0x18
+#define IEEE80211_OFDM_RATE_18MB                0x24
+#define IEEE80211_OFDM_RATE_24MB                0x30
+#define IEEE80211_OFDM_RATE_36MB                0x48
+#define IEEE80211_OFDM_RATE_48MB                0x60
+#define IEEE80211_OFDM_RATE_54MB                0x6C
+#define IEEE80211_BASIC_RATE_MASK               0x80
+
+#define IEEE80211_CCK_RATE_1MB_MASK             (1<<0)
+#define IEEE80211_CCK_RATE_2MB_MASK             (1<<1)
+#define IEEE80211_CCK_RATE_5MB_MASK             (1<<2)
+#define IEEE80211_CCK_RATE_11MB_MASK            (1<<3)
+#define IEEE80211_OFDM_RATE_6MB_MASK            (1<<4)
+#define IEEE80211_OFDM_RATE_9MB_MASK            (1<<5)
+#define IEEE80211_OFDM_RATE_12MB_MASK           (1<<6)
+#define IEEE80211_OFDM_RATE_18MB_MASK           (1<<7)
+#define IEEE80211_OFDM_RATE_24MB_MASK           (1<<8)
+#define IEEE80211_OFDM_RATE_36MB_MASK           (1<<9)
+#define IEEE80211_OFDM_RATE_48MB_MASK           (1<<10)
+#define IEEE80211_OFDM_RATE_54MB_MASK           (1<<11)
+
+#define IEEE80211_CCK_RATES_MASK                0x0000000F
+#define IEEE80211_CCK_BASIC_RATES_MASK  (IEEE80211_CCK_RATE_1MB_MASK | \
+        IEEE80211_CCK_RATE_2MB_MASK)
+#define IEEE80211_CCK_DEFAULT_RATES_MASK        (IEEE80211_CCK_BASIC_RATES_MASK | \
+        IEEE80211_CCK_RATE_5MB_MASK | \
+        IEEE80211_CCK_RATE_11MB_MASK)
+
+#define IEEE80211_OFDM_RATES_MASK               0x00000FF0
+#define IEEE80211_OFDM_BASIC_RATES_MASK (IEEE80211_OFDM_RATE_6MB_MASK | \
+        IEEE80211_OFDM_RATE_12MB_MASK | \
+        IEEE80211_OFDM_RATE_24MB_MASK)
+#define IEEE80211_OFDM_DEFAULT_RATES_MASK       (IEEE80211_OFDM_BASIC_RATES_MASK | \
+        IEEE80211_OFDM_RATE_9MB_MASK  | \
+        IEEE80211_OFDM_RATE_18MB_MASK | \
+        IEEE80211_OFDM_RATE_36MB_MASK | \
+        IEEE80211_OFDM_RATE_48MB_MASK | \
+        IEEE80211_OFDM_RATE_54MB_MASK)
+#define IEEE80211_DEFAULT_RATES_MASK (IEEE80211_OFDM_DEFAULT_RATES_MASK | \
+                                IEEE80211_CCK_DEFAULT_RATES_MASK)
+
+#define IEEE80211_NUM_OFDM_RATES            8
+#define IEEE80211_NUM_CCK_RATES             4
+#define IEEE80211_OFDM_SHIFT_MASK_A         4
+
+
+
+
+/* NOTE: This data is for statistical purposes; not all hardware provides this
+ *       information for frames received.  Not setting these will not cause
+ *       any adverse affects. */
+struct ieee80211_rx_stats {
+        u32 mac_time;
+        s8 rssi;
+        u8 signal;
+        u8 noise;
+        u16 rate; /* in 100 kbps */
+        u8 received_channel;
+        u8 control;
+        u8 mask;
+        u8 freq;
+        u16 len;
+};
+
+/* IEEE 802.11 requires that STA supports concurrent reception of at least
+ * three fragmented frames. This define can be increased to support more
+ * concurrent frames, but it should be noted that each entry can consume about
+ * 2 kB of RAM and increasing cache size will slow down frame reassembly. */
+#define IEEE80211_FRAG_CACHE_LEN 4
+
+struct ieee80211_frag_entry {
+        unsigned long first_frag_time;
+        unsigned int seq;
+        unsigned int last_frag;
+        struct sk_buff *skb;
+        u8 src_addr[ETH_ALEN];
+        u8 dst_addr[ETH_ALEN];
+};
+
+struct ieee80211_stats {
+        unsigned int tx_unicast_frames;
+        unsigned int tx_multicast_frames;
+        unsigned int tx_fragments;
+        unsigned int tx_unicast_octets;
+        unsigned int tx_multicast_octets;
+        unsigned int tx_deferred_transmissions;
+        unsigned int tx_single_retry_frames;
+        unsigned int tx_multiple_retry_frames;
+        unsigned int tx_retry_limit_exceeded;
+        unsigned int tx_discards;
+        unsigned int rx_unicast_frames;
+        unsigned int rx_multicast_frames;
+        unsigned int rx_fragments;
+        unsigned int rx_unicast_octets;
+        unsigned int rx_multicast_octets;
+        unsigned int rx_fcs_errors;
+        unsigned int rx_discards_no_buffer;
+        unsigned int tx_discards_wrong_sa;
+        unsigned int rx_discards_undecryptable;
+        unsigned int rx_message_in_msg_fragments;
+        unsigned int rx_message_in_bad_msg_fragments;
+};
+
+struct ieee80211_device;
+
+#if 0 /* for later */
+#include "ieee80211_crypt.h"
+#endif
+
+#define SEC_KEY_1         (1<<0)
+#define SEC_KEY_2         (1<<1)
+#define SEC_KEY_3         (1<<2)
+#define SEC_KEY_4         (1<<3)
+#define SEC_ACTIVE_KEY    (1<<4)
+#define SEC_AUTH_MODE     (1<<5)
+#define SEC_UNICAST_GROUP (1<<6)
+#define SEC_LEVEL         (1<<7)
+#define SEC_ENABLED       (1<<8)
+
+#define SEC_LEVEL_0      0 /* None */
+#define SEC_LEVEL_1      1 /* WEP 40 and 104 bit */
+#define SEC_LEVEL_2      2 /* Level 1 + TKIP */
+#define SEC_LEVEL_2_CKIP 3 /* Level 1 + CKIP */
+#define SEC_LEVEL_3      4 /* Level 2 + CCMP */
+
+#define WEP_KEYS 4
+#define WEP_KEY_LEN 13
+
+struct ieee80211_security {
+        u16 active_key:2,
+            enabled:1,
+            auth_mode:2,
+            auth_algo:4,
+            unicast_uses_group:1;
+        u8 key_sizes[WEP_KEYS];
+        u8 keys[WEP_KEYS][WEP_KEY_LEN];
+        u8 level;
+        u16 flags;
+} __attribute__ ((packed));
+
+
+/*
+
+ 802.11 data frame from AP
+
+      ,-------------------------------------------------------------------.
+Bytes |  2   |  2   |    6    |    6    |    6    |  2   | 0..2312 |   4  |
+      |------|------|---------|---------|---------|------|---------|------|
+Desc. | ctrl | dura |  DA/RA  |   TA    |    SA   | Sequ |  frame  |  fcs |
+      |      | tion | (BSSID) |         |         | ence |  data   |      |
+      `-------------------------------------------------------------------'
+
+Total: 28-2340 bytes
+
+*/
+
+#define BEACON_PROBE_SSID_ID_POSITION 12
+
+/* Management Frame Information Element Types */
+#define MFIE_TYPE_SSID       0
+#define MFIE_TYPE_RATES      1
+#define MFIE_TYPE_FH_SET     2
+#define MFIE_TYPE_DS_SET     3
+#define MFIE_TYPE_CF_SET     4
+#define MFIE_TYPE_TIM        5
+#define MFIE_TYPE_IBSS_SET   6
+#define MFIE_TYPE_CHALLENGE  16
+#define MFIE_TYPE_RSN        48
+#define MFIE_TYPE_RATES_EX   50
+#define MFIE_TYPE_GENERIC    221
+
+struct ieee80211_info_element_hdr {
+        u8 id;
+        u8 len;
+} __attribute__ ((packed));
+
+struct ieee80211_info_element {
+        u8 id;
+        u8 len;
+        u8 data[0];
+} __attribute__ ((packed));
+
+/*
+ * These are the data types that can make up management packets
+ *
+        u16 auth_algorithm;
+        u16 auth_sequence;
+        u16 beacon_interval;
+        u16 capability;
+        u8 current_ap[ETH_ALEN];
+        u16 listen_interval;
+        struct {
+                u16 association_id:14, reserved:2;
+        } __attribute__ ((packed));
+        u32 time_stamp[2];
+        u16 reason;
+        u16 status;
+*/
+
+struct ieee80211_authentication {
+        struct ieee80211_hdr_3addr header;
+        u16 algorithm;
+        u16 transaction;
+        u16 status;
+        struct ieee80211_info_element info_element;
+} __attribute__ ((packed));
+
+
+struct ieee80211_probe_response {
+        struct ieee80211_hdr_3addr header;
+        u32 time_stamp[2];
+        u16 beacon_interval;
+        u16 capability;
+        struct ieee80211_info_element info_element;
+} __attribute__ ((packed));
+
+struct ieee80211_assoc_request_frame {
+        u16 capability;
+        u16 listen_interval;
+        u8 current_ap[ETH_ALEN];
+        struct ieee80211_info_element info_element;
+} __attribute__ ((packed));
+
+struct ieee80211_assoc_response_frame {
+        struct ieee80211_hdr_3addr header;
+        u16 capability;
+        u16 status;
+        u16 aid;
+        struct ieee80211_info_element info_element; /* supported rates */
+} __attribute__ ((packed));
+
+
+struct ieee80211_txb {
+        u8 nr_frags;
+        u8 encrypted;
+        u16 reserved;
+        u16 frag_size;
+        u16 payload_size;
+        struct sk_buff *fragments[0];
+};
+
+
+/* SWEEP TABLE ENTRIES NUMBER*/
+#define MAX_SWEEP_TAB_ENTRIES             42
+#define MAX_SWEEP_TAB_ENTRIES_PER_PACKET  7
+/* MAX_RATES_LENGTH needs to be 12.  The spec says 8, and many APs
+ * only use 8, and then use extended rates for the remaining supported
+ * rates.  Other APs, however, stick all of their supported rates on the
+ * main rates information element... */
+#define MAX_RATES_LENGTH                  ((u8)12)
+#define MAX_RATES_EX_LENGTH               ((u8)16)
+#define MAX_NETWORK_COUNT                  128
+
+#define CRC_LENGTH                 4U
+
+#define MAX_WPA_IE_LEN 64
+
+#define NETWORK_EMPTY_ESSID (1<<0)
+#define NETWORK_HAS_OFDM    (1<<1)
+#define NETWORK_HAS_CCK     (1<<2)
+
+struct ieee80211_network {
+        /* These entries are used to identify a unique network */
+        u8 bssid[ETH_ALEN];
+        u8 channel;
+        /* Ensure null-terminated for any debug msgs */
+        u8 ssid[IW_ESSID_MAX_SIZE + 1];
+        u8 ssid_len;
+
+        /* These are network statistics */
+        struct ieee80211_rx_stats stats;
+        u16 capability;
+        u8 rates[MAX_RATES_LENGTH];
+        u8 rates_len;
+        u8 rates_ex[MAX_RATES_EX_LENGTH];
+        u8 rates_ex_len;
+        unsigned long last_scanned;
+        u8 mode;
+        u8 flags;
+        u32 last_associate;
+        u32 time_stamp[2];
+        u16 beacon_interval;
+        u16 listen_interval;
+        u16 atim_window;
+        u8 wpa_ie[MAX_WPA_IE_LEN];
+        size_t wpa_ie_len;
+        u8 rsn_ie[MAX_WPA_IE_LEN];
+        size_t rsn_ie_len;
+        struct list_head list;
+};
+
+enum ieee80211_state {
+        IEEE80211_UNINITIALIZED = 0,
+        IEEE80211_INITIALIZED,
+        IEEE80211_ASSOCIATING,
+        IEEE80211_ASSOCIATED,
+        IEEE80211_AUTHENTICATING,
+        IEEE80211_AUTHENTICATED,
+        IEEE80211_SHUTDOWN
+};
+
+#define DEFAULT_MAX_SCAN_AGE (15 * HZ)
+#define DEFAULT_FTS 2346
+#define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x"
+#define MAC_ARG(x) ((u8*)(x))[0],((u8*)(x))[1],((u8*)(x))[2],((u8*)(x))[3],((u8*)(x))[4],((u8*)(x))[5]
+
+
+#define CFG_IEEE80211_RESERVE_FCS (1<<0)
+#define CFG_IEEE80211_COMPUTE_FCS (1<<1)
+
+struct ieee80211_device {
+        struct net_device *dev;
+
+        /* Bookkeeping structures */
+        struct net_device_stats stats;
+        struct ieee80211_stats ieee_stats;
+
+        /* Probe / Beacon management */
+        struct list_head network_free_list;
+        struct list_head network_list;
+        struct ieee80211_network *networks;
+        int scans;
+        int scan_age;
+
+        int iw_mode; /* operating mode (IW_MODE_*) */
+
+        spinlock_t lock;
+
+        int tx_headroom; /* Set to size of any additional room needed at front
+                          * of allocated Tx SKBs */
+        u32 config;
+
+        /* WEP and other encryption related settings at the device level */
+        int open_wep; /* Set to 1 to allow unencrypted frames */
+
+        int reset_on_keychange; /* Set to 1 if the HW needs to be reset on
+                                 * WEP key changes */
+
+        /* If the host performs {en,de}cryption, then set to 1 */
+        int host_encrypt;
+        int host_decrypt;
+        int ieee802_1x; /* is IEEE 802.1X used */
+
+        /* WPA data */
+        int wpa_enabled;
+        int drop_unencrypted;
+        int tkip_countermeasures;
+        int privacy_invoked;
+        size_t wpa_ie_len;
+        u8 *wpa_ie;
+
+        struct list_head crypt_deinit_list;
+        struct ieee80211_crypt_data *crypt[WEP_KEYS];
+        int tx_keyidx; /* default TX key index (crypt[tx_keyidx]) */
+        struct timer_list crypt_deinit_timer;
+
+        int bcrx_sta_key; /* use individual keys to override default keys even
+                           * with RX of broad/multicast frames */
+
+        /* Fragmentation structures */
+        struct ieee80211_frag_entry frag_cache[IEEE80211_FRAG_CACHE_LEN];
+        unsigned int frag_next_idx;
+        u16 fts; /* Fragmentation Threshold */
+
+        /* Association info */
+        u8 bssid[ETH_ALEN];
+
+        enum ieee80211_state state;
+
+        int mode;       /* A, B, G */
+        int modulation; /* CCK, OFDM */
+        int freq_band;  /* 2.4Ghz, 5.2Ghz, Mixed */
+        int abg_ture;   /* ABG flag              */
+
+        /* Callback functions */
+        void (*set_security)(struct net_device *dev,
+                             struct ieee80211_security *sec);
+        int (*hard_start_xmit)(struct ieee80211_txb *txb,
+                               struct net_device *dev);
+        int (*reset_port)(struct net_device *dev);
+
+        /* This must be the last item so that it points to the data
+         * allocated beyond this structure by alloc_ieee80211 */
+        u8 priv[0];
+};
+
+#define IEEE_A            (1<<0)
+#define IEEE_B            (1<<1)
+#define IEEE_G            (1<<2)
+#define IEEE_MODE_MASK    (IEEE_A|IEEE_B|IEEE_G)
+
+extern inline void *ieee80211_priv(struct net_device *dev)
+{
+        return ((struct ieee80211_device *)netdev_priv(dev))->priv;
+}
+
+extern inline int ieee80211_is_empty_essid(const char *essid, int essid_len)
+{
+        /* Single white space is for Linksys APs */
+        if (essid_len == 1 && essid[0] == ' ')
+                return 1;
+
+        /* Otherwise, if the entire essid is 0, we assume it is hidden */
+        while (essid_len) {
+                essid_len--;
+                if (essid[essid_len] != '\0')
+                        return 0;
+        }
+
+        return 1;
+}
+
+extern inline int ieee80211_is_valid_mode(struct ieee80211_device *ieee, int mode)
+{
+        /*
+         * It is possible for both access points and our device to support
+         * combinations of modes, so as long as there is one valid combination
+         * of ap/device supported modes, then return success
+         *
+         */
+        if ((mode & IEEE_A) &&
+            (ieee->modulation & IEEE80211_OFDM_MODULATION) &&
+            (ieee->freq_band & IEEE80211_52GHZ_BAND))
+                return 1;
+
+        if ((mode & IEEE_G) &&
+            (ieee->modulation & IEEE80211_OFDM_MODULATION) &&
+            (ieee->freq_band & IEEE80211_24GHZ_BAND))
+                return 1;
+
+        if ((mode & IEEE_B) &&
+            (ieee->modulation & IEEE80211_CCK_MODULATION) &&
+            (ieee->freq_band & IEEE80211_24GHZ_BAND))
+                return 1;
+
+        return 0;
+}
+
+extern inline int ieee80211_get_hdrlen(u16 fc)
+{
+        int hdrlen = IEEE80211_3ADDR_LEN;
+
+        switch (WLAN_FC_GET_TYPE(fc)) {
+        case IEEE80211_FTYPE_DATA:
+                if ((fc & IEEE80211_FCTL_FROMDS) && (fc & IEEE80211_FCTL_TODS))
+                        hdrlen = IEEE80211_4ADDR_LEN;
+                break;
+        case IEEE80211_FTYPE_CTL:
+                switch (WLAN_FC_GET_STYPE(fc)) {
+                case IEEE80211_STYPE_CTS:
+                case IEEE80211_STYPE_ACK:
+                        hdrlen = IEEE80211_1ADDR_LEN;
+                        break;
+                default:
+                        hdrlen = IEEE80211_2ADDR_LEN;
+                        break;
+                }
+                break;
+        }
+
+        return hdrlen;
+}
+
+
+
+/* ieee80211.c */
+extern void free_ieee80211(struct net_device *dev);
+extern struct net_device *alloc_ieee80211(int sizeof_priv);
+
+extern int ieee80211_set_encryption(struct ieee80211_device *ieee);
+
+/* ieee80211_tx.c */
+
+
+extern int ieee80211_xmit(struct sk_buff *skb,
+                          struct net_device *dev);
+extern void ieee80211_txb_free(struct ieee80211_txb *);
+
+
+/* ieee80211_rx.c */
+extern int ieee80211_rx(struct ieee80211_device *ieee, struct sk_buff *skb,
+                        struct ieee80211_rx_stats *rx_stats);
+extern void ieee80211_rx_mgt(struct ieee80211_device *ieee,
+                             struct ieee80211_hdr *header,
+                             struct ieee80211_rx_stats *stats);
+
+/* iee80211_wx.c */
+extern int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
+                                 struct iw_request_info *info,
+                                 union iwreq_data *wrqu, char *key);
+extern int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
+                                   struct iw_request_info *info,
+                                   union iwreq_data *wrqu, char *key);
+extern int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
+                                   struct iw_request_info *info,
+                                   union iwreq_data *wrqu, char *key);
+
+
+extern inline void ieee80211_increment_scans(struct ieee80211_device *ieee)
+{
+        ieee->scans++;
+}
+
+extern inline int ieee80211_get_scans(struct ieee80211_device *ieee)
+{
+        return ieee->scans;
+}
+
+static inline const char *escape_essid(const char *essid, u8 essid_len) {
+        static char escaped[IW_ESSID_MAX_SIZE * 2 + 1];
+        const char *s = essid;
+        char *d = escaped;
+
+        if (ieee80211_is_empty_essid(essid, essid_len)) {
+                memcpy(escaped, "<hidden>", sizeof("<hidden>"));
+                return escaped;
+        }
+
+        essid_len = min(essid_len, (u8)IW_ESSID_MAX_SIZE);
+        while (essid_len--) {
+                if (*s == '\0') {
+                        *d++ = '\\';
+                        *d++ = '0';
+                        s++;
+                } else {
+                        *d++ = *s++;
+                }
+        }
+        *d = '\0';
+        return escaped;
+}
+
+#endif /* IEEE80211_H */
diff --git a/include/net/ip.h b/include/net/ip.h
index 3f63992eb712..32360bbe143f 100644
--- a/include/net/ip.h
+++ b/include/net/ip.h
@@ -163,6 +163,7 @@ DECLARE_SNMP_STAT(struct linux_mib, net_statistics);
 
 extern int sysctl_local_port_range[2];
 extern int sysctl_ip_default_ttl;
+extern int sysctl_ip_nonlocal_bind;
 
 #ifdef CONFIG_INET
 /* The function in 2.2 was invalid, producing wrong result for
diff --git a/include/net/ip6_fib.h b/include/net/ip6_fib.h
index 319904518194..a66e9de16a6c 100644
--- a/include/net/ip6_fib.h
+++ b/include/net/ip6_fib.h
@@ -167,14 +167,17 @@ extern int			fib6_walk_continue(struct fib6_walker_t *w);
 extern int                      fib6_add(struct fib6_node *root,
                                          struct rt6_info *rt,
                                          struct nlmsghdr *nlh,
-                                         void *rtattr);
+                                         void *rtattr,
+                                         struct netlink_skb_parms *req);
 
 extern int                      fib6_del(struct rt6_info *rt,
                                          struct nlmsghdr *nlh,
-                                         void *rtattr);
+                                         void *rtattr,
+                                         struct netlink_skb_parms *req);
 
 extern void                     inet6_rt_notify(int event, struct rt6_info *rt,
-                                                struct nlmsghdr *nlh);
+                                                struct nlmsghdr *nlh,
+                                                struct netlink_skb_parms *req);
 
 extern void                     fib6_run_gc(unsigned long dummy);
 
diff --git a/include/net/ip6_route.h b/include/net/ip6_route.h
index d5d1dd10cdb8..f920706d526b 100644
--- a/include/net/ip6_route.h
+++ b/include/net/ip6_route.h
@@ -41,13 +41,16 @@ extern int			ipv6_route_ioctl(unsigned int cmd, void __user *arg);
 
 extern int                      ip6_route_add(struct in6_rtmsg *rtmsg,
                                               struct nlmsghdr *,
-                                              void *rtattr);
+                                              void *rtattr,
+                                              struct netlink_skb_parms *req);
 extern int                      ip6_ins_rt(struct rt6_info *,
                                            struct nlmsghdr *,
-                                           void *rtattr);
+                                           void *rtattr,
+                                           struct netlink_skb_parms *req);
 extern int                      ip6_del_rt(struct rt6_info *,
                                            struct nlmsghdr *,
-                                           void *rtattr);
+                                           void *rtattr,
+                                           struct netlink_skb_parms *req);
 
 extern int                      ip6_rt_addr_add(struct in6_addr *addr,
                                                 struct net_device *dev,
diff --git a/include/net/ip_fib.h b/include/net/ip_fib.h
index e5a5f6b62f88..a4208a336ac0 100644
--- a/include/net/ip_fib.h
+++ b/include/net/ip_fib.h
@@ -109,6 +109,20 @@ struct fib_result {
 #endif
 };
 
+struct fib_result_nl {
+        u32             fl_addr;   /* To be looked up*/ 
+        u32             fl_fwmark; 
+        unsigned char   fl_tos;
+        unsigned char   fl_scope;
+        unsigned char   tb_id_in;
+
+        unsigned char   tb_id;      /* Results */
+        unsigned char   prefixlen;
+        unsigned char   nh_sel;
+        unsigned char   type;
+        unsigned char   scope;
+        int             err;      
+};
 
 #ifdef CONFIG_IP_ROUTE_MULTIPATH
 
diff --git a/include/net/ipv6.h b/include/net/ipv6.h
index 771b47e30f86..69324465e8b3 100644
--- a/include/net/ipv6.h
+++ b/include/net/ipv6.h
@@ -183,7 +183,6 @@ struct ipv6_txoptions
         struct ipv6_opt_hdr     *hopopt;
         struct ipv6_opt_hdr     *dst0opt;
         struct ipv6_rt_hdr      *srcrt; /* Routing Header */
-        struct ipv6_opt_hdr     *auth;
         struct ipv6_opt_hdr     *dst1opt;
 
         /* Option buffer, as read by IPV6_PKTOPTIONS, starts here. */
diff --git a/include/net/irda/irda_device.h b/include/net/irda/irda_device.h
index 71d6af83b631..92c828029cd8 100644
--- a/include/net/irda/irda_device.h
+++ b/include/net/irda/irda_device.h
@@ -224,7 +224,7 @@ int  irda_device_is_receiving(struct net_device *dev);
 /* Interface for internal use */
 static inline int irda_device_txqueue_empty(const struct net_device *dev)
 {
-        return (skb_queue_len(&dev->qdisc->q) == 0);
+        return skb_queue_empty(&dev->qdisc->q);
 }
 int  irda_device_set_raw_mode(struct net_device* self, int status);
 struct net_device *alloc_irdadev(int sizeof_priv);
diff --git a/include/net/neighbour.h b/include/net/neighbour.h
index 4f33bbc21e7f..89809891e5ab 100644
--- a/include/net/neighbour.h
+++ b/include/net/neighbour.h
@@ -65,11 +65,10 @@ struct neighbour;
 
 struct neigh_parms
 {
+        struct net_device *dev;
         struct neigh_parms *next;
         int     (*neigh_setup)(struct neighbour *);
         struct neigh_table *tbl;
-        int     entries;
-        void    *priv;
 
         void    *sysctl_table;
 
@@ -192,7 +191,6 @@ struct neigh_table
         atomic_t                entries;
         rwlock_t                lock;
         unsigned long           last_rand;
-        struct neigh_parms      *parms_list;
         kmem_cache_t            *kmem_cachep;
         struct neigh_statistics *stats;
         struct neighbour        **hash_buckets;
@@ -252,6 +250,9 @@ extern int neigh_add(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
 extern int neigh_delete(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
 extern void neigh_app_ns(struct neighbour *n);
 
+extern int neightbl_dump_info(struct sk_buff *skb, struct netlink_callback *cb);
+extern int neightbl_set(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg);
+
 extern void neigh_for_each(struct neigh_table *tbl, void (*cb)(struct neighbour *, void *), void *cookie);
 extern void __neigh_for_each_release(struct neigh_table *tbl, int (*cb)(struct neighbour *));
 extern void pneigh_for_each(struct neigh_table *tbl, void (*cb)(struct pneigh_entry *));
diff --git a/include/net/pkt_sched.h b/include/net/pkt_sched.h
index fcb05a387dbe..6492e7363d84 100644
--- a/include/net/pkt_sched.h
+++ b/include/net/pkt_sched.h
@@ -13,13 +13,12 @@ struct qdisc_walker
 
 extern rwlock_t qdisc_tree_lock;
 
-#define QDISC_ALIGN             32
-#define QDISC_ALIGN_CONST       (QDISC_ALIGN - 1)
+#define QDISC_ALIGNTO           32
+#define QDISC_ALIGN(len)        (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1))
 
 static inline void *qdisc_priv(struct Qdisc *q)
 {
-        return (char *)q + ((sizeof(struct Qdisc) + QDISC_ALIGN_CONST)
-                              & ~QDISC_ALIGN_CONST);
+        return (char *) q + QDISC_ALIGN(sizeof(struct Qdisc));
 }
 
 /* 
@@ -207,8 +206,6 @@ psched_tod_diff(int delta_sec, int bound)
 
 #endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
 
-extern struct Qdisc noop_qdisc;
-extern struct Qdisc_ops noop_qdisc_ops;
 extern struct Qdisc_ops pfifo_qdisc_ops;
 extern struct Qdisc_ops bfifo_qdisc_ops;
 
@@ -216,14 +213,6 @@ extern int register_qdisc(struct Qdisc_ops *qops);
 extern int unregister_qdisc(struct Qdisc_ops *qops);
 extern struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle);
 extern struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle);
-extern void dev_init_scheduler(struct net_device *dev);
-extern void dev_shutdown(struct net_device *dev);
-extern void dev_activate(struct net_device *dev);
-extern void dev_deactivate(struct net_device *dev);
-extern void qdisc_reset(struct Qdisc *qdisc);
-extern void qdisc_destroy(struct Qdisc *qdisc);
-extern struct Qdisc * qdisc_create_dflt(struct net_device *dev,
-        struct Qdisc_ops *ops);
 extern struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,
                 struct rtattr *tab);
 extern void qdisc_put_rtab(struct qdisc_rate_table *tab);
diff --git a/include/net/request_sock.h b/include/net/request_sock.h
new file mode 100644
index 000000000000..72fd6f5e86b1
--- /dev/null
+++ b/include/net/request_sock.h
@@ -0,0 +1,255 @@
+/*
+ * NET          Generic infrastructure for Network protocols.
+ *
+ *              Definitions for request_sock 
+ *
+ * Authors:     Arnaldo Carvalho de Melo <acme@conectiva.com.br>
+ *
+ *              From code originally in include/net/tcp.h
+ *
+ *              This program 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 of the License, or (at your option) any later version.
+ */
+#ifndef _REQUEST_SOCK_H
+#define _REQUEST_SOCK_H
+
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include <net/sock.h>
+
+struct request_sock;
+struct sk_buff;
+struct dst_entry;
+struct proto;
+
+struct request_sock_ops {
+        int             family;
+        kmem_cache_t    *slab;
+        int             obj_size;
+        int             (*rtx_syn_ack)(struct sock *sk,
+                                       struct request_sock *req,
+                                       struct dst_entry *dst);
+        void            (*send_ack)(struct sk_buff *skb,
+                                    struct request_sock *req);
+        void            (*send_reset)(struct sk_buff *skb);
+        void            (*destructor)(struct request_sock *req);
+};
+
+/* struct request_sock - mini sock to represent a connection request
+ */
+struct request_sock {
+        struct request_sock             *dl_next; /* Must be first member! */
+        u16                             mss;
+        u8                              retrans;
+        u8                              __pad;
+        /* The following two fields can be easily recomputed I think -AK */
+        u32                             window_clamp; /* window clamp at creation time */
+        u32                             rcv_wnd;          /* rcv_wnd offered first time */
+        u32                             ts_recent;
+        unsigned long                   expires;
+        struct request_sock_ops         *rsk_ops;
+        struct sock                     *sk;
+};
+
+static inline struct request_sock *reqsk_alloc(struct request_sock_ops *ops)
+{
+        struct request_sock *req = kmem_cache_alloc(ops->slab, SLAB_ATOMIC);
+
+        if (req != NULL)
+                req->rsk_ops = ops;
+
+        return req;
+}
+
+static inline void __reqsk_free(struct request_sock *req)
+{
+        kmem_cache_free(req->rsk_ops->slab, req);
+}
+
+static inline void reqsk_free(struct request_sock *req)
+{
+        req->rsk_ops->destructor(req);
+        __reqsk_free(req);
+}
+
+extern int sysctl_max_syn_backlog;
+
+/** struct listen_sock - listen state
+ *
+ * @max_qlen_log - log_2 of maximal queued SYNs/REQUESTs
+ */
+struct listen_sock {
+        u8                      max_qlen_log;
+        /* 3 bytes hole, try to use */
+        int                     qlen;
+        int                     qlen_young;
+        int                     clock_hand;
+        u32                     hash_rnd;
+        struct request_sock     *syn_table[0];
+};
+
+/** struct request_sock_queue - queue of request_socks
+ *
+ * @rskq_accept_head - FIFO head of established children
+ * @rskq_accept_tail - FIFO tail of established children
+ * @syn_wait_lock - serializer
+ *
+ * %syn_wait_lock is necessary only to avoid proc interface having to grab the main
+ * lock sock while browsing the listening hash (otherwise it's deadlock prone).
+ *
+ * This lock is acquired in read mode only from listening_get_next() seq_file
+ * op and it's acquired in write mode _only_ from code that is actively
+ * changing rskq_accept_head. All readers that are holding the master sock lock
+ * don't need to grab this lock in read mode too as rskq_accept_head. writes
+ * are always protected from the main sock lock.
+ */
+struct request_sock_queue {
+        struct request_sock     *rskq_accept_head;
+        struct request_sock     *rskq_accept_tail;
+        rwlock_t                syn_wait_lock;
+        struct listen_sock      *listen_opt;
+};
+
+extern int reqsk_queue_alloc(struct request_sock_queue *queue,
+                             const int nr_table_entries);
+
+static inline struct listen_sock *reqsk_queue_yank_listen_sk(struct request_sock_queue *queue)
+{
+        struct listen_sock *lopt;
+
+        write_lock_bh(&queue->syn_wait_lock);
+        lopt = queue->listen_opt;
+        queue->listen_opt = NULL;
+        write_unlock_bh(&queue->syn_wait_lock);
+
+        return lopt;
+}
+
+static inline void reqsk_queue_destroy(struct request_sock_queue *queue)
+{
+        kfree(reqsk_queue_yank_listen_sk(queue));
+}
+
+static inline struct request_sock *
+        reqsk_queue_yank_acceptq(struct request_sock_queue *queue)
+{
+        struct request_sock *req = queue->rskq_accept_head;
+
+        queue->rskq_accept_head = queue->rskq_accept_head = NULL;
+        return req;
+}
+
+static inline int reqsk_queue_empty(struct request_sock_queue *queue)
+{
+        return queue->rskq_accept_head == NULL;
+}
+
+static inline void reqsk_queue_unlink(struct request_sock_queue *queue,
+                                      struct request_sock *req,
+                                      struct request_sock **prev_req)
+{
+        write_lock(&queue->syn_wait_lock);
+        *prev_req = req->dl_next;
+        write_unlock(&queue->syn_wait_lock);
+}
+
+static inline void reqsk_queue_add(struct request_sock_queue *queue,
+                                   struct request_sock *req,
+                                   struct sock *parent,
+                                   struct sock *child)
+{
+        req->sk = child;
+        sk_acceptq_added(parent);
+
+        if (queue->rskq_accept_head == NULL)
+                queue->rskq_accept_head = req;
+        else
+                queue->rskq_accept_tail->dl_next = req;
+
+        queue->rskq_accept_tail = req;
+        req->dl_next = NULL;
+}
+
+static inline struct request_sock *reqsk_queue_remove(struct request_sock_queue *queue)
+{
+        struct request_sock *req = queue->rskq_accept_head;
+
+        BUG_TRAP(req != NULL);
+
+        queue->rskq_accept_head = req->dl_next;
+        if (queue->rskq_accept_head == NULL)
+                queue->rskq_accept_tail = NULL;
+
+        return req;
+}
+
+static inline struct sock *reqsk_queue_get_child(struct request_sock_queue *queue,
+                                                 struct sock *parent)
+{
+        struct request_sock *req = reqsk_queue_remove(queue);
+        struct sock *child = req->sk;
+
+        BUG_TRAP(child != NULL);
+
+        sk_acceptq_removed(parent);
+        __reqsk_free(req);
+        return child;
+}
+
+static inline int reqsk_queue_removed(struct request_sock_queue *queue,
+                                      struct request_sock *req)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+
+        if (req->retrans == 0)
+                --lopt->qlen_young;
+
+        return --lopt->qlen;
+}
+
+static inline int reqsk_queue_added(struct request_sock_queue *queue)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+        const int prev_qlen = lopt->qlen;
+
+        lopt->qlen_young++;
+        lopt->qlen++;
+        return prev_qlen;
+}
+
+static inline int reqsk_queue_len(struct request_sock_queue *queue)
+{
+        return queue->listen_opt != NULL ? queue->listen_opt->qlen : 0;
+}
+
+static inline int reqsk_queue_len_young(struct request_sock_queue *queue)
+{
+        return queue->listen_opt->qlen_young;
+}
+
+static inline int reqsk_queue_is_full(struct request_sock_queue *queue)
+{
+        return queue->listen_opt->qlen >> queue->listen_opt->max_qlen_log;
+}
+
+static inline void reqsk_queue_hash_req(struct request_sock_queue *queue,
+                                        u32 hash, struct request_sock *req,
+                                        unsigned timeout)
+{
+        struct listen_sock *lopt = queue->listen_opt;
+
+        req->expires = jiffies + timeout;
+        req->retrans = 0;
+        req->sk = NULL;
+        req->dl_next = lopt->syn_table[hash];
+
+        write_lock(&queue->syn_wait_lock);
+        lopt->syn_table[hash] = req;
+        write_unlock(&queue->syn_wait_lock);
+}
+
+#endif /* _REQUEST_SOCK_H */
diff --git a/include/net/route.h b/include/net/route.h
index d34ca8fc6756..c3cd069a9aca 100644
--- a/include/net/route.h
+++ b/include/net/route.h
@@ -107,7 +107,7 @@ struct rt_cache_stat
 
 extern struct rt_cache_stat *rt_cache_stat;
 #define RT_CACHE_STAT_INC(field)                                          \
-                (per_cpu_ptr(rt_cache_stat, _smp_processor_id())->field++)
+                (per_cpu_ptr(rt_cache_stat, raw_smp_processor_id())->field++)
 
 extern struct ip_rt_acct *ip_rt_acct;
 
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index c57504b3b518..7b6ec9986715 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -164,6 +164,19 @@ extern void qdisc_unlock_tree(struct net_device *dev);
 #define tcf_tree_lock(tp)       qdisc_lock_tree((tp)->q->dev)
 #define tcf_tree_unlock(tp)     qdisc_unlock_tree((tp)->q->dev)
 
+extern struct Qdisc noop_qdisc;
+extern struct Qdisc_ops noop_qdisc_ops;
+
+extern void dev_init_scheduler(struct net_device *dev);
+extern void dev_shutdown(struct net_device *dev);
+extern void dev_activate(struct net_device *dev);
+extern void dev_deactivate(struct net_device *dev);
+extern void qdisc_reset(struct Qdisc *qdisc);
+extern void qdisc_destroy(struct Qdisc *qdisc);
+extern struct Qdisc *qdisc_alloc(struct net_device *dev, struct Qdisc_ops *ops);
+extern struct Qdisc *qdisc_create_dflt(struct net_device *dev,
+                                       struct Qdisc_ops *ops);
+
 static inline void
 tcf_destroy(struct tcf_proto *tp)
 {
@@ -172,4 +185,126 @@ tcf_destroy(struct tcf_proto *tp)
         kfree(tp);
 }
 
+static inline int __qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch,
+                                       struct sk_buff_head *list)
+{
+        __skb_queue_tail(list, skb);
+        sch->qstats.backlog += skb->len;
+        sch->bstats.bytes += skb->len;
+        sch->bstats.packets++;
+
+        return NET_XMIT_SUCCESS;
+}
+
+static inline int qdisc_enqueue_tail(struct sk_buff *skb, struct Qdisc *sch)
+{
+        return __qdisc_enqueue_tail(skb, sch, &sch->q);
+}
+
+static inline struct sk_buff *__qdisc_dequeue_head(struct Qdisc *sch,
+                                                   struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __skb_dequeue(list);
+
+        if (likely(skb != NULL))
+                sch->qstats.backlog -= skb->len;
+
+        return skb;
+}
+
+static inline struct sk_buff *qdisc_dequeue_head(struct Qdisc *sch)
+{
+        return __qdisc_dequeue_head(sch, &sch->q);
+}
+
+static inline struct sk_buff *__qdisc_dequeue_tail(struct Qdisc *sch,
+                                                   struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __skb_dequeue_tail(list);
+
+        if (likely(skb != NULL))
+                sch->qstats.backlog -= skb->len;
+
+        return skb;
+}
+
+static inline struct sk_buff *qdisc_dequeue_tail(struct Qdisc *sch)
+{
+        return __qdisc_dequeue_tail(sch, &sch->q);
+}
+
+static inline int __qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch,
+                                  struct sk_buff_head *list)
+{
+        __skb_queue_head(list, skb);
+        sch->qstats.backlog += skb->len;
+        sch->qstats.requeues++;
+
+        return NET_XMIT_SUCCESS;
+}
+
+static inline int qdisc_requeue(struct sk_buff *skb, struct Qdisc *sch)
+{
+        return __qdisc_requeue(skb, sch, &sch->q);
+}
+
+static inline void __qdisc_reset_queue(struct Qdisc *sch,
+                                       struct sk_buff_head *list)
+{
+        /*
+         * We do not know the backlog in bytes of this list, it
+         * is up to the caller to correct it
+         */
+        skb_queue_purge(list);
+}
+
+static inline void qdisc_reset_queue(struct Qdisc *sch)
+{
+        __qdisc_reset_queue(sch, &sch->q);
+        sch->qstats.backlog = 0;
+}
+
+static inline unsigned int __qdisc_queue_drop(struct Qdisc *sch,
+                                              struct sk_buff_head *list)
+{
+        struct sk_buff *skb = __qdisc_dequeue_tail(sch, list);
+
+        if (likely(skb != NULL)) {
+                unsigned int len = skb->len;
+                kfree_skb(skb);
+                return len;
+        }
+
+        return 0;
+}
+
+static inline unsigned int qdisc_queue_drop(struct Qdisc *sch)
+{
+        return __qdisc_queue_drop(sch, &sch->q);
+}
+
+static inline int qdisc_drop(struct sk_buff *skb, struct Qdisc *sch)
+{
+        kfree_skb(skb);
+        sch->qstats.drops++;
+
+        return NET_XMIT_DROP;
+}
+
+static inline int qdisc_reshape_fail(struct sk_buff *skb, struct Qdisc *sch)
+{
+        sch->qstats.drops++;
+
+#ifdef CONFIG_NET_CLS_POLICE
+        if (sch->reshape_fail == NULL || sch->reshape_fail(skb, sch))
+                goto drop;
+
+        return NET_XMIT_SUCCESS;
+
+drop:
+#endif
+        kfree_skb(skb);
+        return NET_XMIT_DROP;
+}
+
 #endif
diff --git a/include/net/sctp/command.h b/include/net/sctp/command.h
index ebc5282e6d58..dc107ffad483 100644
--- a/include/net/sctp/command.h
+++ b/include/net/sctp/command.h
@@ -65,9 +65,11 @@ typedef enum {
         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_CHOOSE_TRANSPORT, /* Choose transport for an INIT. */
+        SCTP_CMD_INIT_COUNTER_RESET, /* Reset init counter. */
+        SCTP_CMD_INIT_COUNTER_INC,   /* Increment init counter. */
         SCTP_CMD_INIT_RESTART,  /* High level, do init timer work. */
+        SCTP_CMD_COOKIEECHO_RESTART,  /* High level, do cookie-echo timer work. */
         SCTP_CMD_INIT_FAILED,   /* High level, do init failure work. */
         SCTP_CMD_REPORT_DUP,    /* Report a duplicate TSN.  */
         SCTP_CMD_STRIKE,        /* Mark a strike against a transport.  */
@@ -118,7 +120,6 @@ typedef union {
         int error;
         sctp_state_t state;
         sctp_event_timeout_t to;
-        sctp_counter_t counter;
         void *ptr;
         struct sctp_chunk *chunk;
         struct sctp_association *asoc;
@@ -165,7 +166,6 @@ 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,     struct sctp_chunk *, chunk)
diff --git a/include/net/sctp/constants.h b/include/net/sctp/constants.h
index 2b76c0f4babc..5999e5684bbf 100644
--- a/include/net/sctp/constants.h
+++ b/include/net/sctp/constants.h
@@ -263,30 +263,11 @@ enum { SCTP_MIN_PMTU = 576 };
 enum { SCTP_MAX_DUP_TSNS = 16 };
 enum { SCTP_MAX_GABS = 16 };
 
-typedef enum {
-        SCTP_COUNTER_INIT_ERROR,
-} sctp_counter_t;
-
-/* How many counters does an association need? */
-#define SCTP_NUMBER_COUNTERS    5
-
-/* Here we define the default timers.  */
-
-/* cookie timer def = ? seconds */
-#define SCTP_DEFAULT_TIMEOUT_T1_COOKIE  (3 * HZ)
-
-/* init timer def = 3 seconds  */
-#define SCTP_DEFAULT_TIMEOUT_T1_INIT    (3 * HZ)
-
-/* shutdown timer def = 300 ms */
-#define SCTP_DEFAULT_TIMEOUT_T2_SHUTDOWN ((300 * HZ) / 1000)
-
-/* 0 seconds + RTO */
-#define SCTP_DEFAULT_TIMEOUT_HEARTBEAT  (10 * HZ)
+/* Heartbeat interval - 30 secs */
+#define SCTP_DEFAULT_TIMEOUT_HEARTBEAT  (30 * HZ)
 
-/* recv timer def = 200ms (in usec) */
+/* Delayed sack timer - 200ms */
 #define SCTP_DEFAULT_TIMEOUT_SACK       ((200 * HZ) / 1000)
-#define SCTP_DEFAULT_TIMEOUT_SACK_MAX   ((500 * HZ) / 1000) /* 500 ms */
 
 /* RTO.Initial              - 3  seconds
  * RTO.Min                  - 1  second
diff --git a/include/net/sctp/sctp.h b/include/net/sctp/sctp.h
index 960abfa48d68..e1d5ec1c23c0 100644
--- a/include/net/sctp/sctp.h
+++ b/include/net/sctp/sctp.h
@@ -125,7 +125,8 @@
  */
 extern struct sock *sctp_get_ctl_sock(void);
 extern int sctp_copy_local_addr_list(struct sctp_bind_addr *,
-                                     sctp_scope_t, int gfp, int flags);
+                                     sctp_scope_t, unsigned int __nocast 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);
 
@@ -166,15 +167,12 @@ 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_endpoint **,
-                             struct sctp_association **,
+                             struct sctphdr *, struct sctp_association **,
                              struct sctp_transport **);
-void sctp_err_finish(struct sock *, struct sctp_endpoint *,
-                            struct sctp_association *);
+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_endpoint *ep,
                                  struct sctp_association *asoc,
                                  struct sctp_transport *t);
 
@@ -223,6 +221,22 @@ DECLARE_SNMP_STAT(struct sctp_mib, sctp_statistics);
 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 "%04x:%04x:%04x:%04x:%04x:%04x:%04x:%04x" trail, \
+                               leadparm, \
+                               NIP6(saddr->v6.sin6_addr), \
+                               otherparms); \
+                } else { \
+                        printk(KERN_DEBUG \
+                               lead "%u.%u.%u.%u" 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; }
 
@@ -236,6 +250,7 @@ extern int sctp_debug_flag;
 #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)
diff --git a/include/net/sctp/sm.h b/include/net/sctp/sm.h
index f4fcee104707..58462164d960 100644
--- a/include/net/sctp/sm.h
+++ b/include/net/sctp/sm.h
@@ -116,7 +116,8 @@ sctp_state_fn_t sctp_sf_eat_data_fast_4_4;
 sctp_state_fn_t sctp_sf_eat_sack_6_2;
 sctp_state_fn_t sctp_sf_tabort_8_4_8;
 sctp_state_fn_t sctp_sf_operr_notify;
-sctp_state_fn_t sctp_sf_t1_timer_expire;
+sctp_state_fn_t sctp_sf_t1_init_timer_expire;
+sctp_state_fn_t sctp_sf_t1_cookie_timer_expire;
 sctp_state_fn_t sctp_sf_t2_timer_expire;
 sctp_state_fn_t sctp_sf_t4_timer_expire;
 sctp_state_fn_t sctp_sf_t5_timer_expire;
@@ -130,7 +131,6 @@ sctp_state_fn_t sctp_sf_do_ecne;
 sctp_state_fn_t sctp_sf_ootb;
 sctp_state_fn_t sctp_sf_pdiscard;
 sctp_state_fn_t sctp_sf_violation;
-sctp_state_fn_t sctp_sf_violation_chunklen;
 sctp_state_fn_t sctp_sf_discard_chunk;
 sctp_state_fn_t sctp_sf_do_5_2_1_siminit;
 sctp_state_fn_t sctp_sf_do_5_2_2_dupinit;
@@ -181,17 +181,17 @@ const sctp_sm_table_entry_t *sctp_sm_lookup_event(sctp_event_t,
 int sctp_chunk_iif(const struct sctp_chunk *);
 struct sctp_association *sctp_make_temp_asoc(const struct sctp_endpoint *,
                                              struct sctp_chunk *,
-                                             int gfp);
+                                             unsigned int __nocast gfp);
 __u32 sctp_generate_verification_tag(void);
 void sctp_populate_tie_tags(__u8 *cookie, __u32 curTag, __u32 hisTag);
 
 /* Prototypes for chunk-building functions.  */
 struct sctp_chunk *sctp_make_init(const struct sctp_association *,
                              const struct sctp_bind_addr *,
-                             int gfp, int vparam_len);
+                             unsigned int __nocast gfp, int vparam_len);
 struct sctp_chunk *sctp_make_init_ack(const struct sctp_association *,
                                  const struct sctp_chunk *,
-                                 const int gfp,
+                                 const unsigned int __nocast gfp,
                                  const int unkparam_len);
 struct sctp_chunk *sctp_make_cookie_echo(const struct sctp_association *,
                                     const struct sctp_chunk *);
@@ -258,8 +258,6 @@ struct sctp_chunk *sctp_make_fwdtsn(const struct sctp_association *asoc,
 void sctp_chunk_assign_tsn(struct sctp_chunk *);
 void sctp_chunk_assign_ssn(struct sctp_chunk *);
 
-void sctp_stop_t1_and_abort(sctp_cmd_seq_t *commands, __u16 error);
-
 /* Prototypes for statetable processing. */
 
 int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
@@ -267,7 +265,7 @@ int sctp_do_sm(sctp_event_t event_type, sctp_subtype_t subtype,
                struct sctp_endpoint *,
                struct sctp_association *asoc,
                void *event_arg,
-               int gfp);
+               unsigned int __nocast gfp);
 
 /* 2nd level prototypes */
 void sctp_generate_t3_rtx_event(unsigned long peer);
@@ -277,7 +275,8 @@ void sctp_ootb_pkt_free(struct sctp_packet *);
 
 struct sctp_association *sctp_unpack_cookie(const struct sctp_endpoint *,
                                        const struct sctp_association *,
-                                       struct sctp_chunk *, int gfp, int *err,
+                                       struct sctp_chunk *,
+                                       unsigned int __nocast gfp, int *err,
                                        struct sctp_chunk **err_chk_p);
 int sctp_addip_addr_config(struct sctp_association *, sctp_param_t,
                            struct sockaddr_storage*, int);
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h
index 6c24d9cd3d66..994009bbe3b4 100644
--- a/include/net/sctp/structs.h
+++ b/include/net/sctp/structs.h
@@ -161,6 +161,9 @@ extern struct sctp_globals {
          */
         int sndbuf_policy;
 
+        /* Delayed SACK timeout  200ms default*/
+        int sack_timeout;
+
         /* HB.interval              - 30 seconds  */
         int hb_interval;
 
@@ -217,6 +220,7 @@ extern struct sctp_globals {
 #define sctp_sndbuf_policy              (sctp_globals.sndbuf_policy)
 #define sctp_max_retrans_path           (sctp_globals.max_retrans_path)
 #define sctp_max_retrans_init           (sctp_globals.max_retrans_init)
+#define sctp_sack_timeout               (sctp_globals.sack_timeout)
 #define sctp_hb_interval                (sctp_globals.hb_interval)
 #define sctp_max_instreams              (sctp_globals.max_instreams)
 #define sctp_max_outstreams             (sctp_globals.max_outstreams)
@@ -441,7 +445,8 @@ struct sctp_ssnmap {
         int malloced;
 };
 
-struct sctp_ssnmap *sctp_ssnmap_new(__u16 in, __u16 out, int gfp);
+struct sctp_ssnmap *sctp_ssnmap_new(__u16 in, __u16 out,
+                                    unsigned int __nocast gfp);
 void sctp_ssnmap_free(struct sctp_ssnmap *map);
 void sctp_ssnmap_clear(struct sctp_ssnmap *map);
 
@@ -578,7 +583,6 @@ void sctp_datamsg_track(struct sctp_chunk *);
 void sctp_chunk_fail(struct sctp_chunk *, int error);
 int sctp_chunk_abandoned(struct sctp_chunk *);
 
-
 /* RFC2960 1.4 Key Terms
  *
  * o Chunk: A unit of information within an SCTP packet, consisting of
@@ -588,13 +592,8 @@ int sctp_chunk_abandoned(struct sctp_chunk *);
  * each chunk as well as a few other header pointers...
  */
 struct sctp_chunk {
-        /* These first three elements MUST PRECISELY match the first
-         * three elements of struct sk_buff.  This allows us to reuse
-         * all the skb_* queue management functions.
-         */
-        struct sctp_chunk *next;
-        struct sctp_chunk *prev;
-        struct sk_buff_head *list;
+        struct list_head list;
+
         atomic_t refcnt;
 
         /* This is our link to the per-transport transmitted list.  */
@@ -713,7 +712,7 @@ struct sctp_packet {
         __u32 vtag;
 
         /* This contains the payload chunks.  */
-        struct sk_buff_head chunks;
+        struct list_head chunk_list;
 
         /* This is the overhead of the sctp and ip headers. */
         size_t overhead;
@@ -867,10 +866,13 @@ struct sctp_transport {
          */
         unsigned long last_time_ecne_reduced;
 
-        /* active      : The current active state of this destination,
-         *             :  i.e. DOWN, UP, etc.
+        /* The number of times INIT has been sent on this transport. */
+        int init_sent_count;
+
+        /* state       : The current state of this destination,
+         *             : i.e. SCTP_ACTIVE, SCTP_INACTIVE, SCTP_UNKOWN.
          */
-        int active;
+        int state;
 
         /* hb_allowed  : The current heartbeat state of this destination,
          *             :  i.e. ALLOW-HB, NO-HEARTBEAT, etc.
@@ -944,7 +946,8 @@ struct sctp_transport {
         } cacc;
 };
 
-struct sctp_transport *sctp_transport_new(const union sctp_addr *, int);
+struct sctp_transport *sctp_transport_new(const union sctp_addr *,
+                                          unsigned int __nocast);
 void sctp_transport_set_owner(struct sctp_transport *,
                               struct sctp_association *);
 void sctp_transport_route(struct sctp_transport *, union sctp_addr *,
@@ -967,7 +970,7 @@ struct sctp_inq {
         /* This is actually a queue of sctp_chunk each
          * containing a partially decoded packet.
          */
-        struct sk_buff_head in;
+        struct list_head in_chunk_list;
         /* This is the packet which is currently off the in queue and is
          * being worked on through the inbound chunk processing.
          */
@@ -1010,7 +1013,7 @@ struct sctp_outq {
         struct sctp_association *asoc;
 
         /* Data pending that has never been transmitted.  */
-        struct sk_buff_head out;
+        struct list_head out_chunk_list;
 
         unsigned out_qlen;      /* Total length of queued data chunks. */
 
@@ -1018,7 +1021,7 @@ struct sctp_outq {
         unsigned error;
 
         /* These are control chunks we want to send.  */
-        struct sk_buff_head control;
+        struct list_head control_chunk_list;
 
         /* These are chunks that have been sacked but are above the
          * CTSN, or cumulative tsn ack point.
@@ -1092,9 +1095,10 @@ void sctp_bind_addr_init(struct sctp_bind_addr *, __u16 port);
 void sctp_bind_addr_free(struct sctp_bind_addr *);
 int sctp_bind_addr_copy(struct sctp_bind_addr *dest,
                         const struct sctp_bind_addr *src,
-                        sctp_scope_t scope, int gfp,int flags);
+                        sctp_scope_t scope, unsigned int __nocast gfp,
+                        int flags);
 int sctp_add_bind_addr(struct sctp_bind_addr *, union sctp_addr *,
-                       int gfp);
+                       unsigned int __nocast gfp);
 int sctp_del_bind_addr(struct sctp_bind_addr *, union sctp_addr *);
 int sctp_bind_addr_match(struct sctp_bind_addr *, const union sctp_addr *,
                          struct sctp_sock *);
@@ -1103,9 +1107,10 @@ union sctp_addr *sctp_find_unmatch_addr(struct sctp_bind_addr	*bp,
                                         int                     addrcnt,
                                         struct sctp_sock        *opt);
 union sctp_params sctp_bind_addrs_to_raw(const struct sctp_bind_addr *bp,
-                                         int *addrs_len, int gfp);
+                                         int *addrs_len,
+                                         unsigned int __nocast gfp);
 int sctp_raw_to_bind_addrs(struct sctp_bind_addr *bp, __u8 *raw, int len,
-                           __u16 port, int gfp);
+                           __u16 port, unsigned int __nocast gfp);
 
 sctp_scope_t sctp_scope(const union sctp_addr *);
 int sctp_in_scope(const union sctp_addr *addr, const sctp_scope_t scope);
@@ -1222,9 +1227,6 @@ struct sctp_endpoint {
 
         /* sendbuf acct. policy.        */
         __u32 sndbuf_policy;
-
-        /* Name for debugging output... */
-        char *debug_name;
 };
 
 /* Recover the outter endpoint structure. */
@@ -1237,7 +1239,7 @@ static inline struct sctp_endpoint *sctp_ep(struct sctp_ep_common *base)
 }
 
 /* These are function signatures for manipulating endpoints.  */
-struct sctp_endpoint *sctp_endpoint_new(struct sock *, int);
+struct sctp_endpoint *sctp_endpoint_new(struct sock *, unsigned int __nocast);
 void sctp_endpoint_free(struct sctp_endpoint *);
 void sctp_endpoint_put(struct sctp_endpoint *);
 void sctp_endpoint_hold(struct sctp_endpoint *);
@@ -1258,7 +1260,7 @@ int sctp_verify_init(const struct sctp_association *asoc, sctp_cid_t,
                      struct sctp_chunk **err_chunk);
 int sctp_process_init(struct sctp_association *, sctp_cid_t cid,
                       const union sctp_addr *peer,
-                      sctp_init_chunk_t *init, int gfp);
+                      sctp_init_chunk_t *init, unsigned int __nocast gfp);
 __u32 sctp_generate_tag(const struct sctp_endpoint *);
 __u32 sctp_generate_tsn(const struct sctp_endpoint *);
 
@@ -1314,11 +1316,23 @@ struct sctp_association {
                  *             : association. Normally this information is
                  *             : hashed or keyed for quick lookup and access
                  *             : of the TCB.
+                 *             : The list is also initialized with the list
+                 *             : of addresses passed with the sctp_connectx()
+                 *             : call.
                  *
                  * It is a list of SCTP_transport's.
                  */
                 struct list_head transport_addr_list;
 
+                /* transport_count
+                 *
+                 * Peer        : A count of the number of peer addresses
+                 * Transport   : in the Peer Transport Address List.
+                 * Address     :
+                 * Count       :
+                 */
+                __u16 transport_count;
+
                 /* port
                  *   The transport layer port number.
                  */
@@ -1486,6 +1500,9 @@ struct sctp_association {
         /* Transport to which SHUTDOWN chunk was last sent.  */
         struct sctp_transport *shutdown_last_sent_to;
 
+        /* Transport to which INIT chunk was last sent.  */
+        struct sctp_transport *init_last_sent_to;
+
         /* Next TSN    : The next TSN number to be assigned to a new
          *             : DATA chunk.  This is sent in the INIT or INIT
          *             : ACK chunk to the peer and incremented each
@@ -1549,8 +1566,11 @@ struct sctp_association {
         /* The message size at which SCTP fragmentation will occur. */
         __u32 frag_point;
 
-        /* Currently only one counter is used to count INIT errors. */
-        int counters[SCTP_NUMBER_COUNTERS];
+        /* Counter used to count INIT errors. */
+        int init_err_counter;
+
+        /* Count the number of INIT cycles (for doubling timeout). */
+        int init_cycle;
 
         /* Default send parameters. */
         __u16 default_stream;
@@ -1650,7 +1670,7 @@ struct sctp_association {
          *  which already resides in sctp_outq.  Please move this
          *  queue and its supporting logic down there.  --piggy]
          */
-        struct sk_buff_head addip_chunks;
+        struct list_head addip_chunk_list;
 
         /* ADDIP Section 4.1 ASCONF Chunk Procedures
          *
@@ -1703,11 +1723,13 @@ static inline struct sctp_association *sctp_assoc(struct sctp_ep_common *base)
 
 struct sctp_association *
 sctp_association_new(const struct sctp_endpoint *, const struct sock *,
-                     sctp_scope_t scope, int gfp);
+                     sctp_scope_t scope, unsigned int __nocast gfp);
 void sctp_association_free(struct sctp_association *);
 void sctp_association_put(struct sctp_association *);
 void sctp_association_hold(struct sctp_association *);
 
+struct sctp_transport *sctp_assoc_choose_init_transport(
+        struct sctp_association *);
 struct sctp_transport *sctp_assoc_choose_shutdown_transport(
         struct sctp_association *);
 void sctp_assoc_update_retran_path(struct sctp_association *);
@@ -1717,9 +1739,12 @@ int sctp_assoc_lookup_laddr(struct sctp_association *asoc,
                             const union sctp_addr *laddr);
 struct sctp_transport *sctp_assoc_add_peer(struct sctp_association *,
                                      const union sctp_addr *address,
-                                     const int gfp);
+                                     const unsigned int __nocast gfp,
+                                     const int peer_state);
 void sctp_assoc_del_peer(struct sctp_association *asoc,
                          const union sctp_addr *addr);
+void sctp_assoc_rm_peer(struct sctp_association *asoc,
+                         struct sctp_transport *peer);
 void sctp_assoc_control_transport(struct sctp_association *,
                                   struct sctp_transport *,
                                   sctp_transport_cmd_t, sctp_sn_error_t);
@@ -1738,9 +1763,11 @@ void sctp_assoc_rwnd_increase(struct sctp_association *, unsigned);
 void sctp_assoc_rwnd_decrease(struct sctp_association *, unsigned);
 void sctp_assoc_set_primary(struct sctp_association *,
                             struct sctp_transport *);
-int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *, int);
+int sctp_assoc_set_bind_addr_from_ep(struct sctp_association *,
+                                     unsigned int __nocast);
 int sctp_assoc_set_bind_addr_from_cookie(struct sctp_association *,
-                                         struct sctp_cookie*, int gfp);
+                                         struct sctp_cookie*,
+                                         unsigned int __nocast gfp);
 
 int sctp_cmp_addr_exact(const union sctp_addr *ss1,
                         const union sctp_addr *ss2);
diff --git a/include/net/sctp/ulpevent.h b/include/net/sctp/ulpevent.h
index 1019d83a580a..90fe4bf6754f 100644
--- a/include/net/sctp/ulpevent.h
+++ b/include/net/sctp/ulpevent.h
@@ -88,7 +88,7 @@ struct sctp_ulpevent *sctp_ulpevent_make_assoc_change(
         __u16 error,
         __u16 outbound,
         __u16 inbound,
-        int gfp);
+        unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_peer_addr_change(
         const struct sctp_association *asoc,
@@ -96,35 +96,35 @@ struct sctp_ulpevent *sctp_ulpevent_make_peer_addr_change(
         int flags,
         int state,
         int error,
-        int gfp);
+        unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_remote_error(
         const struct sctp_association *asoc,
         struct sctp_chunk *chunk,
         __u16 flags,
-        int gfp);
+        unsigned int __nocast gfp);
 struct sctp_ulpevent *sctp_ulpevent_make_send_failed(
         const struct sctp_association *asoc,
         struct sctp_chunk *chunk,
         __u16 flags,
         __u32 error,
-        int gfp);
+        unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_shutdown_event(
         const struct sctp_association *asoc,
         __u16 flags,
-        int gfp);
+        unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_pdapi(
         const struct sctp_association *asoc,
-        __u32 indication, int gfp);
+        __u32 indication, unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_adaption_indication(
-        const struct sctp_association *asoc, int gfp);
+        const struct sctp_association *asoc, unsigned int __nocast gfp);
 
 struct sctp_ulpevent *sctp_ulpevent_make_rcvmsg(struct sctp_association *asoc,
         struct sctp_chunk *chunk,
-        int gfp);
+        unsigned int __nocast gfp);
 
 void sctp_ulpevent_read_sndrcvinfo(const struct sctp_ulpevent *event,
         struct msghdr *);
diff --git a/include/net/sctp/ulpqueue.h b/include/net/sctp/ulpqueue.h
index 961736d29d21..1a60c6d943c1 100644
--- a/include/net/sctp/ulpqueue.h
+++ b/include/net/sctp/ulpqueue.h
@@ -62,19 +62,22 @@ struct sctp_ulpq *sctp_ulpq_init(struct sctp_ulpq *,
 void sctp_ulpq_free(struct sctp_ulpq *);
 
 /* Add a new DATA chunk for processing. */
-int sctp_ulpq_tail_data(struct sctp_ulpq *, struct sctp_chunk *, int);
+int sctp_ulpq_tail_data(struct sctp_ulpq *, struct sctp_chunk *,
+                        unsigned int __nocast);
 
 /* Add a new event for propagation to the ULP. */
 int sctp_ulpq_tail_event(struct sctp_ulpq *, struct sctp_ulpevent *ev);
 
 /* Renege previously received chunks.  */
-void sctp_ulpq_renege(struct sctp_ulpq *, struct sctp_chunk *, int);
+void sctp_ulpq_renege(struct sctp_ulpq *, struct sctp_chunk *,
+                      unsigned int __nocast);
 
 /* Perform partial delivery. */
-void sctp_ulpq_partial_delivery(struct sctp_ulpq *, struct sctp_chunk *, int);
+void sctp_ulpq_partial_delivery(struct sctp_ulpq *, struct sctp_chunk *,
+                                unsigned int __nocast);
 
 /* Abort the partial delivery. */
-void sctp_ulpq_abort_pd(struct sctp_ulpq *, int);
+void sctp_ulpq_abort_pd(struct sctp_ulpq *, unsigned int __nocast);
 
 /* Clear the partial data delivery condition on this socket. */
 int sctp_clear_pd(struct sock *sk);
diff --git a/include/net/sctp/user.h b/include/net/sctp/user.h
index 2758e8ce4f25..f6328aeddcce 100644
--- a/include/net/sctp/user.h
+++ b/include/net/sctp/user.h
@@ -111,6 +111,8 @@ enum sctp_optname {
 #define SCTP_GET_LOCAL_ADDRS_NUM        SCTP_GET_LOCAL_ADDRS_NUM
         SCTP_GET_LOCAL_ADDRS,   /* Get all local addresss. */
 #define SCTP_GET_LOCAL_ADDRS    SCTP_GET_LOCAL_ADDRS
+        SCTP_SOCKOPT_CONNECTX, /* CONNECTX requests. */
+#define SCTP_SOCKOPT_CONNECTX   SCTP_SOCKOPT_CONNECTX
 };
 
 /*
@@ -527,6 +529,7 @@ struct sctp_paddrinfo {
 enum sctp_spinfo_state {
         SCTP_INACTIVE,
         SCTP_ACTIVE,
+        SCTP_UNKNOWN = 0xffff  /* Value used for transport state unknown */
 };
 
 /*
diff --git a/include/net/slhc_vj.h b/include/net/slhc_vj.h
index 0b2c2784f333..8716d5942b65 100644
--- a/include/net/slhc_vj.h
+++ b/include/net/slhc_vj.h
@@ -170,19 +170,14 @@ struct slcompress {
 };
 #define NULLSLCOMPR     (struct slcompress *)0
 
-#define __ARGS(x) x
-
 /* In slhc.c: */
-struct slcompress *slhc_init __ARGS((int rslots, int tslots));
-void slhc_free __ARGS((struct slcompress *comp));
-
-int slhc_compress __ARGS((struct slcompress *comp, unsigned char *icp,
-                          int isize, unsigned char *ocp, unsigned char **cpp,
-                          int compress_cid));
-int slhc_uncompress __ARGS((struct slcompress *comp, unsigned char *icp,
-                            int isize));
-int slhc_remember __ARGS((struct slcompress *comp, unsigned char *icp,
-                          int isize));
-int slhc_toss __ARGS((struct slcompress *comp));
+struct slcompress *slhc_init(int rslots, int tslots);
+void slhc_free(struct slcompress *comp);
+
+int slhc_compress(struct slcompress *comp, unsigned char *icp, int isize,
+                  unsigned char *ocp, unsigned char **cpp, int compress_cid);
+int slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize);
+int slhc_remember(struct slcompress *comp, unsigned char *icp, int isize);
+int slhc_toss(struct slcompress *comp);
 
 #endif  /* _SLHC_H */
diff --git a/include/net/snmp.h b/include/net/snmp.h
index a15ab256276e..a36bed8ea210 100644
--- a/include/net/snmp.h
+++ b/include/net/snmp.h
@@ -128,18 +128,18 @@ struct linux_mib {
 #define SNMP_STAT_USRPTR(name)  (name[1])
 
 #define SNMP_INC_STATS_BH(mib, field)   \
-        (per_cpu_ptr(mib[0], _smp_processor_id())->mibs[field]++)
+        (per_cpu_ptr(mib[0], raw_smp_processor_id())->mibs[field]++)
 #define SNMP_INC_STATS_OFFSET_BH(mib, field, offset)    \
-        (per_cpu_ptr(mib[0], _smp_processor_id())->mibs[field + (offset)]++)
+        (per_cpu_ptr(mib[0], raw_smp_processor_id())->mibs[field + (offset)]++)
 #define SNMP_INC_STATS_USER(mib, field) \
-        (per_cpu_ptr(mib[1], _smp_processor_id())->mibs[field]++)
+        (per_cpu_ptr(mib[1], raw_smp_processor_id())->mibs[field]++)
 #define SNMP_INC_STATS(mib, field)      \
-        (per_cpu_ptr(mib[!in_softirq()], _smp_processor_id())->mibs[field]++)
+        (per_cpu_ptr(mib[!in_softirq()], raw_smp_processor_id())->mibs[field]++)
 #define SNMP_DEC_STATS(mib, field)      \
-        (per_cpu_ptr(mib[!in_softirq()], _smp_processor_id())->mibs[field]--)
+        (per_cpu_ptr(mib[!in_softirq()], raw_smp_processor_id())->mibs[field]--)
 #define SNMP_ADD_STATS_BH(mib, field, addend)   \
-        (per_cpu_ptr(mib[0], _smp_processor_id())->mibs[field] += addend)
+        (per_cpu_ptr(mib[0], raw_smp_processor_id())->mibs[field] += addend)
 #define SNMP_ADD_STATS_USER(mib, field, addend)         \
-        (per_cpu_ptr(mib[1], _smp_processor_id())->mibs[field] += addend)
+        (per_cpu_ptr(mib[1], raw_smp_processor_id())->mibs[field] += addend)
 
 #endif
diff --git a/include/net/sock.h b/include/net/sock.h
index a9ef3a6a13f3..a1042d08becd 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -484,6 +484,8 @@ extern void sk_stream_kill_queues(struct sock *sk);
 
 extern int sk_wait_data(struct sock *sk, long *timeo);
 
+struct request_sock_ops;
+
 /* Networking protocol blocks we attach to sockets.
  * socket layer -> transport layer interface
  * transport -> network interface is defined by struct inet_proto
@@ -547,6 +549,8 @@ struct proto {
         kmem_cache_t            *slab;
         unsigned int            obj_size;
 
+        struct request_sock_ops *rsk_prot;
+
         struct module           *owner;
 
         char                    name[32];
@@ -680,16 +684,17 @@ extern void FASTCALL(release_sock(struct sock *sk));
 #define bh_lock_sock(__sk)      spin_lock(&((__sk)->sk_lock.slock))
 #define bh_unlock_sock(__sk)    spin_unlock(&((__sk)->sk_lock.slock))
 
-extern struct sock              *sk_alloc(int family, int priority,
+extern struct sock              *sk_alloc(int family,
+                                          unsigned int __nocast priority,
                                           struct proto *prot, int zero_it);
 extern void                     sk_free(struct sock *sk);
 
 extern struct sk_buff           *sock_wmalloc(struct sock *sk,
                                               unsigned long size, int force,
-                                              int priority);
+                                              unsigned int __nocast priority);
 extern struct sk_buff           *sock_rmalloc(struct sock *sk,
                                               unsigned long size, int force,
-                                              int priority);
+                                              unsigned int __nocast priority);
 extern void                     sock_wfree(struct sk_buff *skb);
 extern void                     sock_rfree(struct sk_buff *skb);
 
@@ -704,7 +709,8 @@ extern struct sk_buff 		*sock_alloc_send_skb(struct sock *sk,
                                                      unsigned long size,
                                                      int noblock,
                                                      int *errcode);
-extern void *sock_kmalloc(struct sock *sk, int size, int priority);
+extern void *sock_kmalloc(struct sock *sk, int size,
+                          unsigned int __nocast priority);
 extern void sock_kfree_s(struct sock *sk, void *mem, int size);
 extern void sk_send_sigurg(struct sock *sk);
 
@@ -1128,15 +1134,19 @@ static inline void sk_stream_moderate_sndbuf(struct sock *sk)
 }
 
 static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk,
-                                                   int size, int mem, int gfp)
+                                                   int size, int mem,
+                                                   unsigned int __nocast gfp)
 {
-        struct sk_buff *skb = alloc_skb(size + sk->sk_prot->max_header, gfp);
+        struct sk_buff *skb;
+        int hdr_len;
 
+        hdr_len = SKB_DATA_ALIGN(sk->sk_prot->max_header);
+        skb = alloc_skb(size + hdr_len, gfp);
         if (skb) {
                 skb->truesize += mem;
                 if (sk->sk_forward_alloc >= (int)skb->truesize ||
                     sk_stream_mem_schedule(sk, skb->truesize, 0)) {
-                        skb_reserve(skb, sk->sk_prot->max_header);
+                        skb_reserve(skb, hdr_len);
                         return skb;
                 }
                 __kfree_skb(skb);
@@ -1148,7 +1158,8 @@ static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk,
 }
 
 static inline struct sk_buff *sk_stream_alloc_skb(struct sock *sk,
-                                                  int size, int gfp)
+                                                  int size,
+                                                  unsigned int __nocast gfp)
 {
         return sk_stream_alloc_pskb(sk, size, 0, gfp);
 }
@@ -1181,7 +1192,7 @@ static inline int sock_writeable(const struct sock *sk)
         return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf / 2);
 }
 
-static inline int gfp_any(void)
+static inline unsigned int __nocast gfp_any(void)
 {
         return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
 }
diff --git a/include/net/tcp.h b/include/net/tcp.h
index e71f8ba3e101..5010f0c5a56e 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -31,6 +31,7 @@
 #include <linux/cache.h>
 #include <linux/percpu.h>
 #include <net/checksum.h>
+#include <net/request_sock.h>
 #include <net/sock.h>
 #include <net/snmp.h>
 #include <net/ip.h>
@@ -504,25 +505,6 @@ static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
 #else
 # define TCP_TW_RECYCLE_TICK (12+2-TCP_TW_RECYCLE_SLOTS_LOG)
 #endif
-
-#define BICTCP_BETA_SCALE    1024       /* Scale factor beta calculation
-                                         * max_cwnd = snd_cwnd * beta
-                                         */
-#define BICTCP_MAX_INCREMENT 32         /*
-                                         * Limit on the amount of
-                                         * increment allowed during
-                                         * binary search.
-                                         */
-#define BICTCP_FUNC_OF_MIN_INCR 11      /*
-                                         * log(B/Smin)/log(B/(B-1))+1,
-                                         * Smin:min increment
-                                         * B:log factor
-                                         */
-#define BICTCP_B                4        /*
-                                          * In binary search,
-                                          * go to point (max+min)/N
-                                          */
-
 /*
  *      TCP option
  */
@@ -563,7 +545,6 @@ static __inline__ int tcp_sk_listen_hashfn(struct sock *sk)
 #define TCP_NAGLE_PUSH          4       /* Cork is overriden for already queued data */
 
 /* sysctl variables for tcp */
-extern int sysctl_max_syn_backlog;
 extern int sysctl_tcp_timestamps;
 extern int sysctl_tcp_window_scaling;
 extern int sysctl_tcp_sack;
@@ -596,16 +577,7 @@ extern int sysctl_tcp_adv_win_scale;
 extern int sysctl_tcp_tw_reuse;
 extern int sysctl_tcp_frto;
 extern int sysctl_tcp_low_latency;
-extern int sysctl_tcp_westwood;
-extern int sysctl_tcp_vegas_cong_avoid;
-extern int sysctl_tcp_vegas_alpha;
-extern int sysctl_tcp_vegas_beta;
-extern int sysctl_tcp_vegas_gamma;
 extern int sysctl_tcp_nometrics_save;
-extern int sysctl_tcp_bic;
-extern int sysctl_tcp_bic_fast_convergence;
-extern int sysctl_tcp_bic_low_window;
-extern int sysctl_tcp_bic_beta;
 extern int sysctl_tcp_moderate_rcvbuf;
 extern int sysctl_tcp_tso_win_divisor;
 
@@ -613,74 +585,6 @@ extern atomic_t tcp_memory_allocated;
 extern atomic_t tcp_sockets_allocated;
 extern int tcp_memory_pressure;
 
-struct open_request;
-
-struct or_calltable {
-        int  family;
-        int  (*rtx_syn_ack)     (struct sock *sk, struct open_request *req, struct dst_entry*);
-        void (*send_ack)        (struct sk_buff *skb, struct open_request *req);
-        void (*destructor)      (struct open_request *req);
-        void (*send_reset)      (struct sk_buff *skb);
-};
-
-struct tcp_v4_open_req {
-        __u32                   loc_addr;
-        __u32                   rmt_addr;
-        struct ip_options       *opt;
-};
-
-#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
-struct tcp_v6_open_req {
-        struct in6_addr         loc_addr;
-        struct in6_addr         rmt_addr;
-        struct sk_buff          *pktopts;
-        int                     iif;
-};
-#endif
-
-/* this structure is too big */
-struct open_request {
-        struct open_request     *dl_next; /* Must be first member! */
-        __u32                   rcv_isn;
-        __u32                   snt_isn;
-        __u16                   rmt_port;
-        __u16                   mss;
-        __u8                    retrans;
-        __u8                    __pad;
-        __u16   snd_wscale : 4, 
-                rcv_wscale : 4, 
-                tstamp_ok : 1,
-                sack_ok : 1,
-                wscale_ok : 1,
-                ecn_ok : 1,
-                acked : 1;
-        /* The following two fields can be easily recomputed I think -AK */
-        __u32                   window_clamp;   /* window clamp at creation time */
-        __u32                   rcv_wnd;        /* rcv_wnd offered first time */
-        __u32                   ts_recent;
-        unsigned long           expires;
-        struct or_calltable     *class;
-        struct sock             *sk;
-        union {
-                struct tcp_v4_open_req v4_req;
-#if defined(CONFIG_IPV6) || defined (CONFIG_IPV6_MODULE)
-                struct tcp_v6_open_req v6_req;
-#endif
-        } af;
-};
-
-/* SLAB cache for open requests. */
-extern kmem_cache_t *tcp_openreq_cachep;
-
-#define tcp_openreq_alloc()             kmem_cache_alloc(tcp_openreq_cachep, SLAB_ATOMIC)
-#define tcp_openreq_fastfree(req)       kmem_cache_free(tcp_openreq_cachep, req)
-
-static inline void tcp_openreq_free(struct open_request *req)
-{
-        req->class->destructor(req);
-        tcp_openreq_fastfree(req);
-}
-
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 #define TCP_INET_FAMILY(fam) ((fam) == AF_INET)
 #else
@@ -708,7 +612,7 @@ struct tcp_func {
 
         struct sock *           (*syn_recv_sock)        (struct sock *sk,
                                                          struct sk_buff *skb,
-                                                         struct open_request *req,
+                                                         struct request_sock *req,
                                                          struct dst_entry *dst);
     
         int                     (*remember_stamp)       (struct sock *sk);
@@ -817,11 +721,16 @@ static inline int tcp_ack_scheduled(struct tcp_sock *tp)
         return tp->ack.pending&TCP_ACK_SCHED;
 }
 
-static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp)
+static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp, unsigned int pkts)
 {
-        if (tp->ack.quick && --tp->ack.quick == 0) {
-                /* Leaving quickack mode we deflate ATO. */
-                tp->ack.ato = TCP_ATO_MIN;
+        if (tp->ack.quick) {
+                if (pkts >= tp->ack.quick) {
+                        tp->ack.quick = 0;
+
+                        /* Leaving quickack mode we deflate ATO. */
+                        tp->ack.ato = TCP_ATO_MIN;
+                } else
+                        tp->ack.quick -= pkts;
         }
 }
 
@@ -852,8 +761,8 @@ extern enum tcp_tw_status	tcp_timewait_state_process(struct tcp_tw_bucket *tw,
                                                            unsigned len);
 
 extern struct sock *            tcp_check_req(struct sock *sk,struct sk_buff *skb,
-                                              struct open_request *req,
-                                              struct open_request **prev);
+                                              struct request_sock *req,
+                                              struct request_sock **prev);
 extern int                      tcp_child_process(struct sock *parent,
                                                   struct sock *child,
                                                   struct sk_buff *skb);
@@ -903,12 +812,12 @@ extern int			tcp_v4_conn_request(struct sock *sk,
                                                     struct sk_buff *skb);
 
 extern struct sock *            tcp_create_openreq_child(struct sock *sk,
-                                                         struct open_request *req,
+                                                         struct request_sock *req,
                                                          struct sk_buff *skb);
 
 extern struct sock *            tcp_v4_syn_recv_sock(struct sock *sk,
                                                      struct sk_buff *skb,
-                                                     struct open_request *req,
+                                                     struct request_sock *req,
                                                         struct dst_entry *dst);
 
 extern int                      tcp_v4_do_rcv(struct sock *sk,
@@ -922,7 +831,7 @@ extern int			tcp_connect(struct sock *sk);
 
 extern struct sk_buff *         tcp_make_synack(struct sock *sk,
                                                 struct dst_entry *dst,
-                                                struct open_request *req);
+                                                struct request_sock *req);
 
 extern int                      tcp_disconnect(struct sock *sk, int flags);
 
@@ -939,7 +848,9 @@ extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb,
 
 /* tcp_output.c */
 
-extern int tcp_write_xmit(struct sock *, int nonagle);
+extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp,
+                                      unsigned int cur_mss, int nonagle);
+extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp);
 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
 extern void tcp_xmit_retransmit_queue(struct sock *);
 extern void tcp_simple_retransmit(struct sock *);
@@ -949,12 +860,16 @@ extern void tcp_send_probe0(struct sock *);
 extern void tcp_send_partial(struct sock *);
 extern int  tcp_write_wakeup(struct sock *);
 extern void tcp_send_fin(struct sock *sk);
-extern void tcp_send_active_reset(struct sock *sk, int priority);
+extern void tcp_send_active_reset(struct sock *sk,
+                                  unsigned int __nocast priority);
 extern int  tcp_send_synack(struct sock *);
-extern void tcp_push_one(struct sock *, unsigned mss_now);
+extern void tcp_push_one(struct sock *, unsigned int mss_now);
 extern void tcp_send_ack(struct sock *sk);
 extern void tcp_send_delayed_ack(struct sock *sk);
 
+/* tcp_input.c */
+extern void tcp_cwnd_application_limited(struct sock *sk);
+
 /* tcp_timer.c */
 extern void tcp_init_xmit_timers(struct sock *);
 extern void tcp_clear_xmit_timers(struct sock *);
@@ -1054,7 +969,7 @@ static inline void tcp_reset_xmit_timer(struct sock *sk, int what, unsigned long
 static inline void tcp_initialize_rcv_mss(struct sock *sk)
 {
         struct tcp_sock *tp = tcp_sk(sk);
-        unsigned int hint = min(tp->advmss, tp->mss_cache_std);
+        unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
 
         hint = min(hint, tp->rcv_wnd/2);
         hint = min(hint, TCP_MIN_RCVMSS);
@@ -1077,7 +992,7 @@ static __inline__ void tcp_fast_path_on(struct tcp_sock *tp)
 
 static inline void tcp_fast_path_check(struct sock *sk, struct tcp_sock *tp)
 {
-        if (skb_queue_len(&tp->out_of_order_queue) == 0 &&
+        if (skb_queue_empty(&tp->out_of_order_queue) &&
             tp->rcv_wnd &&
             atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
             !tp->urg_data)
@@ -1204,6 +1119,82 @@ static inline void tcp_packets_out_dec(struct tcp_sock *tp,
         tp->packets_out -= tcp_skb_pcount(skb);
 }
 
+/* Events passed to congestion control interface */
+enum tcp_ca_event {
+        CA_EVENT_TX_START,      /* first transmit when no packets in flight */
+        CA_EVENT_CWND_RESTART,  /* congestion window restart */
+        CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
+        CA_EVENT_FRTO,          /* fast recovery timeout */
+        CA_EVENT_LOSS,          /* loss timeout */
+        CA_EVENT_FAST_ACK,      /* in sequence ack */
+        CA_EVENT_SLOW_ACK,      /* other ack */
+};
+
+/*
+ * Interface for adding new TCP congestion control handlers
+ */
+#define TCP_CA_NAME_MAX 16
+struct tcp_congestion_ops {
+        struct list_head        list;
+
+        /* initialize private data (optional) */
+        void (*init)(struct tcp_sock *tp);
+        /* cleanup private data  (optional) */
+        void (*release)(struct tcp_sock *tp);
+
+        /* return slow start threshold (required) */
+        u32 (*ssthresh)(struct tcp_sock *tp);
+        /* lower bound for congestion window (optional) */
+        u32 (*min_cwnd)(struct tcp_sock *tp);
+        /* do new cwnd calculation (required) */
+        void (*cong_avoid)(struct tcp_sock *tp, u32 ack,
+                           u32 rtt, u32 in_flight, int good_ack);
+        /* round trip time sample per acked packet (optional) */
+        void (*rtt_sample)(struct tcp_sock *tp, u32 usrtt);
+        /* call before changing ca_state (optional) */
+        void (*set_state)(struct tcp_sock *tp, u8 new_state);
+        /* call when cwnd event occurs (optional) */
+        void (*cwnd_event)(struct tcp_sock *tp, enum tcp_ca_event ev);
+        /* new value of cwnd after loss (optional) */
+        u32  (*undo_cwnd)(struct tcp_sock *tp);
+        /* hook for packet ack accounting (optional) */
+        void (*pkts_acked)(struct tcp_sock *tp, u32 num_acked);
+        /* get info for tcp_diag (optional) */
+        void (*get_info)(struct tcp_sock *tp, u32 ext, struct sk_buff *skb);
+
+        char            name[TCP_CA_NAME_MAX];
+        struct module   *owner;
+};
+
+extern int tcp_register_congestion_control(struct tcp_congestion_ops *type);
+extern void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
+
+extern void tcp_init_congestion_control(struct tcp_sock *tp);
+extern void tcp_cleanup_congestion_control(struct tcp_sock *tp);
+extern int tcp_set_default_congestion_control(const char *name);
+extern void tcp_get_default_congestion_control(char *name);
+extern int tcp_set_congestion_control(struct tcp_sock *tp, const char *name);
+
+extern struct tcp_congestion_ops tcp_init_congestion_ops;
+extern u32 tcp_reno_ssthresh(struct tcp_sock *tp);
+extern void tcp_reno_cong_avoid(struct tcp_sock *tp, u32 ack,
+                                u32 rtt, u32 in_flight, int flag);
+extern u32 tcp_reno_min_cwnd(struct tcp_sock *tp);
+extern struct tcp_congestion_ops tcp_reno;
+
+static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
+{
+        if (tp->ca_ops->set_state)
+                tp->ca_ops->set_state(tp, ca_state);
+        tp->ca_state = ca_state;
+}
+
+static inline void tcp_ca_event(struct tcp_sock *tp, enum tcp_ca_event event)
+{
+        if (tp->ca_ops->cwnd_event)
+                tp->ca_ops->cwnd_event(tp, event);
+}
+
 /* This determines how many packets are "in the network" to the best
  * of our knowledge.  In many cases it is conservative, but where
  * detailed information is available from the receiver (via SACK
@@ -1223,91 +1214,6 @@ static __inline__ unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
         return (tp->packets_out - tp->left_out + tp->retrans_out);
 }
 
-/*
- * Which congestion algorithim is in use on the connection.
- */
-#define tcp_is_vegas(__tp)      ((__tp)->adv_cong == TCP_VEGAS)
-#define tcp_is_westwood(__tp)   ((__tp)->adv_cong == TCP_WESTWOOD)
-#define tcp_is_bic(__tp)        ((__tp)->adv_cong == TCP_BIC)
-
-/* Recalculate snd_ssthresh, we want to set it to:
- *
- * Reno:
- *      one half the current congestion window, but no
- *      less than two segments
- *
- * BIC:
- *      behave like Reno until low_window is reached,
- *      then increase congestion window slowly
- */
-static inline __u32 tcp_recalc_ssthresh(struct tcp_sock *tp)
-{
-        if (tcp_is_bic(tp)) {
-                if (sysctl_tcp_bic_fast_convergence &&
-                    tp->snd_cwnd < tp->bictcp.last_max_cwnd)
-                        tp->bictcp.last_max_cwnd = (tp->snd_cwnd * 
-                                                    (BICTCP_BETA_SCALE
-                                                     + sysctl_tcp_bic_beta))
-                                / (2 * BICTCP_BETA_SCALE);
-                else
-                        tp->bictcp.last_max_cwnd = tp->snd_cwnd;
-
-                if (tp->snd_cwnd > sysctl_tcp_bic_low_window)
-                        return max((tp->snd_cwnd * sysctl_tcp_bic_beta)
-                                   / BICTCP_BETA_SCALE, 2U);
-        }
-
-        return max(tp->snd_cwnd >> 1U, 2U);
-}
-
-/* Stop taking Vegas samples for now. */
-#define tcp_vegas_disable(__tp) ((__tp)->vegas.doing_vegas_now = 0)
-    
-static inline void tcp_vegas_enable(struct tcp_sock *tp)
-{
-        /* There are several situations when we must "re-start" Vegas:
-         *
-         *  o when a connection is established
-         *  o after an RTO
-         *  o after fast recovery
-         *  o when we send a packet and there is no outstanding
-         *    unacknowledged data (restarting an idle connection)
-         *
-         * In these circumstances we cannot do a Vegas calculation at the
-         * end of the first RTT, because any calculation we do is using
-         * stale info -- both the saved cwnd and congestion feedback are
-         * stale.
-         *
-         * Instead we must wait until the completion of an RTT during
-         * which we actually receive ACKs.
-         */
-    
-        /* Begin taking Vegas samples next time we send something. */
-        tp->vegas.doing_vegas_now = 1;
-     
-        /* Set the beginning of the next send window. */
-        tp->vegas.beg_snd_nxt = tp->snd_nxt;
-
-        tp->vegas.cntRTT = 0;
-        tp->vegas.minRTT = 0x7fffffff;
-}
-
-/* Should we be taking Vegas samples right now? */
-#define tcp_vegas_enabled(__tp) ((__tp)->vegas.doing_vegas_now)
-
-extern void tcp_ca_init(struct tcp_sock *tp);
-
-static inline void tcp_set_ca_state(struct tcp_sock *tp, u8 ca_state)
-{
-        if (tcp_is_vegas(tp)) {
-                if (ca_state == TCP_CA_Open) 
-                        tcp_vegas_enable(tp);
-                else
-                        tcp_vegas_disable(tp);
-        }
-        tp->ca_state = ca_state;
-}
-
 /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
  * The exception is rate halving phase, when cwnd is decreasing towards
  * ssthresh.
@@ -1330,33 +1236,11 @@ static inline void tcp_sync_left_out(struct tcp_sock *tp)
         tp->left_out = tp->sacked_out + tp->lost_out;
 }
 
-extern void tcp_cwnd_application_limited(struct sock *sk);
-
-/* Congestion window validation. (RFC2861) */
-
-static inline void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp)
-{
-        __u32 packets_out = tp->packets_out;
-
-        if (packets_out >= tp->snd_cwnd) {
-                /* Network is feed fully. */
-                tp->snd_cwnd_used = 0;
-                tp->snd_cwnd_stamp = tcp_time_stamp;
-        } else {
-                /* Network starves. */
-                if (tp->packets_out > tp->snd_cwnd_used)
-                        tp->snd_cwnd_used = tp->packets_out;
-
-                if ((s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= tp->rto)
-                        tcp_cwnd_application_limited(sk);
-        }
-}
-
-/* Set slow start threshould and cwnd not falling to slow start */
+/* Set slow start threshold and cwnd not falling to slow start */
 static inline void __tcp_enter_cwr(struct tcp_sock *tp)
 {
         tp->undo_marker = 0;
-        tp->snd_ssthresh = tcp_recalc_ssthresh(tp);
+        tp->snd_ssthresh = tp->ca_ops->ssthresh(tp);
         tp->snd_cwnd = min(tp->snd_cwnd,
                            tcp_packets_in_flight(tp) + 1U);
         tp->snd_cwnd_cnt = 0;
@@ -1384,12 +1268,6 @@ static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp)
         return 3;
 }
 
-static __inline__ int tcp_minshall_check(const struct tcp_sock *tp)
-{
-        return after(tp->snd_sml,tp->snd_una) &&
-                !after(tp->snd_sml, tp->snd_nxt);
-}
-
 static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, 
                                            const struct sk_buff *skb)
 {
@@ -1397,122 +1275,18 @@ static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss,
                 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
 }
 
-/* Return 0, if packet can be sent now without violation Nagle's rules:
-   1. It is full sized.
-   2. Or it contains FIN.
-   3. Or TCP_NODELAY was set.
-   4. Or TCP_CORK is not set, and all sent packets are ACKed.
-      With Minshall's modification: all sent small packets are ACKed.
- */
-
-static __inline__ int
-tcp_nagle_check(const struct tcp_sock *tp, const struct sk_buff *skb, 
-                unsigned mss_now, int nonagle)
-{
-        return (skb->len < mss_now &&
-                !(TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN) &&
-                ((nonagle&TCP_NAGLE_CORK) ||
-                 (!nonagle &&
-                  tp->packets_out &&
-                  tcp_minshall_check(tp))));
-}
-
-extern void tcp_set_skb_tso_segs(struct sock *, struct sk_buff *);
-
-/* This checks if the data bearing packet SKB (usually sk->sk_send_head)
- * should be put on the wire right now.
- */
-static __inline__ int tcp_snd_test(struct sock *sk,
-                                   struct sk_buff *skb,
-                                   unsigned cur_mss, int nonagle)
-{
-        struct tcp_sock *tp = tcp_sk(sk);
-        int pkts = tcp_skb_pcount(skb);
-
-        if (!pkts) {
-                tcp_set_skb_tso_segs(sk, skb);
-                pkts = tcp_skb_pcount(skb);
-        }
-
-        /*      RFC 1122 - section 4.2.3.4
-         *
-         *      We must queue if
-         *
-         *      a) The right edge of this frame exceeds the window
-         *      b) There are packets in flight and we have a small segment
-         *         [SWS avoidance and Nagle algorithm]
-         *         (part of SWS is done on packetization)
-         *         Minshall version sounds: there are no _small_
-         *         segments in flight. (tcp_nagle_check)
-         *      c) We have too many packets 'in flight'
-         *
-         *      Don't use the nagle rule for urgent data (or
-         *      for the final FIN -DaveM).
-         *
-         *      Also, Nagle rule does not apply to frames, which
-         *      sit in the middle of queue (they have no chances
-         *      to get new data) and if room at tail of skb is
-         *      not enough to save something seriously (<32 for now).
-         */
-
-        /* Don't be strict about the congestion window for the
-         * final FIN frame.  -DaveM
-         */
-        return (((nonagle&TCP_NAGLE_PUSH) || tp->urg_mode
-                 || !tcp_nagle_check(tp, skb, cur_mss, nonagle)) &&
-                (((tcp_packets_in_flight(tp) + (pkts-1)) < tp->snd_cwnd) ||
-                 (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)) &&
-                !after(TCP_SKB_CB(skb)->end_seq, tp->snd_una + tp->snd_wnd));
-}
-
 static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp)
 {
         if (!tp->packets_out && !tp->pending)
                 tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, tp->rto);
 }
 
-static __inline__ int tcp_skb_is_last(const struct sock *sk, 
-                                      const struct sk_buff *skb)
-{
-        return skb->next == (struct sk_buff *)&sk->sk_write_queue;
-}
-
-/* Push out any pending frames which were held back due to
- * TCP_CORK or attempt at coalescing tiny packets.
- * The socket must be locked by the caller.
- */
-static __inline__ void __tcp_push_pending_frames(struct sock *sk,
-                                                 struct tcp_sock *tp,
-                                                 unsigned cur_mss,
-                                                 int nonagle)
-{
-        struct sk_buff *skb = sk->sk_send_head;
-
-        if (skb) {
-                if (!tcp_skb_is_last(sk, skb))
-                        nonagle = TCP_NAGLE_PUSH;
-                if (!tcp_snd_test(sk, skb, cur_mss, nonagle) ||
-                    tcp_write_xmit(sk, nonagle))
-                        tcp_check_probe_timer(sk, tp);
-        }
-        tcp_cwnd_validate(sk, tp);
-}
-
 static __inline__ void tcp_push_pending_frames(struct sock *sk,
                                                struct tcp_sock *tp)
 {
         __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle);
 }
 
-static __inline__ int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp)
-{
-        struct sk_buff *skb = sk->sk_send_head;
-
-        return (skb &&
-                tcp_snd_test(sk, skb, tcp_current_mss(sk, 1),
-                             tcp_skb_is_last(sk, skb) ? TCP_NAGLE_PUSH : tp->nonagle));
-}
-
 static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq)
 {
         tp->snd_wl1 = seq;
@@ -1750,99 +1524,71 @@ static inline int tcp_full_space(const struct sock *sk)
         return tcp_win_from_space(sk->sk_rcvbuf); 
 }
 
-static inline void tcp_acceptq_queue(struct sock *sk, struct open_request *req,
+static inline void tcp_acceptq_queue(struct sock *sk, struct request_sock *req,
                                          struct sock *child)
 {
-        struct tcp_sock *tp = tcp_sk(sk);
-
-        req->sk = child;
-        sk_acceptq_added(sk);
-
-        if (!tp->accept_queue_tail) {
-                tp->accept_queue = req;
-        } else {
-                tp->accept_queue_tail->dl_next = req;
-        }
-        tp->accept_queue_tail = req;
-        req->dl_next = NULL;
+        reqsk_queue_add(&tcp_sk(sk)->accept_queue, req, sk, child);
 }
 
-struct tcp_listen_opt
-{
-        u8                      max_qlen_log;   /* log_2 of maximal queued SYNs */
-        int                     qlen;
-        int                     qlen_young;
-        int                     clock_hand;
-        u32                     hash_rnd;
-        struct open_request     *syn_table[TCP_SYNQ_HSIZE];
-};
-
 static inline void
-tcp_synq_removed(struct sock *sk, struct open_request *req)
+tcp_synq_removed(struct sock *sk, struct request_sock *req)
 {
-        struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt;
-
-        if (--lopt->qlen == 0)
+        if (reqsk_queue_removed(&tcp_sk(sk)->accept_queue, req) == 0)
                 tcp_delete_keepalive_timer(sk);
-        if (req->retrans == 0)
-                lopt->qlen_young--;
 }
 
 static inline void tcp_synq_added(struct sock *sk)
 {
-        struct tcp_listen_opt *lopt = tcp_sk(sk)->listen_opt;
-
-        if (lopt->qlen++ == 0)
+        if (reqsk_queue_added(&tcp_sk(sk)->accept_queue) == 0)
                 tcp_reset_keepalive_timer(sk, TCP_TIMEOUT_INIT);
-        lopt->qlen_young++;
 }
 
 static inline int tcp_synq_len(struct sock *sk)
 {
-        return tcp_sk(sk)->listen_opt->qlen;
+        return reqsk_queue_len(&tcp_sk(sk)->accept_queue);
 }
 
 static inline int tcp_synq_young(struct sock *sk)
 {
-        return tcp_sk(sk)->listen_opt->qlen_young;
+        return reqsk_queue_len_young(&tcp_sk(sk)->accept_queue);
 }
 
 static inline int tcp_synq_is_full(struct sock *sk)
 {
-        return tcp_synq_len(sk) >> tcp_sk(sk)->listen_opt->max_qlen_log;
+        return reqsk_queue_is_full(&tcp_sk(sk)->accept_queue);
 }
 
-static inline void tcp_synq_unlink(struct tcp_sock *tp, struct open_request *req,
-                                       struct open_request **prev)
+static inline void tcp_synq_unlink(struct tcp_sock *tp, struct request_sock *req,
+                                   struct request_sock **prev)
 {
-        write_lock(&tp->syn_wait_lock);
-        *prev = req->dl_next;
-        write_unlock(&tp->syn_wait_lock);
+        reqsk_queue_unlink(&tp->accept_queue, req, prev);
 }
 
-static inline void tcp_synq_drop(struct sock *sk, struct open_request *req,
-                                     struct open_request **prev)
+static inline void tcp_synq_drop(struct sock *sk, struct request_sock *req,
+                                     struct request_sock **prev)
 {
         tcp_synq_unlink(tcp_sk(sk), req, prev);
         tcp_synq_removed(sk, req);
-        tcp_openreq_free(req);
+        reqsk_free(req);
 }
 
-static __inline__ void tcp_openreq_init(struct open_request *req,
+static __inline__ void tcp_openreq_init(struct request_sock *req,
                                         struct tcp_options_received *rx_opt,
                                         struct sk_buff *skb)
 {
+        struct inet_request_sock *ireq = inet_rsk(req);
+
         req->rcv_wnd = 0;               /* So that tcp_send_synack() knows! */
-        req->rcv_isn = TCP_SKB_CB(skb)->seq;
+        tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
         req->mss = rx_opt->mss_clamp;
         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
-        req->tstamp_ok = rx_opt->tstamp_ok;
-        req->sack_ok = rx_opt->sack_ok;
-        req->snd_wscale = rx_opt->snd_wscale;
-        req->wscale_ok = rx_opt->wscale_ok;
-        req->acked = 0;
-        req->ecn_ok = 0;
-        req->rmt_port = skb->h.th->source;
+        ireq->tstamp_ok = rx_opt->tstamp_ok;
+        ireq->sack_ok = rx_opt->sack_ok;
+        ireq->snd_wscale = rx_opt->snd_wscale;
+        ireq->wscale_ok = rx_opt->wscale_ok;
+        ireq->acked = 0;
+        ireq->ecn_ok = 0;
+        ireq->rmt_port = skb->h.th->source;
 }
 
 extern void tcp_enter_memory_pressure(void);
@@ -1972,52 +1718,4 @@ struct tcp_iter_state {
 extern int tcp_proc_register(struct tcp_seq_afinfo *afinfo);
 extern void tcp_proc_unregister(struct tcp_seq_afinfo *afinfo);
 
-/* TCP Westwood functions and constants */
-
-#define TCP_WESTWOOD_INIT_RTT  (20*HZ)           /* maybe too conservative?! */
-#define TCP_WESTWOOD_RTT_MIN   (HZ/20)           /* 50ms */
-
-static inline void tcp_westwood_update_rtt(struct tcp_sock *tp, __u32 rtt_seq)
-{
-        if (tcp_is_westwood(tp))
-                tp->westwood.rtt = rtt_seq;
-}
-
-static inline __u32 __tcp_westwood_bw_rttmin(const struct tcp_sock *tp)
-{
-        return max((tp->westwood.bw_est) * (tp->westwood.rtt_min) /
-                   (__u32) (tp->mss_cache_std),
-                   2U);
-}
-
-static inline __u32 tcp_westwood_bw_rttmin(const struct tcp_sock *tp)
-{
-        return tcp_is_westwood(tp) ? __tcp_westwood_bw_rttmin(tp) : 0;
-}
-
-static inline int tcp_westwood_ssthresh(struct tcp_sock *tp)
-{
-        __u32 ssthresh = 0;
-
-        if (tcp_is_westwood(tp)) {
-                ssthresh = __tcp_westwood_bw_rttmin(tp);
-                if (ssthresh)
-                        tp->snd_ssthresh = ssthresh;  
-        }
-
-        return (ssthresh != 0);
-}
-
-static inline int tcp_westwood_cwnd(struct tcp_sock *tp)
-{
-        __u32 cwnd = 0;
-
-        if (tcp_is_westwood(tp)) {
-                cwnd = __tcp_westwood_bw_rttmin(tp);
-                if (cwnd)
-                        tp->snd_cwnd = cwnd;
-        }
-
-        return (cwnd != 0);
-}
 #endif  /* _TCP_H */
diff --git a/include/net/tcp_ecn.h b/include/net/tcp_ecn.h
index dc1456389a97..64980ee8c92a 100644
--- a/include/net/tcp_ecn.h
+++ b/include/net/tcp_ecn.h
@@ -2,6 +2,7 @@
 #define _NET_TCP_ECN_H_ 1
 
 #include <net/inet_ecn.h>
+#include <net/request_sock.h>
 
 #define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
 
@@ -38,9 +39,9 @@ static inline void TCP_ECN_send_syn(struct sock *sk, struct tcp_sock *tp,
 }
 
 static __inline__ void
-TCP_ECN_make_synack(struct open_request *req, struct tcphdr *th)
+TCP_ECN_make_synack(struct request_sock *req, struct tcphdr *th)
 {
-        if (req->ecn_ok)
+        if (inet_rsk(req)->ecn_ok)
                 th->ece = 1;
 }
 
@@ -111,16 +112,16 @@ static inline int TCP_ECN_rcv_ecn_echo(struct tcp_sock *tp, struct tcphdr *th)
 }
 
 static inline void TCP_ECN_openreq_child(struct tcp_sock *tp,
-                                         struct open_request *req)
+                                         struct request_sock *req)
 {
-        tp->ecn_flags = req->ecn_ok ? TCP_ECN_OK : 0;
+        tp->ecn_flags = inet_rsk(req)->ecn_ok ? TCP_ECN_OK : 0;
 }
 
 static __inline__ void
-TCP_ECN_create_request(struct open_request *req, struct tcphdr *th)
+TCP_ECN_create_request(struct request_sock *req, struct tcphdr *th)
 {
         if (sysctl_tcp_ecn && th->ece && th->cwr)
-                req->ecn_ok = 1;
+                inet_rsk(req)->ecn_ok = 1;
 }
 
 #endif
diff --git a/include/net/x25.h b/include/net/x25.h
index 7a1ba5bbb868..8b39b98876e8 100644
--- a/include/net/x25.h
+++ b/include/net/x25.h
@@ -79,6 +79,8 @@ enum {
 #define X25_DEFAULT_PACKET_SIZE X25_PS128               /* Default Packet Size */
 #define X25_DEFAULT_THROUGHPUT  0x0A                    /* Deafult Throughput */
 #define X25_DEFAULT_REVERSE     0x00                    /* Default Reverse Charging */
+#define X25_DENY_ACCPT_APPRV   0x01                     /* Default value */
+#define X25_ALLOW_ACCPT_APPRV  0x00                     /* Control enabled */
 
 #define X25_SMODULUS            8
 #define X25_EMODULUS            128
@@ -94,7 +96,7 @@ enum {
 #define X25_FAC_CLASS_C         0x80
 #define X25_FAC_CLASS_D         0xC0
 
-#define X25_FAC_REVERSE         0x01
+#define X25_FAC_REVERSE         0x01                    /* also fast select */
 #define X25_FAC_THROUGHPUT      0x02
 #define X25_FAC_PACKET_SIZE     0x42
 #define X25_FAC_WINDOW_SIZE     0x43
@@ -134,8 +136,8 @@ struct x25_sock {
         struct sock             sk;
         struct x25_address      source_addr, dest_addr;
         struct x25_neigh        *neighbour;
-        unsigned int            lci;
-        unsigned char           state, condition, qbitincl, intflag;
+        unsigned int            lci, cudmatchlength;
+        unsigned char           state, condition, qbitincl, intflag, accptapprv;
         unsigned short          vs, vr, va, vl;
         unsigned long           t2, t21, t22, t23;
         unsigned short          fraglen;
@@ -242,7 +244,6 @@ extern int  x25_validate_nr(struct sock *, unsigned short);
 extern void x25_write_internal(struct sock *, int);
 extern int  x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *);
 extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char);
-extern int x25_check_calluserdata(struct x25_calluserdata *,struct x25_calluserdata *);
 
 /* x25_timer.c */
 extern void x25_start_heartbeat(struct sock *);
diff --git a/include/net/x25device.h b/include/net/x25device.h
index cf36a20ea3c5..d45ae883bd1d 100644
--- a/include/net/x25device.h
+++ b/include/net/x25device.h
@@ -5,8 +5,7 @@
 #include <linux/if_packet.h>
 #include <linux/skbuff.h>
 
-static inline unsigned short x25_type_trans(struct sk_buff *skb,
-                                            struct net_device *dev)
+static inline __be16 x25_type_trans(struct sk_buff *skb, struct net_device *dev)
 {
         skb->mac.raw = skb->data;
         skb->input_dev = skb->dev = dev;
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index d675836ba6c3..868ef88ef971 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -158,6 +158,20 @@ enum {
         XFRM_STATE_DEAD
 };
 
+/* callback structure passed from either netlink or pfkey */
+struct km_event
+{
+        union {
+                u32 hard;
+                u32 proto;
+                u32 byid;
+        } data;
+
+        u32     seq;
+        u32     pid;
+        u32     event;
+};
+
 struct xfrm_type;
 struct xfrm_dst;
 struct xfrm_policy_afinfo {
@@ -179,6 +193,8 @@ struct xfrm_policy_afinfo {
 
 extern int xfrm_policy_register_afinfo(struct xfrm_policy_afinfo *afinfo);
 extern int xfrm_policy_unregister_afinfo(struct xfrm_policy_afinfo *afinfo);
+extern void km_policy_notify(struct xfrm_policy *xp, int dir, struct km_event *c);
+extern void km_state_notify(struct xfrm_state *x, struct km_event *c);
 
 #define XFRM_ACQ_EXPIRES        30
 
@@ -188,6 +204,7 @@ struct xfrm_state_afinfo {
         rwlock_t                lock;
         struct list_head        *state_bydst;
         struct list_head        *state_byspi;
+        int                     (*init_flags)(struct xfrm_state *x);
         void                    (*init_tempsel)(struct xfrm_state *x, struct flowi *fl,
                                                 struct xfrm_tmpl *tmpl,
                                                 xfrm_address_t *daddr, xfrm_address_t *saddr);
@@ -209,7 +226,7 @@ struct xfrm_type
         struct module           *owner;
         __u8                    proto;
 
-        int                     (*init_state)(struct xfrm_state *x, void *args);
+        int                     (*init_state)(struct xfrm_state *x);
         void                    (*destructor)(struct xfrm_state *);
         int                     (*input)(struct xfrm_state *, struct xfrm_decap_state *, struct sk_buff *skb);
         int                     (*post_input)(struct xfrm_state *, struct xfrm_decap_state *, struct sk_buff *skb);
@@ -290,11 +307,11 @@ struct xfrm_mgr
 {
         struct list_head        list;
         char                    *id;
-        int                     (*notify)(struct xfrm_state *x, int event);
+        int                     (*notify)(struct xfrm_state *x, struct km_event *c);
         int                     (*acquire)(struct xfrm_state *x, struct xfrm_tmpl *, struct xfrm_policy *xp, int dir);
         struct xfrm_policy      *(*compile_policy)(u16 family, int opt, u8 *data, int len, int *dir);
         int                     (*new_mapping)(struct xfrm_state *x, xfrm_address_t *ipaddr, u16 sport);
-        int                     (*notify_policy)(struct xfrm_policy *x, int dir, int event);
+        int                     (*notify_policy)(struct xfrm_policy *x, int dir, struct km_event *c);
 };
 
 extern int xfrm_register_km(struct xfrm_mgr *km);
@@ -656,7 +673,7 @@ static inline int xfrm_sk_clone_policy(struct sock *sk)
         return 0;
 }
 
-extern void xfrm_policy_delete(struct xfrm_policy *pol, int dir);
+extern int xfrm_policy_delete(struct xfrm_policy *pol, int dir);
 
 static inline void xfrm_sk_free_policy(struct sock *sk)
 {
@@ -786,7 +803,7 @@ struct xfrm_algo_desc {
 /* XFRM tunnel handlers.  */
 struct xfrm_tunnel {
         int (*handler)(struct sk_buff *skb);
-        void (*err_handler)(struct sk_buff *skb, void *info);
+        void (*err_handler)(struct sk_buff *skb, __u32 info);
 };
 
 struct xfrm6_tunnel {
@@ -817,12 +834,13 @@ extern int xfrm_state_add(struct xfrm_state *x);
 extern int xfrm_state_update(struct xfrm_state *x);
 extern struct xfrm_state *xfrm_state_lookup(xfrm_address_t *daddr, u32 spi, u8 proto, unsigned short family);
 extern struct xfrm_state *xfrm_find_acq_byseq(u32 seq);
-extern void xfrm_state_delete(struct xfrm_state *x);
+extern int xfrm_state_delete(struct xfrm_state *x);
 extern void xfrm_state_flush(u8 proto);
 extern int xfrm_replay_check(struct xfrm_state *x, u32 seq);
 extern void xfrm_replay_advance(struct xfrm_state *x, u32 seq);
 extern int xfrm_state_check(struct xfrm_state *x, struct sk_buff *skb);
 extern int xfrm_state_mtu(struct xfrm_state *x, int mtu);
+extern int xfrm_init_state(struct xfrm_state *x);
 extern int xfrm4_rcv(struct sk_buff *skb);
 extern int xfrm4_output(struct sk_buff *skb);
 extern int xfrm4_tunnel_register(struct xfrm_tunnel *handler);