1 /** @file 2 The implementation of a dispatch routine for processing TCP requests. 3 4 (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR> 5 Copyright (c) 2009 - 2014, Intel Corporation. All rights reserved.<BR> 6 7 This program and the accompanying materials 8 are licensed and made available under the terms and conditions of the BSD License 9 which accompanies this distribution. The full text of the license may be found at 10 http://opensource.org/licenses/bsd-license.php. 11 12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 14 15 **/ 16 17 #include "TcpMain.h" 18 19 /** 20 Add or remove a route entry in the IP route table associated with this TCP instance. 21 22 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 23 @param[in] RouteInfo Pointer to the route information to be processed. 24 25 @retval EFI_SUCCESS The operation completed successfully. 26 @retval EFI_NOT_STARTED The driver instance has not been started. 27 @retval EFI_NO_MAPPING When using the default address, configuration(DHCP, 28 BOOTP, RARP, etc.) is not finished yet. 29 @retval EFI_OUT_OF_RESOURCES Could not add the entry to the routing table. 30 @retval EFI_NOT_FOUND This route is not in the routing table 31 (when RouteInfo->DeleteRoute is TRUE). 32 @retval EFI_ACCESS_DENIED The route is already defined in the routing table 33 (when RouteInfo->DeleteRoute is FALSE). 34 **/ 35 EFI_STATUS 36 Tcp4Route ( 37 IN TCP_CB *Tcb, 38 IN TCP4_ROUTE_INFO *RouteInfo 39 ) 40 { 41 IP_IO_IP_PROTOCOL Ip; 42 43 Ip = Tcb->IpInfo->Ip; 44 45 ASSERT (Ip.Ip4!= NULL); 46 47 return Ip.Ip4->Routes ( 48 Ip.Ip4, 49 RouteInfo->DeleteRoute, 50 RouteInfo->SubnetAddress, 51 RouteInfo->SubnetMask, 52 RouteInfo->GatewayAddress 53 ); 54 55 } 56 57 /** 58 Get the operational settings of this TCPv4 instance. 59 60 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 61 @param[in, out] Mode Pointer to the buffer to store the operational 62 settings. 63 64 @retval EFI_SUCCESS The mode data was read. 65 @retval EFI_NOT_STARTED No configuration data is available because this 66 instance hasn't been started. 67 68 **/ 69 EFI_STATUS 70 Tcp4GetMode ( 71 IN TCP_CB *Tcb, 72 IN OUT TCP4_MODE_DATA *Mode 73 ) 74 { 75 SOCKET *Sock; 76 EFI_TCP4_CONFIG_DATA *ConfigData; 77 EFI_TCP4_ACCESS_POINT *AccessPoint; 78 EFI_TCP4_OPTION *Option; 79 EFI_IP4_PROTOCOL *Ip; 80 81 Sock = Tcb->Sk; 82 83 if (!SOCK_IS_CONFIGURED (Sock) && (Mode->Tcp4ConfigData != NULL)) { 84 return EFI_NOT_STARTED; 85 } 86 87 if (Mode->Tcp4State != NULL) { 88 *(Mode->Tcp4State) = (EFI_TCP4_CONNECTION_STATE) Tcb->State; 89 } 90 91 if (Mode->Tcp4ConfigData != NULL) { 92 93 ConfigData = Mode->Tcp4ConfigData; 94 AccessPoint = &(ConfigData->AccessPoint); 95 Option = ConfigData->ControlOption; 96 97 ConfigData->TypeOfService = Tcb->Tos; 98 ConfigData->TimeToLive = Tcb->Ttl; 99 100 AccessPoint->UseDefaultAddress = Tcb->UseDefaultAddr; 101 102 IP4_COPY_ADDRESS (&AccessPoint->StationAddress, &Tcb->LocalEnd.Ip); 103 104 IP4_COPY_ADDRESS (&AccessPoint->SubnetMask, &Tcb->SubnetMask); 105 AccessPoint->StationPort = NTOHS (Tcb->LocalEnd.Port); 106 107 IP4_COPY_ADDRESS (&AccessPoint->RemoteAddress, &Tcb->RemoteEnd.Ip); 108 109 AccessPoint->RemotePort = NTOHS (Tcb->RemoteEnd.Port); 110 AccessPoint->ActiveFlag = (BOOLEAN) (Tcb->State != TCP_LISTEN); 111 112 if (Option != NULL) { 113 Option->ReceiveBufferSize = GET_RCV_BUFFSIZE (Tcb->Sk); 114 Option->SendBufferSize = GET_SND_BUFFSIZE (Tcb->Sk); 115 Option->MaxSynBackLog = GET_BACKLOG (Tcb->Sk); 116 117 Option->ConnectionTimeout = Tcb->ConnectTimeout / TCP_TICK_HZ; 118 Option->DataRetries = Tcb->MaxRexmit; 119 Option->FinTimeout = Tcb->FinWait2Timeout / TCP_TICK_HZ; 120 Option->TimeWaitTimeout = Tcb->TimeWaitTimeout / TCP_TICK_HZ; 121 Option->KeepAliveProbes = Tcb->MaxKeepAlive; 122 Option->KeepAliveTime = Tcb->KeepAliveIdle / TCP_TICK_HZ; 123 Option->KeepAliveInterval = Tcb->KeepAlivePeriod / TCP_TICK_HZ; 124 125 Option->EnableNagle = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE)); 126 Option->EnableTimeStamp = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS)); 127 Option->EnableWindowScaling = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS)); 128 129 Option->EnableSelectiveAck = FALSE; 130 Option->EnablePathMtuDiscovery = FALSE; 131 } 132 } 133 134 Ip = Tcb->IpInfo->Ip.Ip4; 135 ASSERT (Ip != NULL); 136 137 return Ip->GetModeData (Ip, Mode->Ip4ModeData, Mode->MnpConfigData, Mode->SnpModeData); 138 } 139 140 /** 141 Get the operational settings of this TCPv6 instance. 142 143 @param[in] Tcb Pointer to the TCP_CB of this TCP instance. 144 @param[in, out] Mode Pointer to the buffer to store the operational 145 settings. 146 147 @retval EFI_SUCCESS The mode data was read. 148 @retval EFI_NOT_STARTED No configuration data is available because this 149 instance hasn't been started. 150 151 **/ 152 EFI_STATUS 153 Tcp6GetMode ( 154 IN TCP_CB *Tcb, 155 IN OUT TCP6_MODE_DATA *Mode 156 ) 157 { 158 SOCKET *Sock; 159 EFI_TCP6_CONFIG_DATA *ConfigData; 160 EFI_TCP6_ACCESS_POINT *AccessPoint; 161 EFI_TCP6_OPTION *Option; 162 EFI_IP6_PROTOCOL *Ip; 163 164 Sock = Tcb->Sk; 165 166 if (!SOCK_IS_CONFIGURED (Sock) && (Mode->Tcp6ConfigData != NULL)) { 167 return EFI_NOT_STARTED; 168 } 169 170 if (Mode->Tcp6State != NULL) { 171 *(Mode->Tcp6State) = (EFI_TCP6_CONNECTION_STATE) (Tcb->State); 172 } 173 174 if (Mode->Tcp6ConfigData != NULL) { 175 176 ConfigData = Mode->Tcp6ConfigData; 177 AccessPoint = &(ConfigData->AccessPoint); 178 Option = ConfigData->ControlOption; 179 180 ConfigData->TrafficClass = Tcb->Tos; 181 ConfigData->HopLimit = Tcb->Ttl; 182 183 AccessPoint->StationPort = NTOHS (Tcb->LocalEnd.Port); 184 AccessPoint->RemotePort = NTOHS (Tcb->RemoteEnd.Port); 185 AccessPoint->ActiveFlag = (BOOLEAN) (Tcb->State != TCP_LISTEN); 186 187 IP6_COPY_ADDRESS (&AccessPoint->StationAddress, &Tcb->LocalEnd.Ip); 188 IP6_COPY_ADDRESS (&AccessPoint->RemoteAddress, &Tcb->RemoteEnd.Ip); 189 190 if (Option != NULL) { 191 Option->ReceiveBufferSize = GET_RCV_BUFFSIZE (Tcb->Sk); 192 Option->SendBufferSize = GET_SND_BUFFSIZE (Tcb->Sk); 193 Option->MaxSynBackLog = GET_BACKLOG (Tcb->Sk); 194 195 Option->ConnectionTimeout = Tcb->ConnectTimeout / TCP_TICK_HZ; 196 Option->DataRetries = Tcb->MaxRexmit; 197 Option->FinTimeout = Tcb->FinWait2Timeout / TCP_TICK_HZ; 198 Option->TimeWaitTimeout = Tcb->TimeWaitTimeout / TCP_TICK_HZ; 199 Option->KeepAliveProbes = Tcb->MaxKeepAlive; 200 Option->KeepAliveTime = Tcb->KeepAliveIdle / TCP_TICK_HZ; 201 Option->KeepAliveInterval = Tcb->KeepAlivePeriod / TCP_TICK_HZ; 202 203 Option->EnableNagle = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE)); 204 Option->EnableTimeStamp = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_TS)); 205 Option->EnableWindowScaling = (BOOLEAN) (!TCP_FLG_ON (Tcb->CtrlFlag, TCP_CTRL_NO_WS)); 206 207 Option->EnableSelectiveAck = FALSE; 208 Option->EnablePathMtuDiscovery = FALSE; 209 } 210 } 211 212 Ip = Tcb->IpInfo->Ip.Ip6; 213 ASSERT (Ip != NULL); 214 215 return Ip->GetModeData (Ip, Mode->Ip6ModeData, Mode->MnpConfigData, Mode->SnpModeData); 216 } 217 218 /** 219 If TcpAp->StationPort isn't zero, check whether the access point 220 is registered, else generate a random station port for this 221 access point. 222 223 @param[in] TcpAp Pointer to the access point. 224 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6 225 226 @retval EFI_SUCCESS The check passed or the port is assigned. 227 @retval EFI_INVALID_PARAMETER The non-zero station port is already used. 228 @retval EFI_OUT_OF_RESOURCES No port can be allocated. 229 230 **/ 231 EFI_STATUS 232 TcpBind ( 233 IN TCP_ACCESS_POINT *TcpAp, 234 IN UINT8 IpVersion 235 ) 236 { 237 BOOLEAN Cycle; 238 EFI_IP_ADDRESS Local; 239 UINT16 *Port; 240 UINT16 *RandomPort; 241 242 if (IpVersion == IP_VERSION_4) { 243 IP4_COPY_ADDRESS (&Local, &TcpAp->Tcp4Ap.StationAddress); 244 Port = &TcpAp->Tcp4Ap.StationPort; 245 RandomPort = &mTcp4RandomPort; 246 } else { 247 IP6_COPY_ADDRESS (&Local, &TcpAp->Tcp6Ap.StationAddress); 248 Port = &TcpAp->Tcp6Ap.StationPort; 249 RandomPort = &mTcp6RandomPort; 250 } 251 252 if (0 != *Port) { 253 // 254 // Check if a same endpoing is bound. 255 // 256 if (TcpFindTcbByPeer (&Local, *Port, IpVersion)) { 257 258 return EFI_INVALID_PARAMETER; 259 } 260 } else { 261 // 262 // generate a random port 263 // 264 Cycle = FALSE; 265 266 if (TCP_PORT_USER_RESERVED == *RandomPort) { 267 *RandomPort = TCP_PORT_KNOWN; 268 } 269 270 (*RandomPort)++; 271 272 while (TcpFindTcbByPeer (&Local, *RandomPort, IpVersion)) { 273 (*RandomPort)++; 274 275 if (*RandomPort <= TCP_PORT_KNOWN) { 276 if (Cycle) { 277 DEBUG ( 278 (EFI_D_ERROR, 279 "TcpBind: no port can be allocated for this pcb\n") 280 ); 281 return EFI_OUT_OF_RESOURCES; 282 } 283 284 *RandomPort = TCP_PORT_KNOWN + 1; 285 286 Cycle = TRUE; 287 } 288 } 289 290 *Port = *RandomPort; 291 } 292 293 return EFI_SUCCESS; 294 } 295 296 /** 297 Flush the Tcb add its associated protocols. 298 299 @param[in, out] Tcb Pointer to the TCP_CB to be flushed. 300 301 **/ 302 VOID 303 TcpFlushPcb ( 304 IN OUT TCP_CB *Tcb 305 ) 306 { 307 SOCKET *Sock; 308 309 IpIoConfigIp (Tcb->IpInfo, NULL); 310 311 Sock = Tcb->Sk; 312 313 if (SOCK_IS_CONFIGURED (Sock)) { 314 RemoveEntryList (&Tcb->List); 315 316 if (Sock->DevicePath != NULL) { 317 // 318 // Uninstall the device path protocl. 319 // 320 gBS->UninstallProtocolInterface ( 321 Sock->SockHandle, 322 &gEfiDevicePathProtocolGuid, 323 Sock->DevicePath 324 ); 325 326 FreePool (Sock->DevicePath); 327 Sock->DevicePath = NULL; 328 } 329 } 330 331 NetbufFreeList (&Tcb->SndQue); 332 NetbufFreeList (&Tcb->RcvQue); 333 Tcb->State = TCP_CLOSED; 334 Tcb->RemoteIpZero = FALSE; 335 } 336 337 /** 338 Attach a Pcb to the socket. 339 340 @param[in] Sk Pointer to the socket of this TCP instance. 341 342 @retval EFI_SUCCESS The operation completed successfully. 343 @retval EFI_OUT_OF_RESOURCES Failed due to resource limits. 344 345 **/ 346 EFI_STATUS 347 TcpAttachPcb ( 348 IN SOCKET *Sk 349 ) 350 { 351 TCP_CB *Tcb; 352 TCP_PROTO_DATA *ProtoData; 353 IP_IO *IpIo; 354 EFI_STATUS Status; 355 VOID *Ip; 356 EFI_GUID *IpProtocolGuid; 357 358 if (Sk->IpVersion == IP_VERSION_4) { 359 IpProtocolGuid = &gEfiIp4ProtocolGuid; 360 } else { 361 IpProtocolGuid = &gEfiIp6ProtocolGuid; 362 } 363 364 Tcb = AllocateZeroPool (sizeof (TCP_CB)); 365 366 if (Tcb == NULL) { 367 368 DEBUG ((EFI_D_ERROR, "TcpConfigurePcb: failed to allocate a TCB\n")); 369 370 return EFI_OUT_OF_RESOURCES; 371 } 372 373 ProtoData = (TCP_PROTO_DATA *) Sk->ProtoReserved; 374 IpIo = ProtoData->TcpService->IpIo; 375 376 // 377 // Create an IpInfo for this Tcb. 378 // 379 Tcb->IpInfo = IpIoAddIp (IpIo); 380 if (Tcb->IpInfo == NULL) { 381 382 FreePool (Tcb); 383 return EFI_OUT_OF_RESOURCES; 384 } 385 386 // 387 // Open the new created IP instance BY_CHILD. 388 // 389 Status = gBS->OpenProtocol ( 390 Tcb->IpInfo->ChildHandle, 391 IpProtocolGuid, 392 &Ip, 393 IpIo->Image, 394 Sk->SockHandle, 395 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 396 ); 397 if (EFI_ERROR (Status)) { 398 IpIoRemoveIp (IpIo, Tcb->IpInfo); 399 return Status; 400 } 401 402 InitializeListHead (&Tcb->List); 403 InitializeListHead (&Tcb->SndQue); 404 InitializeListHead (&Tcb->RcvQue); 405 406 Tcb->State = TCP_CLOSED; 407 Tcb->Sk = Sk; 408 ProtoData->TcpPcb = Tcb; 409 410 return EFI_SUCCESS; 411 } 412 413 /** 414 Detach the Pcb of the socket. 415 416 @param[in, out] Sk Pointer to the socket of this TCP instance. 417 418 **/ 419 VOID 420 TcpDetachPcb ( 421 IN OUT SOCKET *Sk 422 ) 423 { 424 TCP_PROTO_DATA *ProtoData; 425 TCP_CB *Tcb; 426 EFI_GUID *IpProtocolGuid; 427 428 if (Sk->IpVersion == IP_VERSION_4) { 429 IpProtocolGuid = &gEfiIp4ProtocolGuid; 430 } else { 431 IpProtocolGuid = &gEfiIp6ProtocolGuid; 432 } 433 434 ProtoData = (TCP_PROTO_DATA *) Sk->ProtoReserved; 435 Tcb = ProtoData->TcpPcb; 436 437 ASSERT (Tcb != NULL); 438 439 TcpFlushPcb (Tcb); 440 441 // 442 // Close the IP protocol. 443 // 444 gBS->CloseProtocol ( 445 Tcb->IpInfo->ChildHandle, 446 IpProtocolGuid, 447 ProtoData->TcpService->IpIo->Image, 448 Sk->SockHandle 449 ); 450 451 IpIoRemoveIp (ProtoData->TcpService->IpIo, Tcb->IpInfo); 452 453 FreePool (Tcb); 454 455 ProtoData->TcpPcb = NULL; 456 } 457 458 /** 459 Configure the Pcb using CfgData. 460 461 @param[in] Sk Pointer to the socket of this TCP instance. 462 @param[in] CfgData Pointer to the TCP configuration data. 463 464 @retval EFI_SUCCESS The operation completed successfully. 465 @retval EFI_INVALID_PARAMETER A same access point has been configured in 466 another TCP instance. 467 @retval EFI_OUT_OF_RESOURCES Failed due to resource limits. 468 469 **/ 470 EFI_STATUS 471 TcpConfigurePcb ( 472 IN SOCKET *Sk, 473 IN TCP_CONFIG_DATA *CfgData 474 ) 475 { 476 IP_IO_IP_CONFIG_DATA IpCfgData; 477 EFI_STATUS Status; 478 EFI_TCP4_OPTION *Option; 479 TCP_PROTO_DATA *TcpProto; 480 TCP_CB *Tcb; 481 TCP_ACCESS_POINT *TcpAp; 482 483 ASSERT ((CfgData != NULL) && (Sk != NULL) && (Sk->SockHandle != NULL)); 484 485 TcpProto = (TCP_PROTO_DATA *) Sk->ProtoReserved; 486 Tcb = TcpProto->TcpPcb; 487 488 ASSERT (Tcb != NULL); 489 490 if (Sk->IpVersion == IP_VERSION_4) { 491 // 492 // Add Ip for send pkt to the peer 493 // 494 CopyMem (&IpCfgData.Ip4CfgData, &mIp4IoDefaultIpConfigData, sizeof (EFI_IP4_CONFIG_DATA)); 495 IpCfgData.Ip4CfgData.DefaultProtocol = EFI_IP_PROTO_TCP; 496 IpCfgData.Ip4CfgData.TypeOfService = CfgData->Tcp4CfgData.TypeOfService; 497 IpCfgData.Ip4CfgData.TimeToLive = CfgData->Tcp4CfgData.TimeToLive; 498 IpCfgData.Ip4CfgData.UseDefaultAddress = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress; 499 IP4_COPY_ADDRESS ( 500 &IpCfgData.Ip4CfgData.SubnetMask, 501 &CfgData->Tcp4CfgData.AccessPoint.SubnetMask 502 ); 503 IpCfgData.Ip4CfgData.ReceiveTimeout = (UINT32) (-1); 504 IP4_COPY_ADDRESS ( 505 &IpCfgData.Ip4CfgData.StationAddress, 506 &CfgData->Tcp4CfgData.AccessPoint.StationAddress 507 ); 508 509 } else { 510 ASSERT (Sk->IpVersion == IP_VERSION_6); 511 512 CopyMem (&IpCfgData.Ip6CfgData, &mIp6IoDefaultIpConfigData, sizeof (EFI_IP6_CONFIG_DATA)); 513 IpCfgData.Ip6CfgData.DefaultProtocol = EFI_IP_PROTO_TCP; 514 IpCfgData.Ip6CfgData.TrafficClass = CfgData->Tcp6CfgData.TrafficClass; 515 IpCfgData.Ip6CfgData.HopLimit = CfgData->Tcp6CfgData.HopLimit; 516 IpCfgData.Ip6CfgData.ReceiveTimeout = (UINT32) (-1); 517 IP6_COPY_ADDRESS ( 518 &IpCfgData.Ip6CfgData.StationAddress, 519 &CfgData->Tcp6CfgData.AccessPoint.StationAddress 520 ); 521 IP6_COPY_ADDRESS ( 522 &IpCfgData.Ip6CfgData.DestinationAddress, 523 &CfgData->Tcp6CfgData.AccessPoint.RemoteAddress 524 ); 525 } 526 527 // 528 // Configure the IP instance this Tcb consumes. 529 // 530 Status = IpIoConfigIp (Tcb->IpInfo, &IpCfgData); 531 if (EFI_ERROR (Status)) { 532 goto OnExit; 533 } 534 535 if (Sk->IpVersion == IP_VERSION_4) { 536 // 537 // Get the default address information if the instance is configured to use default address. 538 // 539 IP4_COPY_ADDRESS ( 540 &CfgData->Tcp4CfgData.AccessPoint.StationAddress, 541 &IpCfgData.Ip4CfgData.StationAddress 542 ); 543 IP4_COPY_ADDRESS ( 544 &CfgData->Tcp4CfgData.AccessPoint.SubnetMask, 545 &IpCfgData.Ip4CfgData.SubnetMask 546 ); 547 548 TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp4CfgData.AccessPoint; 549 } else { 550 IP6_COPY_ADDRESS ( 551 &CfgData->Tcp6CfgData.AccessPoint.StationAddress, 552 &IpCfgData.Ip6CfgData.StationAddress 553 ); 554 555 TcpAp = (TCP_ACCESS_POINT *) &CfgData->Tcp6CfgData.AccessPoint; 556 } 557 558 // 559 // check if we can bind this endpoint in CfgData 560 // 561 Status = TcpBind (TcpAp, Sk->IpVersion); 562 563 if (EFI_ERROR (Status)) { 564 DEBUG ( 565 (EFI_D_ERROR, 566 "TcpConfigurePcb: Bind endpoint failed with %r\n", 567 Status) 568 ); 569 570 goto OnExit; 571 } 572 573 // 574 // Initalize the operating information in this Tcb 575 // 576 ASSERT (Tcb->State == TCP_CLOSED && 577 IsListEmpty (&Tcb->SndQue) && 578 IsListEmpty (&Tcb->RcvQue)); 579 580 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE); 581 Tcb->State = TCP_CLOSED; 582 583 Tcb->SndMss = 536; 584 Tcb->RcvMss = TcpGetRcvMss (Sk); 585 586 Tcb->SRtt = 0; 587 Tcb->Rto = 3 * TCP_TICK_HZ; 588 589 Tcb->CWnd = Tcb->SndMss; 590 Tcb->Ssthresh = 0xffffffff; 591 592 Tcb->CongestState = TCP_CONGEST_OPEN; 593 594 Tcb->KeepAliveIdle = TCP_KEEPALIVE_IDLE_MIN; 595 Tcb->KeepAlivePeriod = TCP_KEEPALIVE_PERIOD; 596 Tcb->MaxKeepAlive = TCP_MAX_KEEPALIVE; 597 Tcb->MaxRexmit = TCP_MAX_LOSS; 598 Tcb->FinWait2Timeout = TCP_FIN_WAIT2_TIME; 599 Tcb->TimeWaitTimeout = TCP_TIME_WAIT_TIME; 600 Tcb->ConnectTimeout = TCP_CONNECT_TIME; 601 602 if (Sk->IpVersion == IP_VERSION_4) { 603 // 604 // initialize Tcb in the light of CfgData 605 // 606 Tcb->Ttl = CfgData->Tcp4CfgData.TimeToLive; 607 Tcb->Tos = CfgData->Tcp4CfgData.TypeOfService; 608 609 Tcb->UseDefaultAddr = CfgData->Tcp4CfgData.AccessPoint.UseDefaultAddress; 610 611 CopyMem (&Tcb->LocalEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.StationAddress, sizeof (IP4_ADDR)); 612 Tcb->LocalEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.StationPort); 613 IP4_COPY_ADDRESS (&Tcb->SubnetMask, &CfgData->Tcp4CfgData.AccessPoint.SubnetMask); 614 615 CopyMem (&Tcb->RemoteEnd.Ip, &CfgData->Tcp4CfgData.AccessPoint.RemoteAddress, sizeof (IP4_ADDR)); 616 Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp4CfgData.AccessPoint.RemotePort); 617 618 Option = CfgData->Tcp4CfgData.ControlOption; 619 } else { 620 Tcb->Ttl = CfgData->Tcp6CfgData.HopLimit; 621 Tcb->Tos = CfgData->Tcp6CfgData.TrafficClass; 622 623 IP6_COPY_ADDRESS (&Tcb->LocalEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.StationAddress); 624 Tcb->LocalEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.StationPort); 625 626 IP6_COPY_ADDRESS (&Tcb->RemoteEnd.Ip, &CfgData->Tcp6CfgData.AccessPoint.RemoteAddress); 627 Tcb->RemoteEnd.Port = HTONS (CfgData->Tcp6CfgData.AccessPoint.RemotePort); 628 629 // 630 // Type EFI_TCP4_OPTION and EFI_TCP6_OPTION are the same. 631 // 632 Option = (EFI_TCP4_OPTION *) CfgData->Tcp6CfgData.ControlOption; 633 } 634 635 if (Option != NULL) { 636 SET_RCV_BUFFSIZE ( 637 Sk, 638 (UINT32) (TCP_COMP_VAL ( 639 TCP_RCV_BUF_SIZE_MIN, 640 TCP_RCV_BUF_SIZE, 641 TCP_RCV_BUF_SIZE, 642 Option->ReceiveBufferSize 643 ) 644 ) 645 ); 646 SET_SND_BUFFSIZE ( 647 Sk, 648 (UINT32) (TCP_COMP_VAL ( 649 TCP_SND_BUF_SIZE_MIN, 650 TCP_SND_BUF_SIZE, 651 TCP_SND_BUF_SIZE, 652 Option->SendBufferSize 653 ) 654 ) 655 ); 656 657 SET_BACKLOG ( 658 Sk, 659 (UINT32) (TCP_COMP_VAL ( 660 TCP_BACKLOG_MIN, 661 TCP_BACKLOG, 662 TCP_BACKLOG, 663 Option->MaxSynBackLog 664 ) 665 ) 666 ); 667 668 Tcb->MaxRexmit = (UINT16) TCP_COMP_VAL ( 669 TCP_MAX_LOSS_MIN, 670 TCP_MAX_LOSS, 671 TCP_MAX_LOSS, 672 Option->DataRetries 673 ); 674 Tcb->FinWait2Timeout = TCP_COMP_VAL ( 675 TCP_FIN_WAIT2_TIME, 676 TCP_FIN_WAIT2_TIME_MAX, 677 TCP_FIN_WAIT2_TIME, 678 (UINT32) (Option->FinTimeout * TCP_TICK_HZ) 679 ); 680 681 if (Option->TimeWaitTimeout != 0) { 682 Tcb->TimeWaitTimeout = TCP_COMP_VAL ( 683 TCP_TIME_WAIT_TIME, 684 TCP_TIME_WAIT_TIME_MAX, 685 TCP_TIME_WAIT_TIME, 686 (UINT32) (Option->TimeWaitTimeout * TCP_TICK_HZ) 687 ); 688 } else { 689 Tcb->TimeWaitTimeout = 0; 690 } 691 692 if (Option->KeepAliveProbes != 0) { 693 TCP_CLEAR_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_KEEPALIVE); 694 695 Tcb->MaxKeepAlive = (UINT8) TCP_COMP_VAL ( 696 TCP_MAX_KEEPALIVE_MIN, 697 TCP_MAX_KEEPALIVE, 698 TCP_MAX_KEEPALIVE, 699 Option->KeepAliveProbes 700 ); 701 Tcb->KeepAliveIdle = TCP_COMP_VAL ( 702 TCP_KEEPALIVE_IDLE_MIN, 703 TCP_KEEPALIVE_IDLE_MAX, 704 TCP_KEEPALIVE_IDLE_MIN, 705 (UINT32) (Option->KeepAliveTime * TCP_TICK_HZ) 706 ); 707 Tcb->KeepAlivePeriod = TCP_COMP_VAL ( 708 TCP_KEEPALIVE_PERIOD_MIN, 709 TCP_KEEPALIVE_PERIOD, 710 TCP_KEEPALIVE_PERIOD, 711 (UINT32) (Option->KeepAliveInterval * TCP_TICK_HZ) 712 ); 713 } 714 715 Tcb->ConnectTimeout = TCP_COMP_VAL ( 716 TCP_CONNECT_TIME_MIN, 717 TCP_CONNECT_TIME, 718 TCP_CONNECT_TIME, 719 (UINT32) (Option->ConnectionTimeout * TCP_TICK_HZ) 720 ); 721 722 if (!Option->EnableNagle) { 723 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_NAGLE); 724 } 725 726 if (!Option->EnableTimeStamp) { 727 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_TS); 728 } 729 730 if (!Option->EnableWindowScaling) { 731 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_NO_WS); 732 } 733 } 734 735 // 736 // The socket is bound, the <SrcIp, SrcPort, DstIp, DstPort> is 737 // determined, construct the IP device path and install it. 738 // 739 Status = TcpInstallDevicePath (Sk); 740 if (EFI_ERROR (Status)) { 741 goto OnExit; 742 } 743 744 // 745 // update state of Tcb and socket 746 // 747 if (((Sk->IpVersion == IP_VERSION_4) && !CfgData->Tcp4CfgData.AccessPoint.ActiveFlag) || 748 ((Sk->IpVersion == IP_VERSION_6) && !CfgData->Tcp6CfgData.AccessPoint.ActiveFlag) 749 ) { 750 751 TcpSetState (Tcb, TCP_LISTEN); 752 SockSetState (Sk, SO_LISTENING); 753 754 Sk->ConfigureState = SO_CONFIGURED_PASSIVE; 755 } else { 756 757 Sk->ConfigureState = SO_CONFIGURED_ACTIVE; 758 } 759 760 if (Sk->IpVersion == IP_VERSION_6) { 761 Tcb->Tick = TCP6_REFRESH_NEIGHBOR_TICK; 762 763 if (NetIp6IsUnspecifiedAddr (&Tcb->RemoteEnd.Ip.v6)) { 764 Tcb->RemoteIpZero = TRUE; 765 } 766 } 767 768 TcpInsertTcb (Tcb); 769 770 OnExit: 771 772 return Status; 773 } 774 775 /** 776 The procotol handler provided to the socket layer, which is used to 777 dispatch the socket level requests by calling the corresponding 778 TCP layer functions. 779 780 @param[in] Sock Pointer to the socket of this TCP instance. 781 @param[in] Request The code of this operation request. 782 @param[in] Data Pointer to the operation specific data passed in 783 together with the operation request. This is an 784 optional parameter that may be NULL. 785 786 @retval EFI_SUCCESS The socket request completed successfully. 787 @retval other The error status returned by the corresponding TCP 788 layer function. 789 790 **/ 791 EFI_STATUS 792 TcpDispatcher ( 793 IN SOCKET *Sock, 794 IN UINT8 Request, 795 IN VOID *Data OPTIONAL 796 ) 797 { 798 TCP_CB *Tcb; 799 TCP_PROTO_DATA *ProtoData; 800 801 ProtoData = (TCP_PROTO_DATA *) Sock->ProtoReserved; 802 Tcb = ProtoData->TcpPcb; 803 804 switch (Request) { 805 case SOCK_POLL: 806 if (Tcb->Sk->IpVersion == IP_VERSION_4) { 807 ProtoData->TcpService->IpIo->Ip.Ip4->Poll (ProtoData->TcpService->IpIo->Ip.Ip4); 808 } else { 809 ProtoData->TcpService->IpIo->Ip.Ip6->Poll (ProtoData->TcpService->IpIo->Ip.Ip6); 810 } 811 812 break; 813 814 case SOCK_CONSUMED: 815 // 816 // After user received data from socket buffer, socket will 817 // notify TCP using this message to give it a chance to send out 818 // window update information 819 // 820 ASSERT (Tcb != NULL); 821 TcpOnAppConsume (Tcb); 822 break; 823 824 case SOCK_SND: 825 826 ASSERT (Tcb != NULL); 827 TcpOnAppSend (Tcb); 828 break; 829 830 case SOCK_CLOSE: 831 832 TcpOnAppClose (Tcb); 833 834 break; 835 836 case SOCK_ABORT: 837 838 TcpOnAppAbort (Tcb); 839 840 break; 841 842 case SOCK_SNDPUSH: 843 Tcb->SndPsh = TcpGetMaxSndNxt (Tcb) + GET_SND_DATASIZE (Tcb->Sk); 844 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_PSH); 845 846 break; 847 848 case SOCK_SNDURG: 849 Tcb->SndUp = TcpGetMaxSndNxt (Tcb) + GET_SND_DATASIZE (Tcb->Sk) - 1; 850 TCP_SET_FLG (Tcb->CtrlFlag, TCP_CTRL_SND_URG); 851 852 break; 853 854 case SOCK_CONNECT: 855 856 TcpOnAppConnect (Tcb); 857 858 break; 859 860 case SOCK_ATTACH: 861 862 return TcpAttachPcb (Sock); 863 864 break; 865 866 case SOCK_FLUSH: 867 868 TcpFlushPcb (Tcb); 869 870 break; 871 872 case SOCK_DETACH: 873 874 TcpDetachPcb (Sock); 875 876 break; 877 878 case SOCK_CONFIGURE: 879 880 return TcpConfigurePcb ( 881 Sock, 882 (TCP_CONFIG_DATA *) Data 883 ); 884 885 break; 886 887 case SOCK_MODE: 888 889 ASSERT ((Data != NULL) && (Tcb != NULL)); 890 891 if (Tcb->Sk->IpVersion == IP_VERSION_4) { 892 893 return Tcp4GetMode (Tcb, (TCP4_MODE_DATA *) Data); 894 } else { 895 896 return Tcp6GetMode (Tcb, (TCP6_MODE_DATA *) Data); 897 } 898 899 break; 900 901 case SOCK_ROUTE: 902 903 ASSERT ((Data != NULL) && (Tcb != NULL) && (Tcb->Sk->IpVersion == IP_VERSION_4)); 904 905 return Tcp4Route (Tcb, (TCP4_ROUTE_INFO *) Data); 906 907 default: 908 909 return EFI_UNSUPPORTED; 910 } 911 912 return EFI_SUCCESS; 913 } 914
