diff options
Diffstat (limited to 'include/net')
-rw-r--r-- | include/net/ieee80211.h | 856 | ||||
-rw-r--r-- | include/net/ipv6.h | 1 | ||||
-rw-r--r-- | include/net/pkt_sched.h | 17 | ||||
-rw-r--r-- | include/net/sch_generic.h | 13 | ||||
-rw-r--r-- | include/net/sctp/constants.h | 18 | ||||
-rw-r--r-- | include/net/sctp/structs.h | 4 | ||||
-rw-r--r-- | include/net/slhc_vj.h | 21 | ||||
-rw-r--r-- | include/net/sock.h | 7 | ||||
-rw-r--r-- | include/net/tcp.h | 156 |
9 files changed, 909 insertions, 184 deletions
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 @@ | |||
1 | /* | ||
2 | * Merged with mainline ieee80211.h in Aug 2004. Original ieee802_11 | ||
3 | * remains copyright by the original authors | ||
4 | * | ||
5 | * Portions of the merged code are based on Host AP (software wireless | ||
6 | * LAN access point) driver for Intersil Prism2/2.5/3. | ||
7 | * | ||
8 | * Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen | ||
9 | * <jkmaline@cc.hut.fi> | ||
10 | * Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi> | ||
11 | * | ||
12 | * Adaption to a generic IEEE 802.11 stack by James Ketrenos | ||
13 | * <jketreno@linux.intel.com> | ||
14 | * Copyright (c) 2004, Intel Corporation | ||
15 | * | ||
16 | * This program is free software; you can redistribute it and/or modify | ||
17 | * it under the terms of the GNU General Public License version 2 as | ||
18 | * published by the Free Software Foundation. See README and COPYING for | ||
19 | * more details. | ||
20 | */ | ||
21 | #ifndef IEEE80211_H | ||
22 | #define IEEE80211_H | ||
23 | |||
24 | #include <linux/if_ether.h> /* ETH_ALEN */ | ||
25 | #include <linux/kernel.h> /* ARRAY_SIZE */ | ||
26 | |||
27 | #if WIRELESS_EXT < 17 | ||
28 | #define IW_QUAL_QUAL_INVALID 0x10 | ||
29 | #define IW_QUAL_LEVEL_INVALID 0x20 | ||
30 | #define IW_QUAL_NOISE_INVALID 0x40 | ||
31 | #define IW_QUAL_QUAL_UPDATED 0x1 | ||
32 | #define IW_QUAL_LEVEL_UPDATED 0x2 | ||
33 | #define IW_QUAL_NOISE_UPDATED 0x4 | ||
34 | #endif | ||
35 | |||
36 | #define IEEE80211_DATA_LEN 2304 | ||
37 | /* Maximum size for the MA-UNITDATA primitive, 802.11 standard section | ||
38 | 6.2.1.1.2. | ||
39 | |||
40 | The figure in section 7.1.2 suggests a body size of up to 2312 | ||
41 | bytes is allowed, which is a bit confusing, I suspect this | ||
42 | represents the 2304 bytes of real data, plus a possible 8 bytes of | ||
43 | WEP IV and ICV. (this interpretation suggested by Ramiro Barreiro) */ | ||
44 | |||
45 | |||
46 | #define IEEE80211_HLEN 30 | ||
47 | #define IEEE80211_FRAME_LEN (IEEE80211_DATA_LEN + IEEE80211_HLEN) | ||
48 | |||
49 | struct ieee80211_hdr { | ||
50 | u16 frame_ctl; | ||
51 | u16 duration_id; | ||
52 | u8 addr1[ETH_ALEN]; | ||
53 | u8 addr2[ETH_ALEN]; | ||
54 | u8 addr3[ETH_ALEN]; | ||
55 | u16 seq_ctl; | ||
56 | u8 addr4[ETH_ALEN]; | ||
57 | } __attribute__ ((packed)); | ||
58 | |||
59 | struct ieee80211_hdr_3addr { | ||
60 | u16 frame_ctl; | ||
61 | u16 duration_id; | ||
62 | u8 addr1[ETH_ALEN]; | ||
63 | u8 addr2[ETH_ALEN]; | ||
64 | u8 addr3[ETH_ALEN]; | ||
65 | u16 seq_ctl; | ||
66 | } __attribute__ ((packed)); | ||
67 | |||
68 | enum eap_type { | ||
69 | EAP_PACKET = 0, | ||
70 | EAPOL_START, | ||
71 | EAPOL_LOGOFF, | ||
72 | EAPOL_KEY, | ||
73 | EAPOL_ENCAP_ASF_ALERT | ||
74 | }; | ||
75 | |||
76 | static const char *eap_types[] = { | ||
77 | [EAP_PACKET] = "EAP-Packet", | ||
78 | [EAPOL_START] = "EAPOL-Start", | ||
79 | [EAPOL_LOGOFF] = "EAPOL-Logoff", | ||
80 | [EAPOL_KEY] = "EAPOL-Key", | ||
81 | [EAPOL_ENCAP_ASF_ALERT] = "EAPOL-Encap-ASF-Alert" | ||
82 | }; | ||
83 | |||
84 | static inline const char *eap_get_type(int type) | ||
85 | { | ||
86 | return (type >= ARRAY_SIZE(eap_types)) ? "Unknown" : eap_types[type]; | ||
87 | } | ||
88 | |||
89 | struct eapol { | ||
90 | u8 snap[6]; | ||
91 | u16 ethertype; | ||
92 | u8 version; | ||
93 | u8 type; | ||
94 | u16 length; | ||
95 | } __attribute__ ((packed)); | ||
96 | |||
97 | #define IEEE80211_1ADDR_LEN 10 | ||
98 | #define IEEE80211_2ADDR_LEN 16 | ||
99 | #define IEEE80211_3ADDR_LEN 24 | ||
100 | #define IEEE80211_4ADDR_LEN 30 | ||
101 | #define IEEE80211_FCS_LEN 4 | ||
102 | |||
103 | #define MIN_FRAG_THRESHOLD 256U | ||
104 | #define MAX_FRAG_THRESHOLD 2346U | ||
105 | |||
106 | /* Frame control field constants */ | ||
107 | #define IEEE80211_FCTL_VERS 0x0002 | ||
108 | #define IEEE80211_FCTL_FTYPE 0x000c | ||
109 | #define IEEE80211_FCTL_STYPE 0x00f0 | ||
110 | #define IEEE80211_FCTL_TODS 0x0100 | ||
111 | #define IEEE80211_FCTL_FROMDS 0x0200 | ||
112 | #define IEEE80211_FCTL_MOREFRAGS 0x0400 | ||
113 | #define IEEE80211_FCTL_RETRY 0x0800 | ||
114 | #define IEEE80211_FCTL_PM 0x1000 | ||
115 | #define IEEE80211_FCTL_MOREDATA 0x2000 | ||
116 | #define IEEE80211_FCTL_WEP 0x4000 | ||
117 | #define IEEE80211_FCTL_ORDER 0x8000 | ||
118 | |||
119 | #define IEEE80211_FTYPE_MGMT 0x0000 | ||
120 | #define IEEE80211_FTYPE_CTL 0x0004 | ||
121 | #define IEEE80211_FTYPE_DATA 0x0008 | ||
122 | |||
123 | /* management */ | ||
124 | #define IEEE80211_STYPE_ASSOC_REQ 0x0000 | ||
125 | #define IEEE80211_STYPE_ASSOC_RESP 0x0010 | ||
126 | #define IEEE80211_STYPE_REASSOC_REQ 0x0020 | ||
127 | #define IEEE80211_STYPE_REASSOC_RESP 0x0030 | ||
128 | #define IEEE80211_STYPE_PROBE_REQ 0x0040 | ||
129 | #define IEEE80211_STYPE_PROBE_RESP 0x0050 | ||
130 | #define IEEE80211_STYPE_BEACON 0x0080 | ||
131 | #define IEEE80211_STYPE_ATIM 0x0090 | ||
132 | #define IEEE80211_STYPE_DISASSOC 0x00A0 | ||
133 | #define IEEE80211_STYPE_AUTH 0x00B0 | ||
134 | #define IEEE80211_STYPE_DEAUTH 0x00C0 | ||
135 | |||
136 | /* control */ | ||
137 | #define IEEE80211_STYPE_PSPOLL 0x00A0 | ||
138 | #define IEEE80211_STYPE_RTS 0x00B0 | ||
139 | #define IEEE80211_STYPE_CTS 0x00C0 | ||
140 | #define IEEE80211_STYPE_ACK 0x00D0 | ||
141 | #define IEEE80211_STYPE_CFEND 0x00E0 | ||
142 | #define IEEE80211_STYPE_CFENDACK 0x00F0 | ||
143 | |||
144 | /* data */ | ||
145 | #define IEEE80211_STYPE_DATA 0x0000 | ||
146 | #define IEEE80211_STYPE_DATA_CFACK 0x0010 | ||
147 | #define IEEE80211_STYPE_DATA_CFPOLL 0x0020 | ||
148 | #define IEEE80211_STYPE_DATA_CFACKPOLL 0x0030 | ||
149 | #define IEEE80211_STYPE_NULLFUNC 0x0040 | ||
150 | #define IEEE80211_STYPE_CFACK 0x0050 | ||
151 | #define IEEE80211_STYPE_CFPOLL 0x0060 | ||
152 | #define IEEE80211_STYPE_CFACKPOLL 0x0070 | ||
153 | |||
154 | #define IEEE80211_SCTL_FRAG 0x000F | ||
155 | #define IEEE80211_SCTL_SEQ 0xFFF0 | ||
156 | |||
157 | |||
158 | /* debug macros */ | ||
159 | |||
160 | #ifdef CONFIG_IEEE80211_DEBUG | ||
161 | extern u32 ieee80211_debug_level; | ||
162 | #define IEEE80211_DEBUG(level, fmt, args...) \ | ||
163 | do { if (ieee80211_debug_level & (level)) \ | ||
164 | printk(KERN_DEBUG "ieee80211: %c %s " fmt, \ | ||
165 | in_interrupt() ? 'I' : 'U', __FUNCTION__ , ## args); } while (0) | ||
166 | #else | ||
167 | #define IEEE80211_DEBUG(level, fmt, args...) do {} while (0) | ||
168 | #endif /* CONFIG_IEEE80211_DEBUG */ | ||
169 | |||
170 | /* | ||
171 | * To use the debug system; | ||
172 | * | ||
173 | * If you are defining a new debug classification, simply add it to the #define | ||
174 | * list here in the form of: | ||
175 | * | ||
176 | * #define IEEE80211_DL_xxxx VALUE | ||
177 | * | ||
178 | * shifting value to the left one bit from the previous entry. xxxx should be | ||
179 | * the name of the classification (for example, WEP) | ||
180 | * | ||
181 | * You then need to either add a IEEE80211_xxxx_DEBUG() macro definition for your | ||
182 | * classification, or use IEEE80211_DEBUG(IEEE80211_DL_xxxx, ...) whenever you want | ||
183 | * to send output to that classification. | ||
184 | * | ||
185 | * To add your debug level to the list of levels seen when you perform | ||
186 | * | ||
187 | * % cat /proc/net/ipw/debug_level | ||
188 | * | ||
189 | * you simply need to add your entry to the ipw_debug_levels array. | ||
190 | * | ||
191 | * If you do not see debug_level in /proc/net/ipw then you do not have | ||
192 | * CONFIG_IEEE80211_DEBUG defined in your kernel configuration | ||
193 | * | ||
194 | */ | ||
195 | |||
196 | #define IEEE80211_DL_INFO (1<<0) | ||
197 | #define IEEE80211_DL_WX (1<<1) | ||
198 | #define IEEE80211_DL_SCAN (1<<2) | ||
199 | #define IEEE80211_DL_STATE (1<<3) | ||
200 | #define IEEE80211_DL_MGMT (1<<4) | ||
201 | #define IEEE80211_DL_FRAG (1<<5) | ||
202 | #define IEEE80211_DL_EAP (1<<6) | ||
203 | #define IEEE80211_DL_DROP (1<<7) | ||
204 | |||
205 | #define IEEE80211_DL_TX (1<<8) | ||
206 | #define IEEE80211_DL_RX (1<<9) | ||
207 | |||
208 | #define IEEE80211_ERROR(f, a...) printk(KERN_ERR "ieee80211: " f, ## a) | ||
209 | #define IEEE80211_WARNING(f, a...) printk(KERN_WARNING "ieee80211: " f, ## a) | ||
210 | #define IEEE80211_DEBUG_INFO(f, a...) IEEE80211_DEBUG(IEEE80211_DL_INFO, f, ## a) | ||
211 | |||
212 | #define IEEE80211_DEBUG_WX(f, a...) IEEE80211_DEBUG(IEEE80211_DL_WX, f, ## a) | ||
213 | #define IEEE80211_DEBUG_SCAN(f, a...) IEEE80211_DEBUG(IEEE80211_DL_SCAN, f, ## a) | ||
214 | #define IEEE80211_DEBUG_STATE(f, a...) IEEE80211_DEBUG(IEEE80211_DL_STATE, f, ## a) | ||
215 | #define IEEE80211_DEBUG_MGMT(f, a...) IEEE80211_DEBUG(IEEE80211_DL_MGMT, f, ## a) | ||
216 | #define IEEE80211_DEBUG_FRAG(f, a...) IEEE80211_DEBUG(IEEE80211_DL_FRAG, f, ## a) | ||
217 | #define IEEE80211_DEBUG_EAP(f, a...) IEEE80211_DEBUG(IEEE80211_DL_EAP, f, ## a) | ||
218 | #define IEEE80211_DEBUG_DROP(f, a...) IEEE80211_DEBUG(IEEE80211_DL_DROP, f, ## a) | ||
219 | #define IEEE80211_DEBUG_TX(f, a...) IEEE80211_DEBUG(IEEE80211_DL_TX, f, ## a) | ||
220 | #define IEEE80211_DEBUG_RX(f, a...) IEEE80211_DEBUG(IEEE80211_DL_RX, f, ## a) | ||
221 | #include <linux/netdevice.h> | ||
222 | #include <linux/wireless.h> | ||
223 | #include <linux/if_arp.h> /* ARPHRD_ETHER */ | ||
224 | |||
225 | #ifndef WIRELESS_SPY | ||
226 | #define WIRELESS_SPY // enable iwspy support | ||
227 | #endif | ||
228 | #include <net/iw_handler.h> // new driver API | ||
229 | |||
230 | #ifndef ETH_P_PAE | ||
231 | #define ETH_P_PAE 0x888E /* Port Access Entity (IEEE 802.1X) */ | ||
232 | #endif /* ETH_P_PAE */ | ||
233 | |||
234 | #define ETH_P_PREAUTH 0x88C7 /* IEEE 802.11i pre-authentication */ | ||
235 | |||
236 | #ifndef ETH_P_80211_RAW | ||
237 | #define ETH_P_80211_RAW (ETH_P_ECONET + 1) | ||
238 | #endif | ||
239 | |||
240 | /* IEEE 802.11 defines */ | ||
241 | |||
242 | #define P80211_OUI_LEN 3 | ||
243 | |||
244 | struct ieee80211_snap_hdr { | ||
245 | |||
246 | u8 dsap; /* always 0xAA */ | ||
247 | u8 ssap; /* always 0xAA */ | ||
248 | u8 ctrl; /* always 0x03 */ | ||
249 | u8 oui[P80211_OUI_LEN]; /* organizational universal id */ | ||
250 | |||
251 | } __attribute__ ((packed)); | ||
252 | |||
253 | #define SNAP_SIZE sizeof(struct ieee80211_snap_hdr) | ||
254 | |||
255 | #define WLAN_FC_GET_TYPE(fc) ((fc) & IEEE80211_FCTL_FTYPE) | ||
256 | #define WLAN_FC_GET_STYPE(fc) ((fc) & IEEE80211_FCTL_STYPE) | ||
257 | |||
258 | #define WLAN_GET_SEQ_FRAG(seq) ((seq) & IEEE80211_SCTL_FRAG) | ||
259 | #define WLAN_GET_SEQ_SEQ(seq) ((seq) & IEEE80211_SCTL_SEQ) | ||
260 | |||
261 | /* Authentication algorithms */ | ||
262 | #define WLAN_AUTH_OPEN 0 | ||
263 | #define WLAN_AUTH_SHARED_KEY 1 | ||
264 | |||
265 | #define WLAN_AUTH_CHALLENGE_LEN 128 | ||
266 | |||
267 | #define WLAN_CAPABILITY_BSS (1<<0) | ||
268 | #define WLAN_CAPABILITY_IBSS (1<<1) | ||
269 | #define WLAN_CAPABILITY_CF_POLLABLE (1<<2) | ||
270 | #define WLAN_CAPABILITY_CF_POLL_REQUEST (1<<3) | ||
271 | #define WLAN_CAPABILITY_PRIVACY (1<<4) | ||
272 | #define WLAN_CAPABILITY_SHORT_PREAMBLE (1<<5) | ||
273 | #define WLAN_CAPABILITY_PBCC (1<<6) | ||
274 | #define WLAN_CAPABILITY_CHANNEL_AGILITY (1<<7) | ||
275 | |||
276 | /* Status codes */ | ||
277 | #define WLAN_STATUS_SUCCESS 0 | ||
278 | #define WLAN_STATUS_UNSPECIFIED_FAILURE 1 | ||
279 | #define WLAN_STATUS_CAPS_UNSUPPORTED 10 | ||
280 | #define WLAN_STATUS_REASSOC_NO_ASSOC 11 | ||
281 | #define WLAN_STATUS_ASSOC_DENIED_UNSPEC 12 | ||
282 | #define WLAN_STATUS_NOT_SUPPORTED_AUTH_ALG 13 | ||
283 | #define WLAN_STATUS_UNKNOWN_AUTH_TRANSACTION 14 | ||
284 | #define WLAN_STATUS_CHALLENGE_FAIL 15 | ||
285 | #define WLAN_STATUS_AUTH_TIMEOUT 16 | ||
286 | #define WLAN_STATUS_AP_UNABLE_TO_HANDLE_NEW_STA 17 | ||
287 | #define WLAN_STATUS_ASSOC_DENIED_RATES 18 | ||
288 | /* 802.11b */ | ||
289 | #define WLAN_STATUS_ASSOC_DENIED_NOSHORT 19 | ||
290 | #define WLAN_STATUS_ASSOC_DENIED_NOPBCC 20 | ||
291 | #define WLAN_STATUS_ASSOC_DENIED_NOAGILITY 21 | ||
292 | |||
293 | /* Reason codes */ | ||
294 | #define WLAN_REASON_UNSPECIFIED 1 | ||
295 | #define WLAN_REASON_PREV_AUTH_NOT_VALID 2 | ||
296 | #define WLAN_REASON_DEAUTH_LEAVING 3 | ||
297 | #define WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY 4 | ||
298 | #define WLAN_REASON_DISASSOC_AP_BUSY 5 | ||
299 | #define WLAN_REASON_CLASS2_FRAME_FROM_NONAUTH_STA 6 | ||
300 | #define WLAN_REASON_CLASS3_FRAME_FROM_NONASSOC_STA 7 | ||
301 | #define WLAN_REASON_DISASSOC_STA_HAS_LEFT 8 | ||
302 | #define WLAN_REASON_STA_REQ_ASSOC_WITHOUT_AUTH 9 | ||
303 | |||
304 | |||
305 | #define IEEE80211_STATMASK_SIGNAL (1<<0) | ||
306 | #define IEEE80211_STATMASK_RSSI (1<<1) | ||
307 | #define IEEE80211_STATMASK_NOISE (1<<2) | ||
308 | #define IEEE80211_STATMASK_RATE (1<<3) | ||
309 | #define IEEE80211_STATMASK_WEMASK 0x7 | ||
310 | |||
311 | |||
312 | #define IEEE80211_CCK_MODULATION (1<<0) | ||
313 | #define IEEE80211_OFDM_MODULATION (1<<1) | ||
314 | |||
315 | #define IEEE80211_24GHZ_BAND (1<<0) | ||
316 | #define IEEE80211_52GHZ_BAND (1<<1) | ||
317 | |||
318 | #define IEEE80211_CCK_RATE_1MB 0x02 | ||
319 | #define IEEE80211_CCK_RATE_2MB 0x04 | ||
320 | #define IEEE80211_CCK_RATE_5MB 0x0B | ||
321 | #define IEEE80211_CCK_RATE_11MB 0x16 | ||
322 | #define IEEE80211_OFDM_RATE_6MB 0x0C | ||
323 | #define IEEE80211_OFDM_RATE_9MB 0x12 | ||
324 | #define IEEE80211_OFDM_RATE_12MB 0x18 | ||
325 | #define IEEE80211_OFDM_RATE_18MB 0x24 | ||
326 | #define IEEE80211_OFDM_RATE_24MB 0x30 | ||
327 | #define IEEE80211_OFDM_RATE_36MB 0x48 | ||
328 | #define IEEE80211_OFDM_RATE_48MB 0x60 | ||
329 | #define IEEE80211_OFDM_RATE_54MB 0x6C | ||
330 | #define IEEE80211_BASIC_RATE_MASK 0x80 | ||
331 | |||
332 | #define IEEE80211_CCK_RATE_1MB_MASK (1<<0) | ||
333 | #define IEEE80211_CCK_RATE_2MB_MASK (1<<1) | ||
334 | #define IEEE80211_CCK_RATE_5MB_MASK (1<<2) | ||
335 | #define IEEE80211_CCK_RATE_11MB_MASK (1<<3) | ||
336 | #define IEEE80211_OFDM_RATE_6MB_MASK (1<<4) | ||
337 | #define IEEE80211_OFDM_RATE_9MB_MASK (1<<5) | ||
338 | #define IEEE80211_OFDM_RATE_12MB_MASK (1<<6) | ||
339 | #define IEEE80211_OFDM_RATE_18MB_MASK (1<<7) | ||
340 | #define IEEE80211_OFDM_RATE_24MB_MASK (1<<8) | ||
341 | #define IEEE80211_OFDM_RATE_36MB_MASK (1<<9) | ||
342 | #define IEEE80211_OFDM_RATE_48MB_MASK (1<<10) | ||
343 | #define IEEE80211_OFDM_RATE_54MB_MASK (1<<11) | ||
344 | |||
345 | #define IEEE80211_CCK_RATES_MASK 0x0000000F | ||
346 | #define IEEE80211_CCK_BASIC_RATES_MASK (IEEE80211_CCK_RATE_1MB_MASK | \ | ||
347 | IEEE80211_CCK_RATE_2MB_MASK) | ||
348 | #define IEEE80211_CCK_DEFAULT_RATES_MASK (IEEE80211_CCK_BASIC_RATES_MASK | \ | ||
349 | IEEE80211_CCK_RATE_5MB_MASK | \ | ||
350 | IEEE80211_CCK_RATE_11MB_MASK) | ||
351 | |||
352 | #define IEEE80211_OFDM_RATES_MASK 0x00000FF0 | ||
353 | #define IEEE80211_OFDM_BASIC_RATES_MASK (IEEE80211_OFDM_RATE_6MB_MASK | \ | ||
354 | IEEE80211_OFDM_RATE_12MB_MASK | \ | ||
355 | IEEE80211_OFDM_RATE_24MB_MASK) | ||
356 | #define IEEE80211_OFDM_DEFAULT_RATES_MASK (IEEE80211_OFDM_BASIC_RATES_MASK | \ | ||
357 | IEEE80211_OFDM_RATE_9MB_MASK | \ | ||
358 | IEEE80211_OFDM_RATE_18MB_MASK | \ | ||
359 | IEEE80211_OFDM_RATE_36MB_MASK | \ | ||
360 | IEEE80211_OFDM_RATE_48MB_MASK | \ | ||
361 | IEEE80211_OFDM_RATE_54MB_MASK) | ||
362 | #define IEEE80211_DEFAULT_RATES_MASK (IEEE80211_OFDM_DEFAULT_RATES_MASK | \ | ||
363 | IEEE80211_CCK_DEFAULT_RATES_MASK) | ||
364 | |||
365 | #define IEEE80211_NUM_OFDM_RATES 8 | ||
366 | #define IEEE80211_NUM_CCK_RATES 4 | ||
367 | #define IEEE80211_OFDM_SHIFT_MASK_A 4 | ||
368 | |||
369 | |||
370 | |||
371 | |||
372 | /* NOTE: This data is for statistical purposes; not all hardware provides this | ||
373 | * information for frames received. Not setting these will not cause | ||
374 | * any adverse affects. */ | ||
375 | struct ieee80211_rx_stats { | ||
376 | u32 mac_time; | ||
377 | s8 rssi; | ||
378 | u8 signal; | ||
379 | u8 noise; | ||
380 | u16 rate; /* in 100 kbps */ | ||
381 | u8 received_channel; | ||
382 | u8 control; | ||
383 | u8 mask; | ||
384 | u8 freq; | ||
385 | u16 len; | ||
386 | }; | ||
387 | |||
388 | /* IEEE 802.11 requires that STA supports concurrent reception of at least | ||
389 | * three fragmented frames. This define can be increased to support more | ||
390 | * concurrent frames, but it should be noted that each entry can consume about | ||
391 | * 2 kB of RAM and increasing cache size will slow down frame reassembly. */ | ||
392 | #define IEEE80211_FRAG_CACHE_LEN 4 | ||
393 | |||
394 | struct ieee80211_frag_entry { | ||
395 | unsigned long first_frag_time; | ||
396 | unsigned int seq; | ||
397 | unsigned int last_frag; | ||
398 | struct sk_buff *skb; | ||
399 | u8 src_addr[ETH_ALEN]; | ||
400 | u8 dst_addr[ETH_ALEN]; | ||
401 | }; | ||
402 | |||
403 | struct ieee80211_stats { | ||
404 | unsigned int tx_unicast_frames; | ||
405 | unsigned int tx_multicast_frames; | ||
406 | unsigned int tx_fragments; | ||
407 | unsigned int tx_unicast_octets; | ||
408 | unsigned int tx_multicast_octets; | ||
409 | unsigned int tx_deferred_transmissions; | ||
410 | unsigned int tx_single_retry_frames; | ||
411 | unsigned int tx_multiple_retry_frames; | ||
412 | unsigned int tx_retry_limit_exceeded; | ||
413 | unsigned int tx_discards; | ||
414 | unsigned int rx_unicast_frames; | ||
415 | unsigned int rx_multicast_frames; | ||
416 | unsigned int rx_fragments; | ||
417 | unsigned int rx_unicast_octets; | ||
418 | unsigned int rx_multicast_octets; | ||
419 | unsigned int rx_fcs_errors; | ||
420 | unsigned int rx_discards_no_buffer; | ||
421 | unsigned int tx_discards_wrong_sa; | ||
422 | unsigned int rx_discards_undecryptable; | ||
423 | unsigned int rx_message_in_msg_fragments; | ||
424 | unsigned int rx_message_in_bad_msg_fragments; | ||
425 | }; | ||
426 | |||
427 | struct ieee80211_device; | ||
428 | |||
429 | #if 0 /* for later */ | ||
430 | #include "ieee80211_crypt.h" | ||
431 | #endif | ||
432 | |||
433 | #define SEC_KEY_1 (1<<0) | ||
434 | #define SEC_KEY_2 (1<<1) | ||
435 | #define SEC_KEY_3 (1<<2) | ||
436 | #define SEC_KEY_4 (1<<3) | ||
437 | #define SEC_ACTIVE_KEY (1<<4) | ||
438 | #define SEC_AUTH_MODE (1<<5) | ||
439 | #define SEC_UNICAST_GROUP (1<<6) | ||
440 | #define SEC_LEVEL (1<<7) | ||
441 | #define SEC_ENABLED (1<<8) | ||
442 | |||
443 | #define SEC_LEVEL_0 0 /* None */ | ||
444 | #define SEC_LEVEL_1 1 /* WEP 40 and 104 bit */ | ||
445 | #define SEC_LEVEL_2 2 /* Level 1 + TKIP */ | ||
446 | #define SEC_LEVEL_2_CKIP 3 /* Level 1 + CKIP */ | ||
447 | #define SEC_LEVEL_3 4 /* Level 2 + CCMP */ | ||
448 | |||
449 | #define WEP_KEYS 4 | ||
450 | #define WEP_KEY_LEN 13 | ||
451 | |||
452 | struct ieee80211_security { | ||
453 | u16 active_key:2, | ||
454 | enabled:1, | ||
455 | auth_mode:2, | ||
456 | auth_algo:4, | ||
457 | unicast_uses_group:1; | ||
458 | u8 key_sizes[WEP_KEYS]; | ||
459 | u8 keys[WEP_KEYS][WEP_KEY_LEN]; | ||
460 | u8 level; | ||
461 | u16 flags; | ||
462 | } __attribute__ ((packed)); | ||
463 | |||
464 | |||
465 | /* | ||
466 | |||
467 | 802.11 data frame from AP | ||
468 | |||
469 | ,-------------------------------------------------------------------. | ||
470 | Bytes | 2 | 2 | 6 | 6 | 6 | 2 | 0..2312 | 4 | | ||
471 | |------|------|---------|---------|---------|------|---------|------| | ||
472 | Desc. | ctrl | dura | DA/RA | TA | SA | Sequ | frame | fcs | | ||
473 | | | tion | (BSSID) | | | ence | data | | | ||
474 | `-------------------------------------------------------------------' | ||
475 | |||
476 | Total: 28-2340 bytes | ||
477 | |||
478 | */ | ||
479 | |||
480 | #define BEACON_PROBE_SSID_ID_POSITION 12 | ||
481 | |||
482 | /* Management Frame Information Element Types */ | ||
483 | #define MFIE_TYPE_SSID 0 | ||
484 | #define MFIE_TYPE_RATES 1 | ||
485 | #define MFIE_TYPE_FH_SET 2 | ||
486 | #define MFIE_TYPE_DS_SET 3 | ||
487 | #define MFIE_TYPE_CF_SET 4 | ||
488 | #define MFIE_TYPE_TIM 5 | ||
489 | #define MFIE_TYPE_IBSS_SET 6 | ||
490 | #define MFIE_TYPE_CHALLENGE 16 | ||
491 | #define MFIE_TYPE_RSN 48 | ||
492 | #define MFIE_TYPE_RATES_EX 50 | ||
493 | #define MFIE_TYPE_GENERIC 221 | ||
494 | |||
495 | struct ieee80211_info_element_hdr { | ||
496 | u8 id; | ||
497 | u8 len; | ||
498 | } __attribute__ ((packed)); | ||
499 | |||
500 | struct ieee80211_info_element { | ||
501 | u8 id; | ||
502 | u8 len; | ||
503 | u8 data[0]; | ||
504 | } __attribute__ ((packed)); | ||
505 | |||
506 | /* | ||
507 | * These are the data types that can make up management packets | ||
508 | * | ||
509 | u16 auth_algorithm; | ||
510 | u16 auth_sequence; | ||
511 | u16 beacon_interval; | ||
512 | u16 capability; | ||
513 | u8 current_ap[ETH_ALEN]; | ||
514 | u16 listen_interval; | ||
515 | struct { | ||
516 | u16 association_id:14, reserved:2; | ||
517 | } __attribute__ ((packed)); | ||
518 | u32 time_stamp[2]; | ||
519 | u16 reason; | ||
520 | u16 status; | ||
521 | */ | ||
522 | |||
523 | struct ieee80211_authentication { | ||
524 | struct ieee80211_hdr_3addr header; | ||
525 | u16 algorithm; | ||
526 | u16 transaction; | ||
527 | u16 status; | ||
528 | struct ieee80211_info_element info_element; | ||
529 | } __attribute__ ((packed)); | ||
530 | |||
531 | |||
532 | struct ieee80211_probe_response { | ||
533 | struct ieee80211_hdr_3addr header; | ||
534 | u32 time_stamp[2]; | ||
535 | u16 beacon_interval; | ||
536 | u16 capability; | ||
537 | struct ieee80211_info_element info_element; | ||
538 | } __attribute__ ((packed)); | ||
539 | |||
540 | struct ieee80211_assoc_request_frame { | ||
541 | u16 capability; | ||
542 | u16 listen_interval; | ||
543 | u8 current_ap[ETH_ALEN]; | ||
544 | struct ieee80211_info_element info_element; | ||
545 | } __attribute__ ((packed)); | ||
546 | |||
547 | struct ieee80211_assoc_response_frame { | ||
548 | struct ieee80211_hdr_3addr header; | ||
549 | u16 capability; | ||
550 | u16 status; | ||
551 | u16 aid; | ||
552 | struct ieee80211_info_element info_element; /* supported rates */ | ||
553 | } __attribute__ ((packed)); | ||
554 | |||
555 | |||
556 | struct ieee80211_txb { | ||
557 | u8 nr_frags; | ||
558 | u8 encrypted; | ||
559 | u16 reserved; | ||
560 | u16 frag_size; | ||
561 | u16 payload_size; | ||
562 | struct sk_buff *fragments[0]; | ||
563 | }; | ||
564 | |||
565 | |||
566 | /* SWEEP TABLE ENTRIES NUMBER*/ | ||
567 | #define MAX_SWEEP_TAB_ENTRIES 42 | ||
568 | #define MAX_SWEEP_TAB_ENTRIES_PER_PACKET 7 | ||
569 | /* MAX_RATES_LENGTH needs to be 12. The spec says 8, and many APs | ||
570 | * only use 8, and then use extended rates for the remaining supported | ||
571 | * rates. Other APs, however, stick all of their supported rates on the | ||
572 | * main rates information element... */ | ||
573 | #define MAX_RATES_LENGTH ((u8)12) | ||
574 | #define MAX_RATES_EX_LENGTH ((u8)16) | ||
575 | #define MAX_NETWORK_COUNT 128 | ||
576 | |||
577 | #define CRC_LENGTH 4U | ||
578 | |||
579 | #define MAX_WPA_IE_LEN 64 | ||
580 | |||
581 | #define NETWORK_EMPTY_ESSID (1<<0) | ||
582 | #define NETWORK_HAS_OFDM (1<<1) | ||
583 | #define NETWORK_HAS_CCK (1<<2) | ||
584 | |||
585 | struct ieee80211_network { | ||
586 | /* These entries are used to identify a unique network */ | ||
587 | u8 bssid[ETH_ALEN]; | ||
588 | u8 channel; | ||
589 | /* Ensure null-terminated for any debug msgs */ | ||
590 | u8 ssid[IW_ESSID_MAX_SIZE + 1]; | ||
591 | u8 ssid_len; | ||
592 | |||
593 | /* These are network statistics */ | ||
594 | struct ieee80211_rx_stats stats; | ||
595 | u16 capability; | ||
596 | u8 rates[MAX_RATES_LENGTH]; | ||
597 | u8 rates_len; | ||
598 | u8 rates_ex[MAX_RATES_EX_LENGTH]; | ||
599 | u8 rates_ex_len; | ||
600 | unsigned long last_scanned; | ||
601 | u8 mode; | ||
602 | u8 flags; | ||
603 | u32 last_associate; | ||
604 | u32 time_stamp[2]; | ||
605 | u16 beacon_interval; | ||
606 | u16 listen_interval; | ||
607 | u16 atim_window; | ||
608 | u8 wpa_ie[MAX_WPA_IE_LEN]; | ||
609 | size_t wpa_ie_len; | ||
610 | u8 rsn_ie[MAX_WPA_IE_LEN]; | ||
611 | size_t rsn_ie_len; | ||
612 | struct list_head list; | ||
613 | }; | ||
614 | |||
615 | enum ieee80211_state { | ||
616 | IEEE80211_UNINITIALIZED = 0, | ||
617 | IEEE80211_INITIALIZED, | ||
618 | IEEE80211_ASSOCIATING, | ||
619 | IEEE80211_ASSOCIATED, | ||
620 | IEEE80211_AUTHENTICATING, | ||
621 | IEEE80211_AUTHENTICATED, | ||
622 | IEEE80211_SHUTDOWN | ||
623 | }; | ||
624 | |||
625 | #define DEFAULT_MAX_SCAN_AGE (15 * HZ) | ||
626 | #define DEFAULT_FTS 2346 | ||
627 | #define MAC_FMT "%02x:%02x:%02x:%02x:%02x:%02x" | ||
628 | #define MAC_ARG(x) ((u8*)(x))[0],((u8*)(x))[1],((u8*)(x))[2],((u8*)(x))[3],((u8*)(x))[4],((u8*)(x))[5] | ||
629 | |||
630 | |||
631 | #define CFG_IEEE80211_RESERVE_FCS (1<<0) | ||
632 | #define CFG_IEEE80211_COMPUTE_FCS (1<<1) | ||
633 | |||
634 | struct ieee80211_device { | ||
635 | struct net_device *dev; | ||
636 | |||
637 | /* Bookkeeping structures */ | ||
638 | struct net_device_stats stats; | ||
639 | struct ieee80211_stats ieee_stats; | ||
640 | |||
641 | /* Probe / Beacon management */ | ||
642 | struct list_head network_free_list; | ||
643 | struct list_head network_list; | ||
644 | struct ieee80211_network *networks; | ||
645 | int scans; | ||
646 | int scan_age; | ||
647 | |||
648 | int iw_mode; /* operating mode (IW_MODE_*) */ | ||
649 | |||
650 | spinlock_t lock; | ||
651 | |||
652 | int tx_headroom; /* Set to size of any additional room needed at front | ||
653 | * of allocated Tx SKBs */ | ||
654 | u32 config; | ||
655 | |||
656 | /* WEP and other encryption related settings at the device level */ | ||
657 | int open_wep; /* Set to 1 to allow unencrypted frames */ | ||
658 | |||
659 | int reset_on_keychange; /* Set to 1 if the HW needs to be reset on | ||
660 | * WEP key changes */ | ||
661 | |||
662 | /* If the host performs {en,de}cryption, then set to 1 */ | ||
663 | int host_encrypt; | ||
664 | int host_decrypt; | ||
665 | int ieee802_1x; /* is IEEE 802.1X used */ | ||
666 | |||
667 | /* WPA data */ | ||
668 | int wpa_enabled; | ||
669 | int drop_unencrypted; | ||
670 | int tkip_countermeasures; | ||
671 | int privacy_invoked; | ||
672 | size_t wpa_ie_len; | ||
673 | u8 *wpa_ie; | ||
674 | |||
675 | struct list_head crypt_deinit_list; | ||
676 | struct ieee80211_crypt_data *crypt[WEP_KEYS]; | ||
677 | int tx_keyidx; /* default TX key index (crypt[tx_keyidx]) */ | ||
678 | struct timer_list crypt_deinit_timer; | ||
679 | |||
680 | int bcrx_sta_key; /* use individual keys to override default keys even | ||
681 | * with RX of broad/multicast frames */ | ||
682 | |||
683 | /* Fragmentation structures */ | ||
684 | struct ieee80211_frag_entry frag_cache[IEEE80211_FRAG_CACHE_LEN]; | ||
685 | unsigned int frag_next_idx; | ||
686 | u16 fts; /* Fragmentation Threshold */ | ||
687 | |||
688 | /* Association info */ | ||
689 | u8 bssid[ETH_ALEN]; | ||
690 | |||
691 | enum ieee80211_state state; | ||
692 | |||
693 | int mode; /* A, B, G */ | ||
694 | int modulation; /* CCK, OFDM */ | ||
695 | int freq_band; /* 2.4Ghz, 5.2Ghz, Mixed */ | ||
696 | int abg_ture; /* ABG flag */ | ||
697 | |||
698 | /* Callback functions */ | ||
699 | void (*set_security)(struct net_device *dev, | ||
700 | struct ieee80211_security *sec); | ||
701 | int (*hard_start_xmit)(struct ieee80211_txb *txb, | ||
702 | struct net_device *dev); | ||
703 | int (*reset_port)(struct net_device *dev); | ||
704 | |||
705 | /* This must be the last item so that it points to the data | ||
706 | * allocated beyond this structure by alloc_ieee80211 */ | ||
707 | u8 priv[0]; | ||
708 | }; | ||
709 | |||
710 | #define IEEE_A (1<<0) | ||
711 | #define IEEE_B (1<<1) | ||
712 | #define IEEE_G (1<<2) | ||
713 | #define IEEE_MODE_MASK (IEEE_A|IEEE_B|IEEE_G) | ||
714 | |||
715 | extern inline void *ieee80211_priv(struct net_device *dev) | ||
716 | { | ||
717 | return ((struct ieee80211_device *)netdev_priv(dev))->priv; | ||
718 | } | ||
719 | |||
720 | extern inline int ieee80211_is_empty_essid(const char *essid, int essid_len) | ||
721 | { | ||
722 | /* Single white space is for Linksys APs */ | ||
723 | if (essid_len == 1 && essid[0] == ' ') | ||
724 | return 1; | ||
725 | |||
726 | /* Otherwise, if the entire essid is 0, we assume it is hidden */ | ||
727 | while (essid_len) { | ||
728 | essid_len--; | ||
729 | if (essid[essid_len] != '\0') | ||
730 | return 0; | ||
731 | } | ||
732 | |||
733 | return 1; | ||
734 | } | ||
735 | |||
736 | extern inline int ieee80211_is_valid_mode(struct ieee80211_device *ieee, int mode) | ||
737 | { | ||
738 | /* | ||
739 | * It is possible for both access points and our device to support | ||
740 | * combinations of modes, so as long as there is one valid combination | ||
741 | * of ap/device supported modes, then return success | ||
742 | * | ||
743 | */ | ||
744 | if ((mode & IEEE_A) && | ||
745 | (ieee->modulation & IEEE80211_OFDM_MODULATION) && | ||
746 | (ieee->freq_band & IEEE80211_52GHZ_BAND)) | ||
747 | return 1; | ||
748 | |||
749 | if ((mode & IEEE_G) && | ||
750 | (ieee->modulation & IEEE80211_OFDM_MODULATION) && | ||
751 | (ieee->freq_band & IEEE80211_24GHZ_BAND)) | ||
752 | return 1; | ||
753 | |||
754 | if ((mode & IEEE_B) && | ||
755 | (ieee->modulation & IEEE80211_CCK_MODULATION) && | ||
756 | (ieee->freq_band & IEEE80211_24GHZ_BAND)) | ||
757 | return 1; | ||
758 | |||
759 | return 0; | ||
760 | } | ||
761 | |||
762 | extern inline int ieee80211_get_hdrlen(u16 fc) | ||
763 | { | ||
764 | int hdrlen = IEEE80211_3ADDR_LEN; | ||
765 | |||
766 | switch (WLAN_FC_GET_TYPE(fc)) { | ||
767 | case IEEE80211_FTYPE_DATA: | ||
768 | if ((fc & IEEE80211_FCTL_FROMDS) && (fc & IEEE80211_FCTL_TODS)) | ||
769 | hdrlen = IEEE80211_4ADDR_LEN; | ||
770 | break; | ||
771 | case IEEE80211_FTYPE_CTL: | ||
772 | switch (WLAN_FC_GET_STYPE(fc)) { | ||
773 | case IEEE80211_STYPE_CTS: | ||
774 | case IEEE80211_STYPE_ACK: | ||
775 | hdrlen = IEEE80211_1ADDR_LEN; | ||
776 | break; | ||
777 | default: | ||
778 | hdrlen = IEEE80211_2ADDR_LEN; | ||
779 | break; | ||
780 | } | ||
781 | break; | ||
782 | } | ||
783 | |||
784 | return hdrlen; | ||
785 | } | ||
786 | |||
787 | |||
788 | |||
789 | /* ieee80211.c */ | ||
790 | extern void free_ieee80211(struct net_device *dev); | ||
791 | extern struct net_device *alloc_ieee80211(int sizeof_priv); | ||
792 | |||
793 | extern int ieee80211_set_encryption(struct ieee80211_device *ieee); | ||
794 | |||
795 | /* ieee80211_tx.c */ | ||
796 | |||
797 | |||
798 | extern int ieee80211_xmit(struct sk_buff *skb, | ||
799 | struct net_device *dev); | ||
800 | extern void ieee80211_txb_free(struct ieee80211_txb *); | ||
801 | |||
802 | |||
803 | /* ieee80211_rx.c */ | ||
804 | extern int ieee80211_rx(struct ieee80211_device *ieee, struct sk_buff *skb, | ||
805 | struct ieee80211_rx_stats *rx_stats); | ||
806 | extern void ieee80211_rx_mgt(struct ieee80211_device *ieee, | ||
807 | struct ieee80211_hdr *header, | ||
808 | struct ieee80211_rx_stats *stats); | ||
809 | |||
810 | /* iee80211_wx.c */ | ||
811 | extern int ieee80211_wx_get_scan(struct ieee80211_device *ieee, | ||
812 | struct iw_request_info *info, | ||
813 | union iwreq_data *wrqu, char *key); | ||
814 | extern int ieee80211_wx_set_encode(struct ieee80211_device *ieee, | ||
815 | struct iw_request_info *info, | ||
816 | union iwreq_data *wrqu, char *key); | ||
817 | extern int ieee80211_wx_get_encode(struct ieee80211_device *ieee, | ||
818 | struct iw_request_info *info, | ||
819 | union iwreq_data *wrqu, char *key); | ||
820 | |||
821 | |||
822 | extern inline void ieee80211_increment_scans(struct ieee80211_device *ieee) | ||
823 | { | ||
824 | ieee->scans++; | ||
825 | } | ||
826 | |||
827 | extern inline int ieee80211_get_scans(struct ieee80211_device *ieee) | ||
828 | { | ||
829 | return ieee->scans; | ||
830 | } | ||
831 | |||
832 | static inline const char *escape_essid(const char *essid, u8 essid_len) { | ||
833 | static char escaped[IW_ESSID_MAX_SIZE * 2 + 1]; | ||
834 | const char *s = essid; | ||
835 | char *d = escaped; | ||
836 | |||
837 | if (ieee80211_is_empty_essid(essid, essid_len)) { | ||
838 | memcpy(escaped, "<hidden>", sizeof("<hidden>")); | ||
839 | return escaped; | ||
840 | } | ||
841 | |||
842 | essid_len = min(essid_len, (u8)IW_ESSID_MAX_SIZE); | ||
843 | while (essid_len--) { | ||
844 | if (*s == '\0') { | ||
845 | *d++ = '\\'; | ||
846 | *d++ = '0'; | ||
847 | s++; | ||
848 | } else { | ||
849 | *d++ = *s++; | ||
850 | } | ||
851 | } | ||
852 | *d = '\0'; | ||
853 | return escaped; | ||
854 | } | ||
855 | |||
856 | #endif /* IEEE80211_H */ | ||
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 | |||
183 | struct ipv6_opt_hdr *hopopt; | 183 | struct ipv6_opt_hdr *hopopt; |
184 | struct ipv6_opt_hdr *dst0opt; | 184 | struct ipv6_opt_hdr *dst0opt; |
185 | struct ipv6_rt_hdr *srcrt; /* Routing Header */ | 185 | struct ipv6_rt_hdr *srcrt; /* Routing Header */ |
186 | struct ipv6_opt_hdr *auth; | ||
187 | struct ipv6_opt_hdr *dst1opt; | 186 | struct ipv6_opt_hdr *dst1opt; |
188 | 187 | ||
189 | /* Option buffer, as read by IPV6_PKTOPTIONS, starts here. */ | 188 | /* Option buffer, as read by IPV6_PKTOPTIONS, starts here. */ |
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 | |||
13 | 13 | ||
14 | extern rwlock_t qdisc_tree_lock; | 14 | extern rwlock_t qdisc_tree_lock; |
15 | 15 | ||
16 | #define QDISC_ALIGN 32 | 16 | #define QDISC_ALIGNTO 32 |
17 | #define QDISC_ALIGN_CONST (QDISC_ALIGN - 1) | 17 | #define QDISC_ALIGN(len) (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1)) |
18 | 18 | ||
19 | static inline void *qdisc_priv(struct Qdisc *q) | 19 | static inline void *qdisc_priv(struct Qdisc *q) |
20 | { | 20 | { |
21 | return (char *)q + ((sizeof(struct Qdisc) + QDISC_ALIGN_CONST) | 21 | return (char *) q + QDISC_ALIGN(sizeof(struct Qdisc)); |
22 | & ~QDISC_ALIGN_CONST); | ||
23 | } | 22 | } |
24 | 23 | ||
25 | /* | 24 | /* |
@@ -207,8 +206,6 @@ psched_tod_diff(int delta_sec, int bound) | |||
207 | 206 | ||
208 | #endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */ | 207 | #endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */ |
209 | 208 | ||
210 | extern struct Qdisc noop_qdisc; | ||
211 | extern struct Qdisc_ops noop_qdisc_ops; | ||
212 | extern struct Qdisc_ops pfifo_qdisc_ops; | 209 | extern struct Qdisc_ops pfifo_qdisc_ops; |
213 | extern struct Qdisc_ops bfifo_qdisc_ops; | 210 | extern struct Qdisc_ops bfifo_qdisc_ops; |
214 | 211 | ||
@@ -216,14 +213,6 @@ extern int register_qdisc(struct Qdisc_ops *qops); | |||
216 | extern int unregister_qdisc(struct Qdisc_ops *qops); | 213 | extern int unregister_qdisc(struct Qdisc_ops *qops); |
217 | extern struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle); | 214 | extern struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle); |
218 | extern struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle); | 215 | extern struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle); |
219 | extern void dev_init_scheduler(struct net_device *dev); | ||
220 | extern void dev_shutdown(struct net_device *dev); | ||
221 | extern void dev_activate(struct net_device *dev); | ||
222 | extern void dev_deactivate(struct net_device *dev); | ||
223 | extern void qdisc_reset(struct Qdisc *qdisc); | ||
224 | extern void qdisc_destroy(struct Qdisc *qdisc); | ||
225 | extern struct Qdisc * qdisc_create_dflt(struct net_device *dev, | ||
226 | struct Qdisc_ops *ops); | ||
227 | extern struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, | 216 | extern struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, |
228 | struct rtattr *tab); | 217 | struct rtattr *tab); |
229 | extern void qdisc_put_rtab(struct qdisc_rate_table *tab); | 218 | extern void qdisc_put_rtab(struct qdisc_rate_table *tab); |
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h index 7b97405e2dbf..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); | |||
164 | #define tcf_tree_lock(tp) qdisc_lock_tree((tp)->q->dev) | 164 | #define tcf_tree_lock(tp) qdisc_lock_tree((tp)->q->dev) |
165 | #define tcf_tree_unlock(tp) qdisc_unlock_tree((tp)->q->dev) | 165 | #define tcf_tree_unlock(tp) qdisc_unlock_tree((tp)->q->dev) |
166 | 166 | ||
167 | extern struct Qdisc noop_qdisc; | ||
168 | extern struct Qdisc_ops noop_qdisc_ops; | ||
169 | |||
170 | extern void dev_init_scheduler(struct net_device *dev); | ||
171 | extern void dev_shutdown(struct net_device *dev); | ||
172 | extern void dev_activate(struct net_device *dev); | ||
173 | extern void dev_deactivate(struct net_device *dev); | ||
174 | extern void qdisc_reset(struct Qdisc *qdisc); | ||
175 | extern void qdisc_destroy(struct Qdisc *qdisc); | ||
176 | extern struct Qdisc *qdisc_alloc(struct net_device *dev, struct Qdisc_ops *ops); | ||
177 | extern struct Qdisc *qdisc_create_dflt(struct net_device *dev, | ||
178 | struct Qdisc_ops *ops); | ||
179 | |||
167 | static inline void | 180 | static inline void |
168 | tcf_destroy(struct tcf_proto *tp) | 181 | tcf_destroy(struct tcf_proto *tp) |
169 | { | 182 | { |
diff --git a/include/net/sctp/constants.h b/include/net/sctp/constants.h index 4868c7f7749d..5999e5684bbf 100644 --- a/include/net/sctp/constants.h +++ b/include/net/sctp/constants.h | |||
@@ -263,23 +263,11 @@ enum { SCTP_MIN_PMTU = 576 }; | |||
263 | enum { SCTP_MAX_DUP_TSNS = 16 }; | 263 | enum { SCTP_MAX_DUP_TSNS = 16 }; |
264 | enum { SCTP_MAX_GABS = 16 }; | 264 | enum { SCTP_MAX_GABS = 16 }; |
265 | 265 | ||
266 | /* Here we define the default timers. */ | 266 | /* Heartbeat interval - 30 secs */ |
267 | #define SCTP_DEFAULT_TIMEOUT_HEARTBEAT (30 * HZ) | ||
267 | 268 | ||
268 | /* cookie timer def = ? seconds */ | 269 | /* Delayed sack timer - 200ms */ |
269 | #define SCTP_DEFAULT_TIMEOUT_T1_COOKIE (3 * HZ) | ||
270 | |||
271 | /* init timer def = 3 seconds */ | ||
272 | #define SCTP_DEFAULT_TIMEOUT_T1_INIT (3 * HZ) | ||
273 | |||
274 | /* shutdown timer def = 300 ms */ | ||
275 | #define SCTP_DEFAULT_TIMEOUT_T2_SHUTDOWN ((300 * HZ) / 1000) | ||
276 | |||
277 | /* 0 seconds + RTO */ | ||
278 | #define SCTP_DEFAULT_TIMEOUT_HEARTBEAT (10 * HZ) | ||
279 | |||
280 | /* recv timer def = 200ms (in usec) */ | ||
281 | #define SCTP_DEFAULT_TIMEOUT_SACK ((200 * HZ) / 1000) | 270 | #define SCTP_DEFAULT_TIMEOUT_SACK ((200 * HZ) / 1000) |
282 | #define SCTP_DEFAULT_TIMEOUT_SACK_MAX ((500 * HZ) / 1000) /* 500 ms */ | ||
283 | 271 | ||
284 | /* RTO.Initial - 3 seconds | 272 | /* RTO.Initial - 3 seconds |
285 | * RTO.Min - 1 second | 273 | * RTO.Min - 1 second |
diff --git a/include/net/sctp/structs.h b/include/net/sctp/structs.h index dfad4d3c581c..47727c7cc628 100644 --- a/include/net/sctp/structs.h +++ b/include/net/sctp/structs.h | |||
@@ -161,6 +161,9 @@ extern struct sctp_globals { | |||
161 | */ | 161 | */ |
162 | int sndbuf_policy; | 162 | int sndbuf_policy; |
163 | 163 | ||
164 | /* Delayed SACK timeout 200ms default*/ | ||
165 | int sack_timeout; | ||
166 | |||
164 | /* HB.interval - 30 seconds */ | 167 | /* HB.interval - 30 seconds */ |
165 | int hb_interval; | 168 | int hb_interval; |
166 | 169 | ||
@@ -217,6 +220,7 @@ extern struct sctp_globals { | |||
217 | #define sctp_sndbuf_policy (sctp_globals.sndbuf_policy) | 220 | #define sctp_sndbuf_policy (sctp_globals.sndbuf_policy) |
218 | #define sctp_max_retrans_path (sctp_globals.max_retrans_path) | 221 | #define sctp_max_retrans_path (sctp_globals.max_retrans_path) |
219 | #define sctp_max_retrans_init (sctp_globals.max_retrans_init) | 222 | #define sctp_max_retrans_init (sctp_globals.max_retrans_init) |
223 | #define sctp_sack_timeout (sctp_globals.sack_timeout) | ||
220 | #define sctp_hb_interval (sctp_globals.hb_interval) | 224 | #define sctp_hb_interval (sctp_globals.hb_interval) |
221 | #define sctp_max_instreams (sctp_globals.max_instreams) | 225 | #define sctp_max_instreams (sctp_globals.max_instreams) |
222 | #define sctp_max_outstreams (sctp_globals.max_outstreams) | 226 | #define sctp_max_outstreams (sctp_globals.max_outstreams) |
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 { | |||
170 | }; | 170 | }; |
171 | #define NULLSLCOMPR (struct slcompress *)0 | 171 | #define NULLSLCOMPR (struct slcompress *)0 |
172 | 172 | ||
173 | #define __ARGS(x) x | ||
174 | |||
175 | /* In slhc.c: */ | 173 | /* In slhc.c: */ |
176 | struct slcompress *slhc_init __ARGS((int rslots, int tslots)); | 174 | struct slcompress *slhc_init(int rslots, int tslots); |
177 | void slhc_free __ARGS((struct slcompress *comp)); | 175 | void slhc_free(struct slcompress *comp); |
178 | 176 | ||
179 | int slhc_compress __ARGS((struct slcompress *comp, unsigned char *icp, | 177 | int slhc_compress(struct slcompress *comp, unsigned char *icp, int isize, |
180 | int isize, unsigned char *ocp, unsigned char **cpp, | 178 | unsigned char *ocp, unsigned char **cpp, int compress_cid); |
181 | int compress_cid)); | 179 | int slhc_uncompress(struct slcompress *comp, unsigned char *icp, int isize); |
182 | int slhc_uncompress __ARGS((struct slcompress *comp, unsigned char *icp, | 180 | int slhc_remember(struct slcompress *comp, unsigned char *icp, int isize); |
183 | int isize)); | 181 | int slhc_toss(struct slcompress *comp); |
184 | int slhc_remember __ARGS((struct slcompress *comp, unsigned char *icp, | ||
185 | int isize)); | ||
186 | int slhc_toss __ARGS((struct slcompress *comp)); | ||
187 | 182 | ||
188 | #endif /* _SLHC_H */ | 183 | #endif /* _SLHC_H */ |
diff --git a/include/net/sock.h b/include/net/sock.h index e593af5b1ecc..7b76f891ae2d 100644 --- a/include/net/sock.h +++ b/include/net/sock.h | |||
@@ -1134,13 +1134,16 @@ static inline void sk_stream_moderate_sndbuf(struct sock *sk) | |||
1134 | static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk, | 1134 | static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk, |
1135 | int size, int mem, int gfp) | 1135 | int size, int mem, int gfp) |
1136 | { | 1136 | { |
1137 | struct sk_buff *skb = alloc_skb(size + sk->sk_prot->max_header, gfp); | 1137 | struct sk_buff *skb; |
1138 | int hdr_len; | ||
1138 | 1139 | ||
1140 | hdr_len = SKB_DATA_ALIGN(sk->sk_prot->max_header); | ||
1141 | skb = alloc_skb(size + hdr_len, gfp); | ||
1139 | if (skb) { | 1142 | if (skb) { |
1140 | skb->truesize += mem; | 1143 | skb->truesize += mem; |
1141 | if (sk->sk_forward_alloc >= (int)skb->truesize || | 1144 | if (sk->sk_forward_alloc >= (int)skb->truesize || |
1142 | sk_stream_mem_schedule(sk, skb->truesize, 0)) { | 1145 | sk_stream_mem_schedule(sk, skb->truesize, 0)) { |
1143 | skb_reserve(skb, sk->sk_prot->max_header); | 1146 | skb_reserve(skb, hdr_len); |
1144 | return skb; | 1147 | return skb; |
1145 | } | 1148 | } |
1146 | __kfree_skb(skb); | 1149 | __kfree_skb(skb); |
diff --git a/include/net/tcp.h b/include/net/tcp.h index ec9e20c27179..a166918ca56d 100644 --- a/include/net/tcp.h +++ b/include/net/tcp.h | |||
@@ -721,11 +721,16 @@ static inline int tcp_ack_scheduled(struct tcp_sock *tp) | |||
721 | return tp->ack.pending&TCP_ACK_SCHED; | 721 | return tp->ack.pending&TCP_ACK_SCHED; |
722 | } | 722 | } |
723 | 723 | ||
724 | static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp) | 724 | static __inline__ void tcp_dec_quickack_mode(struct tcp_sock *tp, unsigned int pkts) |
725 | { | 725 | { |
726 | if (tp->ack.quick && --tp->ack.quick == 0) { | 726 | if (tp->ack.quick) { |
727 | /* Leaving quickack mode we deflate ATO. */ | 727 | if (pkts >= tp->ack.quick) { |
728 | tp->ack.ato = TCP_ATO_MIN; | 728 | tp->ack.quick = 0; |
729 | |||
730 | /* Leaving quickack mode we deflate ATO. */ | ||
731 | tp->ack.ato = TCP_ATO_MIN; | ||
732 | } else | ||
733 | tp->ack.quick -= pkts; | ||
729 | } | 734 | } |
730 | } | 735 | } |
731 | 736 | ||
@@ -843,7 +848,9 @@ extern __u32 cookie_v4_init_sequence(struct sock *sk, struct sk_buff *skb, | |||
843 | 848 | ||
844 | /* tcp_output.c */ | 849 | /* tcp_output.c */ |
845 | 850 | ||
846 | extern int tcp_write_xmit(struct sock *, int nonagle); | 851 | extern void __tcp_push_pending_frames(struct sock *sk, struct tcp_sock *tp, |
852 | unsigned int cur_mss, int nonagle); | ||
853 | extern int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp); | ||
847 | extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); | 854 | extern int tcp_retransmit_skb(struct sock *, struct sk_buff *); |
848 | extern void tcp_xmit_retransmit_queue(struct sock *); | 855 | extern void tcp_xmit_retransmit_queue(struct sock *); |
849 | extern void tcp_simple_retransmit(struct sock *); | 856 | extern void tcp_simple_retransmit(struct sock *); |
@@ -855,10 +862,13 @@ extern int tcp_write_wakeup(struct sock *); | |||
855 | extern void tcp_send_fin(struct sock *sk); | 862 | extern void tcp_send_fin(struct sock *sk); |
856 | extern void tcp_send_active_reset(struct sock *sk, int priority); | 863 | extern void tcp_send_active_reset(struct sock *sk, int priority); |
857 | extern int tcp_send_synack(struct sock *); | 864 | extern int tcp_send_synack(struct sock *); |
858 | extern void tcp_push_one(struct sock *, unsigned mss_now); | 865 | extern void tcp_push_one(struct sock *, unsigned int mss_now); |
859 | extern void tcp_send_ack(struct sock *sk); | 866 | extern void tcp_send_ack(struct sock *sk); |
860 | extern void tcp_send_delayed_ack(struct sock *sk); | 867 | extern void tcp_send_delayed_ack(struct sock *sk); |
861 | 868 | ||
869 | /* tcp_input.c */ | ||
870 | extern void tcp_cwnd_application_limited(struct sock *sk); | ||
871 | |||
862 | /* tcp_timer.c */ | 872 | /* tcp_timer.c */ |
863 | extern void tcp_init_xmit_timers(struct sock *); | 873 | extern void tcp_init_xmit_timers(struct sock *); |
864 | extern void tcp_clear_xmit_timers(struct sock *); | 874 | extern void tcp_clear_xmit_timers(struct sock *); |
@@ -958,7 +968,7 @@ static inline void tcp_reset_xmit_timer(struct sock *sk, int what, unsigned long | |||
958 | static inline void tcp_initialize_rcv_mss(struct sock *sk) | 968 | static inline void tcp_initialize_rcv_mss(struct sock *sk) |
959 | { | 969 | { |
960 | struct tcp_sock *tp = tcp_sk(sk); | 970 | struct tcp_sock *tp = tcp_sk(sk); |
961 | unsigned int hint = min(tp->advmss, tp->mss_cache_std); | 971 | unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache); |
962 | 972 | ||
963 | hint = min(hint, tp->rcv_wnd/2); | 973 | hint = min(hint, tp->rcv_wnd/2); |
964 | hint = min(hint, TCP_MIN_RCVMSS); | 974 | hint = min(hint, TCP_MIN_RCVMSS); |
@@ -1225,28 +1235,6 @@ static inline void tcp_sync_left_out(struct tcp_sock *tp) | |||
1225 | tp->left_out = tp->sacked_out + tp->lost_out; | 1235 | tp->left_out = tp->sacked_out + tp->lost_out; |
1226 | } | 1236 | } |
1227 | 1237 | ||
1228 | extern void tcp_cwnd_application_limited(struct sock *sk); | ||
1229 | |||
1230 | /* Congestion window validation. (RFC2861) */ | ||
1231 | |||
1232 | static inline void tcp_cwnd_validate(struct sock *sk, struct tcp_sock *tp) | ||
1233 | { | ||
1234 | __u32 packets_out = tp->packets_out; | ||
1235 | |||
1236 | if (packets_out >= tp->snd_cwnd) { | ||
1237 | /* Network is feed fully. */ | ||
1238 | tp->snd_cwnd_used = 0; | ||
1239 | tp->snd_cwnd_stamp = tcp_time_stamp; | ||
1240 | } else { | ||
1241 | /* Network starves. */ | ||
1242 | if (tp->packets_out > tp->snd_cwnd_used) | ||
1243 | tp->snd_cwnd_used = tp->packets_out; | ||
1244 | |||
1245 | if ((s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >= tp->rto) | ||
1246 | tcp_cwnd_application_limited(sk); | ||
1247 | } | ||
1248 | } | ||
1249 | |||
1250 | /* Set slow start threshould and cwnd not falling to slow start */ | 1238 | /* Set slow start threshould and cwnd not falling to slow start */ |
1251 | static inline void __tcp_enter_cwr(struct tcp_sock *tp) | 1239 | static inline void __tcp_enter_cwr(struct tcp_sock *tp) |
1252 | { | 1240 | { |
@@ -1279,12 +1267,6 @@ static __inline__ __u32 tcp_max_burst(const struct tcp_sock *tp) | |||
1279 | return 3; | 1267 | return 3; |
1280 | } | 1268 | } |
1281 | 1269 | ||
1282 | static __inline__ int tcp_minshall_check(const struct tcp_sock *tp) | ||
1283 | { | ||
1284 | return after(tp->snd_sml,tp->snd_una) && | ||
1285 | !after(tp->snd_sml, tp->snd_nxt); | ||
1286 | } | ||
1287 | |||
1288 | static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, | 1270 | static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, |
1289 | const struct sk_buff *skb) | 1271 | const struct sk_buff *skb) |
1290 | { | 1272 | { |
@@ -1292,122 +1274,18 @@ static __inline__ void tcp_minshall_update(struct tcp_sock *tp, int mss, | |||
1292 | tp->snd_sml = TCP_SKB_CB(skb)->end_seq; | 1274 | tp->snd_sml = TCP_SKB_CB(skb)->end_seq; |
1293 | } | 1275 | } |
1294 | 1276 | ||
1295 | /* Return 0, if packet can be sent now without violation Nagle's rules: | ||
1296 | 1. It is full sized. | ||
1297 | 2. Or it contains FIN. | ||
1298 | 3. Or TCP_NODELAY was set. | ||
1299 | 4. Or TCP_CORK is not set, and all sent packets are ACKed. | ||
1300 | With Minshall's modification: all sent small packets are ACKed. | ||
1301 | */ | ||
1302 | |||
1303 | static __inline__ int | ||
1304 | tcp_nagle_check(const struct tcp_sock *tp, const struct sk_buff *skb, | ||
1305 | unsigned mss_now, int nonagle) | ||
1306 | { | ||
1307 | return (skb->len < mss_now && | ||
1308 | !(TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN) && | ||
1309 | ((nonagle&TCP_NAGLE_CORK) || | ||
1310 | (!nonagle && | ||
1311 | tp->packets_out && | ||
1312 | tcp_minshall_check(tp)))); | ||
1313 | } | ||
1314 | |||
1315 | extern void tcp_set_skb_tso_segs(struct sock *, struct sk_buff *); | ||
1316 | |||
1317 | /* This checks if the data bearing packet SKB (usually sk->sk_send_head) | ||
1318 | * should be put on the wire right now. | ||
1319 | */ | ||
1320 | static __inline__ int tcp_snd_test(struct sock *sk, | ||
1321 | struct sk_buff *skb, | ||
1322 | unsigned cur_mss, int nonagle) | ||
1323 | { | ||
1324 | struct tcp_sock *tp = tcp_sk(sk); | ||
1325 | int pkts = tcp_skb_pcount(skb); | ||
1326 | |||
1327 | if (!pkts) { | ||
1328 | tcp_set_skb_tso_segs(sk, skb); | ||
1329 | pkts = tcp_skb_pcount(skb); | ||
1330 | } | ||
1331 | |||
1332 | /* RFC 1122 - section 4.2.3.4 | ||
1333 | * | ||
1334 | * We must queue if | ||
1335 | * | ||
1336 | * a) The right edge of this frame exceeds the window | ||
1337 | * b) There are packets in flight and we have a small segment | ||
1338 | * [SWS avoidance and Nagle algorithm] | ||
1339 | * (part of SWS is done on packetization) | ||
1340 | * Minshall version sounds: there are no _small_ | ||
1341 | * segments in flight. (tcp_nagle_check) | ||
1342 | * c) We have too many packets 'in flight' | ||
1343 | * | ||
1344 | * Don't use the nagle rule for urgent data (or | ||
1345 | * for the final FIN -DaveM). | ||
1346 | * | ||
1347 | * Also, Nagle rule does not apply to frames, which | ||
1348 | * sit in the middle of queue (they have no chances | ||
1349 | * to get new data) and if room at tail of skb is | ||
1350 | * not enough to save something seriously (<32 for now). | ||
1351 | */ | ||
1352 | |||
1353 | /* Don't be strict about the congestion window for the | ||
1354 | * final FIN frame. -DaveM | ||
1355 | */ | ||
1356 | return (((nonagle&TCP_NAGLE_PUSH) || tp->urg_mode | ||
1357 | || !tcp_nagle_check(tp, skb, cur_mss, nonagle)) && | ||
1358 | (((tcp_packets_in_flight(tp) + (pkts-1)) < tp->snd_cwnd) || | ||
1359 | (TCP_SKB_CB(skb)->flags & TCPCB_FLAG_FIN)) && | ||
1360 | !after(TCP_SKB_CB(skb)->end_seq, tp->snd_una + tp->snd_wnd)); | ||
1361 | } | ||
1362 | |||
1363 | static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp) | 1277 | static __inline__ void tcp_check_probe_timer(struct sock *sk, struct tcp_sock *tp) |
1364 | { | 1278 | { |
1365 | if (!tp->packets_out && !tp->pending) | 1279 | if (!tp->packets_out && !tp->pending) |
1366 | tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, tp->rto); | 1280 | tcp_reset_xmit_timer(sk, TCP_TIME_PROBE0, tp->rto); |
1367 | } | 1281 | } |
1368 | 1282 | ||
1369 | static __inline__ int tcp_skb_is_last(const struct sock *sk, | ||
1370 | const struct sk_buff *skb) | ||
1371 | { | ||
1372 | return skb->next == (struct sk_buff *)&sk->sk_write_queue; | ||
1373 | } | ||
1374 | |||
1375 | /* Push out any pending frames which were held back due to | ||
1376 | * TCP_CORK or attempt at coalescing tiny packets. | ||
1377 | * The socket must be locked by the caller. | ||
1378 | */ | ||
1379 | static __inline__ void __tcp_push_pending_frames(struct sock *sk, | ||
1380 | struct tcp_sock *tp, | ||
1381 | unsigned cur_mss, | ||
1382 | int nonagle) | ||
1383 | { | ||
1384 | struct sk_buff *skb = sk->sk_send_head; | ||
1385 | |||
1386 | if (skb) { | ||
1387 | if (!tcp_skb_is_last(sk, skb)) | ||
1388 | nonagle = TCP_NAGLE_PUSH; | ||
1389 | if (!tcp_snd_test(sk, skb, cur_mss, nonagle) || | ||
1390 | tcp_write_xmit(sk, nonagle)) | ||
1391 | tcp_check_probe_timer(sk, tp); | ||
1392 | } | ||
1393 | tcp_cwnd_validate(sk, tp); | ||
1394 | } | ||
1395 | |||
1396 | static __inline__ void tcp_push_pending_frames(struct sock *sk, | 1283 | static __inline__ void tcp_push_pending_frames(struct sock *sk, |
1397 | struct tcp_sock *tp) | 1284 | struct tcp_sock *tp) |
1398 | { | 1285 | { |
1399 | __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle); | 1286 | __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 1), tp->nonagle); |
1400 | } | 1287 | } |
1401 | 1288 | ||
1402 | static __inline__ int tcp_may_send_now(struct sock *sk, struct tcp_sock *tp) | ||
1403 | { | ||
1404 | struct sk_buff *skb = sk->sk_send_head; | ||
1405 | |||
1406 | return (skb && | ||
1407 | tcp_snd_test(sk, skb, tcp_current_mss(sk, 1), | ||
1408 | tcp_skb_is_last(sk, skb) ? TCP_NAGLE_PUSH : tp->nonagle)); | ||
1409 | } | ||
1410 | |||
1411 | static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq) | 1289 | static __inline__ void tcp_init_wl(struct tcp_sock *tp, u32 ack, u32 seq) |
1412 | { | 1290 | { |
1413 | tp->snd_wl1 = seq; | 1291 | tp->snd_wl1 = seq; |