1 /** @file 2 Routines to process TCP option. 3 4 Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR> 5 6 This program and the accompanying materials 7 are licensed and made available under the terms and conditions of the BSD License 8 which accompanies this distribution. The full text of the license may be found at 9 http://opensource.org/licenses/bsd-license.php. 10 11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 13 14 **/ 15 16 #include "TcpMain.h" 17 18 /** 19 Get a UINT16 value from buffer. 20 21 @param[in] Buf Pointer to input buffer. 22 23 @return The UINT16 value obtained from the buffer. 24 25 **/ 26 UINT16 27 TcpGetUint16 ( 28 IN UINT8 *Buf 29 ) 30 { 31 UINT16 Value; 32 CopyMem (&Value, Buf, sizeof (UINT16)); 33 return NTOHS (Value); 34 } 35 36 /** 37 Get a UINT32 value from buffer. 38 39 @param[in] Buf Pointer to input buffer. 40 41 @return The UINT32 value obtained from the buffer. 42 43 **/ 44 UINT32 45 TcpGetUint32 ( 46 IN UINT8 *Buf 47 ) 48 { 49 UINT32 Value; 50 CopyMem (&Value, Buf, sizeof (UINT32)); 51 return NTOHL (Value); 52 } 53 54 /** 55 Put a UINT32 value in buffer. 56 57 @param[out] Buf Pointer to the buffer. 58 @param[in] Data The UINT32 Date to put in the buffer. 59 60 **/ 61 VOID 62 TcpPutUint32 ( 63 OUT UINT8 *Buf, 64 IN UINT32 Data 65 ) 66 { 67 Data = HTONL (Data); 68 CopyMem (Buf, &Data, sizeof (UINT32)); 69 } 70 71 /** 72 Compute the window scale value according to the given buffer size. 73 74 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 75 76 @return The scale value. 77 78 **/ 79 UINT8 80 TcpComputeScale ( 81 IN TCP_CB *Tcb 82 ) 83 { 84 UINT8 Scale; 85 UINT32 BufSize; 86 87 ASSERT ((Tcb != NULL) && (Tcb->Sk != NULL)); 88 89 BufSize = GET_RCV_BUFFSIZE (Tcb->Sk); 90 91 Scale = 0; 92 while ((Scale < TCP_OPTION_MAX_WS) && ((UINT32) (TCP_OPTION_MAX_WIN << Scale) < BufSize)) { 93 94 Scale++; 95 } 96 97 return Scale; 98 } 99 100 /** 101 Build the TCP option in three-way handshake. 102 103 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 104 @param[in] Nbuf Pointer to the buffer to store the options. 105 106 @return The total length of the TCP option field. 107 108 **/ 109 UINT16 110 TcpSynBuildOption ( 111 IN TCP_CB *Tcb, 112 IN NET_BUF *Nbuf 113 ) 114 { 115 UINT8 *Data; 116 UINT16 Len; 117 118 ASSERT ((Tcb != NULL) && (Nbuf != NULL) && (Nbuf->Tcp == NULL)); 119 120 Len = 0; 121 122 // 123 // Add a timestamp option if not disabled by the application 124 // and it is the first SYN segment, or the peer has sent 125 // us its timestamp. 126 // 127 if (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS) && 128 (!TCP_FLG_ON (TCPSEG_NETBUF (Nbuf)->Flag, TCP_FLG_ACK) || 129 TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RCVD_TS)) 130 ) { 131 132 Data = NetbufAllocSpace ( 133 Nbuf, 134 TCP_OPTION_TS_ALIGNED_LEN, 135 NET_BUF_HEAD 136 ); 137 138 ASSERT (Data != NULL); 139 Len += TCP_OPTION_TS_ALIGNED_LEN; 140 141 TcpPutUint32 (Data, TCP_OPTION_TS_FAST); 142 TcpPutUint32 (Data + 4, mTcpTick); 143 TcpPutUint32 (Data + 8, 0); 144 } 145 146 // 147 // Build window scale option, only when configured 148 // to send WS option, and either we are doing active 149 // open or we have received WS option from peer. 150 // 151 if (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS) && 152 (!TCP_FLG_ON (TCPSEG_NETBUF (Nbuf)->Flag, TCP_FLG_ACK) || 153 TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_RCVD_WS)) 154 ) { 155 156 Data = NetbufAllocSpace ( 157 Nbuf, 158 TCP_OPTION_WS_ALIGNED_LEN, 159 NET_BUF_HEAD 160 ); 161 162 ASSERT (Data != NULL); 163 164 Len += TCP_OPTION_WS_ALIGNED_LEN; 165 TcpPutUint32 (Data, TCP_OPTION_WS_FAST | TcpComputeScale (Tcb)); 166 } 167 168 // 169 // Build the MSS option. 170 // 171 Data = NetbufAllocSpace (Nbuf, TCP_OPTION_MSS_LEN, 1); 172 ASSERT (Data != NULL); 173 174 Len += TCP_OPTION_MSS_LEN; 175 TcpPutUint32 (Data, TCP_OPTION_MSS_FAST | Tcb->RcvMss); 176 177 return Len; 178 } 179 180 /** 181 Build the TCP option in synchronized states. 182 183 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 184 @param[in] Nbuf Pointer to the buffer to store the options. 185 186 @return The total length of the TCP option field. 187 188 **/ 189 UINT16 190 TcpBuildOption ( 191 IN TCP_CB *Tcb, 192 IN NET_BUF *Nbuf 193 ) 194 { 195 UINT8 *Data; 196 UINT16 Len; 197 198 ASSERT ((Tcb != NULL) && (Nbuf != NULL) && (Nbuf->Tcp == NULL)); 199 Len = 0; 200 201 // 202 // Build the Timestamp option. 203 // 204 if (TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_SND_TS) && 205 !TCP_FLG_ON (TCPSEG_NETBUF (Nbuf)->Flag, TCP_FLG_RST) 206 ) { 207 208 Data = NetbufAllocSpace ( 209 Nbuf, 210 TCP_OPTION_TS_ALIGNED_LEN, 211 NET_BUF_HEAD 212 ); 213 214 ASSERT (Data != NULL); 215 Len += TCP_OPTION_TS_ALIGNED_LEN; 216 217 TcpPutUint32 (Data, TCP_OPTION_TS_FAST); 218 TcpPutUint32 (Data + 4, mTcpTick); 219 TcpPutUint32 (Data + 8, Tcb->TsRecent); 220 } 221 222 return Len; 223 } 224 225 /** 226 Parse the supported options. 227 228 @param[in] Tcp Pointer to the TCP_CB of this TCP instance. 229 @param[in, out] Option Pointer to the TCP_OPTION used to store the 230 successfully pasrsed options. 231 232 @retval 0 The options are successfully pasrsed. 233 @retval -1 Ilegal option was found. 234 235 **/ 236 INTN 237 TcpParseOption ( 238 IN TCP_HEAD *Tcp, 239 IN OUT TCP_OPTION *Option 240 ) 241 { 242 UINT8 *Head; 243 UINT8 TotalLen; 244 UINT8 Cur; 245 UINT8 Type; 246 UINT8 Len; 247 248 ASSERT ((Tcp != NULL) && (Option != NULL)); 249 250 Option->Flag = 0; 251 252 TotalLen = (UINT8) ((Tcp->HeadLen << 2) - sizeof (TCP_HEAD)); 253 if (TotalLen <= 0) { 254 return 0; 255 } 256 257 Head = (UINT8 *) (Tcp + 1); 258 259 // 260 // Fast process of the timestamp option. 261 // 262 if ((TotalLen == TCP_OPTION_TS_ALIGNED_LEN) && (TcpGetUint32 (Head) == TCP_OPTION_TS_FAST)) { 263 264 Option->TSVal = TcpGetUint32 (Head + 4); 265 Option->TSEcr = TcpGetUint32 (Head + 8); 266 Option->Flag = TCP_OPTION_RCVD_TS; 267 268 return 0; 269 } 270 // 271 // Slow path to process the options. 272 // 273 Cur = 0; 274 275 while (Cur < TotalLen) { 276 Type = Head[Cur]; 277 278 switch (Type) { 279 case TCP_OPTION_MSS: 280 Len = Head[Cur + 1]; 281 282 if ((Len != TCP_OPTION_MSS_LEN) || (TotalLen - Cur < TCP_OPTION_MSS_LEN)) { 283 284 return -1; 285 } 286 287 Option->Mss = TcpGetUint16 (&Head[Cur + 2]); 288 TCP_SET_FLG (Option->Flag, TCP_OPTION_RCVD_MSS); 289 290 Cur += TCP_OPTION_MSS_LEN; 291 break; 292 293 case TCP_OPTION_WS: 294 Len = Head[Cur + 1]; 295 296 if ((Len != TCP_OPTION_WS_LEN) || (TotalLen - Cur < TCP_OPTION_WS_LEN)) { 297 298 return -1; 299 } 300 301 Option->WndScale = (UINT8) MIN (14, Head[Cur + 2]); 302 TCP_SET_FLG (Option->Flag, TCP_OPTION_RCVD_WS); 303 304 Cur += TCP_OPTION_WS_LEN; 305 break; 306 307 case TCP_OPTION_TS: 308 Len = Head[Cur + 1]; 309 310 if ((Len != TCP_OPTION_TS_LEN) || (TotalLen - Cur < TCP_OPTION_TS_LEN)) { 311 312 return -1; 313 } 314 315 Option->TSVal = TcpGetUint32 (&Head[Cur + 2]); 316 Option->TSEcr = TcpGetUint32 (&Head[Cur + 6]); 317 TCP_SET_FLG (Option->Flag, TCP_OPTION_RCVD_TS); 318 319 Cur += TCP_OPTION_TS_LEN; 320 break; 321 322 case TCP_OPTION_NOP: 323 Cur++; 324 break; 325 326 case TCP_OPTION_EOP: 327 Cur = TotalLen; 328 break; 329 330 default: 331 Len = Head[Cur + 1]; 332 333 if ((TotalLen - Cur) < Len || Len < 2) { 334 return -1; 335 } 336 337 Cur = (UINT8) (Cur + Len); 338 break; 339 } 340 341 } 342 343 return 0; 344 } 345 346 /** 347 Check the segment against PAWS. 348 349 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 350 @param[in] TSVal The timestamp value. 351 352 @retval 1 The segment passed the PAWS check. 353 @retval 0 The segment failed to pass the PAWS check. 354 355 **/ 356 UINT32 357 TcpPawsOK ( 358 IN TCP_CB *Tcb, 359 IN UINT32 TSVal 360 ) 361 { 362 // 363 // PAWS as defined in RFC1323, buggy... 364 // 365 if (TCP_TIME_LT (TSVal, Tcb->TsRecent) && 366 TCP_TIME_LT (Tcb->TsRecentAge + TCP_PAWS_24DAY, mTcpTick) 367 ) { 368 369 return 0; 370 371 } 372 373 return 1; 374 } 375
