1 /** @file 2 The implementation of common functions shared by IP6 driver. 3 4 Copyright (c) 2009 - 2016, 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 "Ip6Impl.h" 17 18 /** 19 Build a array of EFI_IP6_ADDRESS_INFO to be returned to the caller. The number 20 of EFI_IP6_ADDRESS_INFO is also returned. If AddressList is NULL, 21 only the address count is returned. 22 23 @param[in] IpSb The IP6 service binding instance. 24 @param[out] AddressCount The number of returned addresses. 25 @param[out] AddressList The pointer to the array of EFI_IP6_ADDRESS_INFO. 26 This is an optional parameter. 27 28 29 @retval EFI_SUCCESS The address array successfully built. 30 @retval EFI_OUT_OF_RESOURCES Failed to allocate the memory for the address info. 31 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 32 33 **/ 34 EFI_STATUS 35 Ip6BuildEfiAddressList ( 36 IN IP6_SERVICE *IpSb, 37 OUT UINT32 *AddressCount, 38 OUT EFI_IP6_ADDRESS_INFO **AddressList OPTIONAL 39 ) 40 { 41 UINT32 Count; 42 LIST_ENTRY *Entry; 43 EFI_IP6_ADDRESS_INFO *EfiAddrInfo; 44 IP6_ADDRESS_INFO *AddrInfo; 45 46 if (AddressCount == NULL) { 47 return EFI_INVALID_PARAMETER; 48 } 49 50 if (IpSb->LinkLocalOk) { 51 Count = 1 + IpSb->DefaultInterface->AddressCount; 52 } else { 53 Count = 0; 54 } 55 56 *AddressCount = Count; 57 58 if ((AddressList == NULL) || (Count == 0)) { 59 return EFI_SUCCESS; 60 } 61 62 if (*AddressList == NULL) { 63 *AddressList = AllocatePool (sizeof (EFI_IP6_ADDRESS_INFO) * Count); 64 if (*AddressList == NULL) { 65 return EFI_OUT_OF_RESOURCES; 66 } 67 } 68 69 EfiAddrInfo = *AddressList; 70 71 IP6_COPY_ADDRESS (&EfiAddrInfo->Address, &IpSb->LinkLocalAddr); 72 EfiAddrInfo->PrefixLength = IP6_LINK_LOCAL_PREFIX_LENGTH; 73 74 EfiAddrInfo++; 75 Count = 1; 76 77 NET_LIST_FOR_EACH (Entry, &IpSb->DefaultInterface->AddressList) { 78 AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE); 79 80 IP6_COPY_ADDRESS (&EfiAddrInfo->Address, &AddrInfo->Address); 81 EfiAddrInfo->PrefixLength = AddrInfo->PrefixLength; 82 83 EfiAddrInfo++; 84 Count++; 85 } 86 87 ASSERT (Count == *AddressCount); 88 89 return EFI_SUCCESS; 90 } 91 92 /** 93 Generate the multicast addresses identify the group of all IPv6 nodes or IPv6 94 routers defined in RFC4291. 95 96 All Nodes Addresses: FF01::1, FF02::1. 97 All Router Addresses: FF01::2, FF02::2, FF05::2. 98 99 @param[in] Router If TRUE, generate all routers addresses, 100 else generate all node addresses. 101 @param[in] Scope interface-local(1), link-local(2), or site-local(5) 102 @param[out] Ip6Addr The generated multicast address. 103 104 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 105 @retval EFI_SUCCESS The address is generated. 106 107 **/ 108 EFI_STATUS 109 Ip6SetToAllNodeMulticast ( 110 IN BOOLEAN Router, 111 IN UINT8 Scope, 112 OUT EFI_IPv6_ADDRESS *Ip6Addr 113 ) 114 { 115 if (Ip6Addr == NULL) { 116 return EFI_INVALID_PARAMETER; 117 } 118 119 if (!Router && Scope == IP6_SITE_LOCAL_SCOPE) { 120 return EFI_INVALID_PARAMETER; 121 } 122 123 ZeroMem (Ip6Addr, sizeof (EFI_IPv6_ADDRESS)); 124 Ip6Addr->Addr[0] = 0xFF; 125 Ip6Addr->Addr[1] = Scope; 126 127 if (!Router) { 128 Ip6Addr->Addr[15] = 0x1; 129 } else { 130 Ip6Addr->Addr[15] = 0x2; 131 } 132 133 return EFI_SUCCESS; 134 } 135 136 /** 137 This function converts MAC address to 64 bits interface ID according to RFC4291 138 and returns the interface ID. Currently only 48-bit MAC address is supported by 139 this function. 140 141 @param[in, out] IpSb The IP6 service binding instance. 142 143 @retval NULL The operation fails. 144 @return Pointer to the generated interface ID. 145 146 **/ 147 UINT8 * 148 Ip6CreateInterfaceID ( 149 IN OUT IP6_SERVICE *IpSb 150 ) 151 { 152 UINT8 InterfaceId[8]; 153 UINT8 Byte; 154 EFI_MAC_ADDRESS *MacAddr; 155 UINT32 AddrLen; 156 157 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE); 158 159 AddrLen = IpSb->SnpMode.HwAddressSize; 160 161 // 162 // Currently only IEEE 802 48-bit MACs are supported to create link local address. 163 // 164 if (AddrLen != IP6_MAC_LEN || IpSb->InterfaceIdLen != IP6_IF_ID_LEN) { 165 return NULL; 166 } 167 168 MacAddr = &IpSb->SnpMode.CurrentAddress; 169 170 // 171 // Convert MAC address to 64 bits interface ID according to Appendix A of RFC4291: 172 // 1. Insert 0xFFFE to the middle 173 // 2. Invert the universal/local bit - bit 6 in network order 174 // 175 CopyMem (InterfaceId, MacAddr, 3); 176 InterfaceId[3] = 0xFF; 177 InterfaceId[4] = 0xFE; 178 CopyMem (&InterfaceId[5], &MacAddr->Addr[3], 3); 179 180 Byte = (UINT8) (InterfaceId[0] & IP6_U_BIT); 181 if (Byte == IP6_U_BIT) { 182 InterfaceId[0] &= ~IP6_U_BIT; 183 } else { 184 InterfaceId[0] |= IP6_U_BIT; 185 } 186 187 // 188 // Return the interface ID. 189 // 190 return AllocateCopyPool (IpSb->InterfaceIdLen, InterfaceId); 191 } 192 193 /** 194 This function creates link-local address from interface identifier. The 195 interface identifier is normally created from MAC address. It might be manually 196 configured by administrator if the link-local address created from MAC address 197 is a duplicate address. 198 199 @param[in, out] IpSb The IP6 service binding instance. 200 201 @retval NULL If the operation fails. 202 @return The generated Link Local address, in network order. 203 204 **/ 205 EFI_IPv6_ADDRESS * 206 Ip6CreateLinkLocalAddr ( 207 IN OUT IP6_SERVICE *IpSb 208 ) 209 { 210 EFI_IPv6_ADDRESS *Ip6Addr; 211 EFI_IP6_CONFIG_PROTOCOL *Ip6Config; 212 UINTN DataSize; 213 EFI_IP6_CONFIG_INTERFACE_ID InterfaceId; 214 EFI_STATUS Status; 215 216 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE); 217 218 if (IpSb->InterfaceId != NULL) { 219 FreePool (IpSb->InterfaceId); 220 } 221 222 // 223 // Get the interface id if it is manully configured. 224 // 225 Ip6Config = &IpSb->Ip6ConfigInstance.Ip6Config; 226 DataSize = sizeof (EFI_IP6_CONFIG_INTERFACE_ID); 227 ZeroMem (&InterfaceId, DataSize); 228 229 Status = Ip6Config->GetData ( 230 Ip6Config, 231 Ip6ConfigDataTypeAltInterfaceId, 232 &DataSize, 233 &InterfaceId 234 ); 235 if (Status == EFI_NOT_FOUND) { 236 // 237 // Since the interface id is not configured, generate the interface id from 238 // MAC address. 239 // 240 IpSb->InterfaceId = Ip6CreateInterfaceID (IpSb); 241 if (IpSb->InterfaceId == NULL) { 242 return NULL; 243 } 244 245 CopyMem (&InterfaceId, IpSb->InterfaceId, IpSb->InterfaceIdLen); 246 // 247 // Record the interface id. 248 // 249 Status = Ip6Config->SetData ( 250 Ip6Config, 251 Ip6ConfigDataTypeAltInterfaceId, 252 DataSize, 253 &InterfaceId 254 ); 255 if (EFI_ERROR (Status)) { 256 FreePool (IpSb->InterfaceId); 257 IpSb->InterfaceId = NULL; 258 return NULL; 259 } 260 } else if (!EFI_ERROR (Status)) { 261 IpSb->InterfaceId = AllocateCopyPool (DataSize, &InterfaceId); 262 if (IpSb->InterfaceId == NULL) { 263 return NULL; 264 } 265 } else { 266 return NULL; 267 } 268 269 // 270 // Append FE80::/64 to the left of IPv6 address then return. 271 // 272 Ip6Addr = AllocateZeroPool (sizeof (EFI_IPv6_ADDRESS)); 273 if (Ip6Addr == NULL) { 274 FreePool (IpSb->InterfaceId); 275 IpSb->InterfaceId = NULL; 276 return NULL; 277 } 278 279 CopyMem (&Ip6Addr->Addr[8], IpSb->InterfaceId, IpSb->InterfaceIdLen); 280 Ip6Addr->Addr[1] = 0x80; 281 Ip6Addr->Addr[0] = 0xFE; 282 283 return Ip6Addr; 284 } 285 286 /** 287 Compute the solicited-node multicast address for an unicast or anycast address, 288 by taking the low-order 24 bits of this address, and appending those bits to 289 the prefix FF02:0:0:0:0:1:FF00::/104. 290 291 @param[in] Ip6Addr The unicast or anycast address, in network order. 292 @param[out] MulticastAddr The generated solicited-node multicast address, 293 in network order. 294 295 **/ 296 VOID 297 Ip6CreateSNMulticastAddr ( 298 IN EFI_IPv6_ADDRESS *Ip6Addr, 299 OUT EFI_IPv6_ADDRESS *MulticastAddr 300 ) 301 { 302 ASSERT (Ip6Addr != NULL && MulticastAddr != NULL); 303 304 ZeroMem (MulticastAddr, sizeof (EFI_IPv6_ADDRESS)); 305 306 MulticastAddr->Addr[0] = 0xFF; 307 MulticastAddr->Addr[1] = 0x02; 308 MulticastAddr->Addr[11] = 0x1; 309 MulticastAddr->Addr[12] = 0xFF; 310 311 CopyMem (&MulticastAddr->Addr[13], &Ip6Addr->Addr[13], 3); 312 } 313 314 /** 315 Insert a node IP6_ADDRESS_INFO to an IP6 interface. 316 317 @param[in, out] IpIf Points to an IP6 interface. 318 @param[in] AddrInfo Points to IP6_ADDRESS_INFO 319 320 **/ 321 VOID 322 Ip6AddAddr ( 323 IN OUT IP6_INTERFACE *IpIf, 324 IN IP6_ADDRESS_INFO *AddrInfo 325 ) 326 { 327 InsertHeadList (&IpIf->AddressList, &AddrInfo->Link); 328 IpIf->AddressCount++; 329 } 330 331 /** 332 Callback function which provided by user to remove one node in NetDestroyLinkList process. 333 334 @param[in] Entry The entry to be removed. 335 @param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList. 336 337 @retval EFI_SUCCESS The entry has been removed successfully. 338 @retval Others Fail to remove the entry. 339 340 **/ 341 EFI_STATUS 342 EFIAPI 343 Ip6DestroyChildEntryByAddr ( 344 IN LIST_ENTRY *Entry, 345 IN VOID *Context 346 ) 347 { 348 IP6_PROTOCOL *Instance; 349 EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding; 350 EFI_IPv6_ADDRESS *Address; 351 352 Instance = NET_LIST_USER_STRUCT_S (Entry, IP6_PROTOCOL, Link, IP6_PROTOCOL_SIGNATURE); 353 ServiceBinding = ((IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT*) Context)->ServiceBinding; 354 Address = ((IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT*) Context)->Address; 355 356 if ((Instance->State == IP6_STATE_CONFIGED) && EFI_IP6_EQUAL (&Instance->ConfigData.StationAddress, Address)) { 357 return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle); 358 } 359 360 return EFI_SUCCESS; 361 } 362 363 /** 364 Destroy the IP instance if its StationAddress is removed. It is the help function 365 for Ip6RemoveAddr(). 366 367 @param[in, out] IpSb Points to an IP6 service binding instance. 368 @param[in] Address The to be removed address 369 370 **/ 371 VOID 372 Ip6DestroyInstanceByAddress ( 373 IN OUT IP6_SERVICE *IpSb, 374 IN EFI_IPv6_ADDRESS *Address 375 ) 376 { 377 LIST_ENTRY *List; 378 IP6_DESTROY_CHILD_BY_ADDR_CALLBACK_CONTEXT Context; 379 380 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE); 381 382 List = &IpSb->Children; 383 Context.ServiceBinding = &IpSb->ServiceBinding; 384 Context.Address = Address; 385 NetDestroyLinkList ( 386 List, 387 Ip6DestroyChildEntryByAddr, 388 &Context, 389 NULL 390 ); 391 } 392 393 /** 394 Remove the IPv6 address from the address list node points to IP6_ADDRESS_INFO. 395 396 This function removes the matching IPv6 addresses from the address list and 397 adjusts the address count of the address list. If IpSb is not NULL, this function 398 calls Ip6LeaveGroup to see whether it should call Mnp->Groups() to remove the 399 its solicited-node multicast MAC address from the filter list and sends out 400 a Multicast Listener Done. If Prefix is NULL, all address in the address list 401 will be removed. If Prefix is not NULL, the address that matching the Prefix 402 with PrefixLength in the address list will be removed. 403 404 @param[in] IpSb NULL or points to IP6 service binding instance. 405 @param[in, out] AddressList Address list array. 406 @param[in, out] AddressCount The count of addresses in address list array. 407 @param[in] Prefix NULL or an IPv6 address prefix. 408 @param[in] PrefixLength The length of Prefix. 409 410 @retval EFI_SUCCESS The operation completed successfully. 411 @retval EFI_NOT_FOUND The address matching the Prefix with PrefixLength 412 cannot be found in the address list. 413 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 414 415 **/ 416 EFI_STATUS 417 Ip6RemoveAddr ( 418 IN IP6_SERVICE *IpSb OPTIONAL, 419 IN OUT LIST_ENTRY *AddressList, 420 IN OUT UINT32 *AddressCount, 421 IN EFI_IPv6_ADDRESS *Prefix OPTIONAL, 422 IN UINT8 PrefixLength 423 ) 424 { 425 EFI_STATUS Status; 426 LIST_ENTRY *Entry; 427 LIST_ENTRY *Next; 428 IP6_ADDRESS_INFO *AddrInfo; 429 EFI_IPv6_ADDRESS SnMCastAddr; 430 431 if (IsListEmpty (AddressList) || *AddressCount < 1 || PrefixLength > IP6_PREFIX_MAX) { 432 return EFI_INVALID_PARAMETER; 433 } 434 435 Status = EFI_NOT_FOUND; 436 437 NET_LIST_FOR_EACH_SAFE (Entry, Next, AddressList) { 438 AddrInfo = NET_LIST_USER_STRUCT_S (Entry, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE); 439 440 if (Prefix == NULL || 441 (PrefixLength == 128 && EFI_IP6_EQUAL (Prefix, &AddrInfo->Address)) || 442 (PrefixLength == AddrInfo->PrefixLength && NetIp6IsNetEqual (Prefix, &AddrInfo->Address, PrefixLength)) 443 ) { 444 if (IpSb != NULL) { 445 NET_CHECK_SIGNATURE (IpSb, IP6_SERVICE_SIGNATURE); 446 Ip6CreateSNMulticastAddr (&AddrInfo->Address, &SnMCastAddr); 447 Ip6LeaveGroup (IpSb, &SnMCastAddr); 448 449 // 450 // Destroy any instance who is using the dying address as the source address. 451 // 452 Ip6DestroyInstanceByAddress (IpSb, &AddrInfo->Address); 453 } 454 455 RemoveEntryList (Entry); 456 FreePool (AddrInfo); 457 (*AddressCount)--; 458 459 Status = EFI_SUCCESS; 460 } 461 } 462 463 return Status; 464 } 465 466 /** 467 Check whether the incoming Ipv6 address is a solicited-node multicast address. 468 469 @param[in] Ip6 Ip6 address, in network order. 470 471 @retval TRUE Yes, solicited-node multicast address 472 @retval FALSE No 473 474 **/ 475 BOOLEAN 476 Ip6IsSNMulticastAddr ( 477 IN EFI_IPv6_ADDRESS *Ip6 478 ) 479 { 480 EFI_IPv6_ADDRESS Sn; 481 BOOLEAN Flag; 482 483 Ip6CreateSNMulticastAddr (Ip6, &Sn); 484 Flag = FALSE; 485 486 if (CompareMem (Sn.Addr, Ip6->Addr, 13) == 0) { 487 Flag = TRUE; 488 } 489 490 return Flag; 491 } 492 493 /** 494 Check whether the incoming IPv6 address is one of the maintained addresses in 495 the IP6 service binding instance. 496 497 @param[in] IpSb Points to a IP6 service binding instance. 498 @param[in] Address The IP6 address to be checked. 499 @param[out] Interface If not NULL, output the IP6 interface which 500 maintains the Address. 501 @param[out] AddressInfo If not NULL, output the IP6 address information 502 of the Address. 503 504 @retval TRUE Yes, it is one of the maintained address. 505 @retval FALSE No, it is not one of the maintained address. 506 507 **/ 508 BOOLEAN 509 Ip6IsOneOfSetAddress ( 510 IN IP6_SERVICE *IpSb, 511 IN EFI_IPv6_ADDRESS *Address, 512 OUT IP6_INTERFACE **Interface OPTIONAL, 513 OUT IP6_ADDRESS_INFO **AddressInfo OPTIONAL 514 ) 515 { 516 LIST_ENTRY *Entry; 517 LIST_ENTRY *Entry2; 518 IP6_INTERFACE *IpIf; 519 IP6_ADDRESS_INFO *TmpAddressInfo; 520 521 // 522 // Check link-local address first 523 // 524 if (IpSb->LinkLocalOk && EFI_IP6_EQUAL (&IpSb->LinkLocalAddr, Address)) { 525 if (Interface != NULL) { 526 *Interface = IpSb->DefaultInterface; 527 } 528 529 if (AddressInfo != NULL) { 530 *AddressInfo = NULL; 531 } 532 533 return TRUE; 534 } 535 536 NET_LIST_FOR_EACH (Entry, &IpSb->Interfaces) { 537 IpIf = NET_LIST_USER_STRUCT_S (Entry, IP6_INTERFACE, Link, IP6_INTERFACE_SIGNATURE); 538 539 NET_LIST_FOR_EACH (Entry2, &IpIf->AddressList) { 540 TmpAddressInfo = NET_LIST_USER_STRUCT_S (Entry2, IP6_ADDRESS_INFO, Link, IP6_ADDR_INFO_SIGNATURE); 541 542 if (EFI_IP6_EQUAL (&TmpAddressInfo->Address, Address)) { 543 if (Interface != NULL) { 544 *Interface = IpIf; 545 } 546 547 if (AddressInfo != NULL) { 548 *AddressInfo = TmpAddressInfo; 549 } 550 551 return TRUE; 552 } 553 } 554 } 555 556 return FALSE; 557 } 558 559 /** 560 Check whether the incoming MAC address is valid. 561 562 @param[in] IpSb Points to a IP6 service binding instance. 563 @param[in] LinkAddress The MAC address. 564 565 @retval TRUE Yes, it is valid. 566 @retval FALSE No, it is not valid. 567 568 **/ 569 BOOLEAN 570 Ip6IsValidLinkAddress ( 571 IN IP6_SERVICE *IpSb, 572 IN EFI_MAC_ADDRESS *LinkAddress 573 ) 574 { 575 UINT32 Index; 576 577 // 578 // TODO: might be updated later to be more acceptable. 579 // 580 for (Index = IpSb->SnpMode.HwAddressSize; Index < sizeof (EFI_MAC_ADDRESS); Index++) { 581 if (LinkAddress->Addr[Index] != 0) { 582 return FALSE; 583 } 584 } 585 586 return TRUE; 587 } 588 589 /** 590 Copy the PrefixLength bits from Src to Dest. 591 592 @param[out] Dest A pointer to the buffer to copy to. 593 @param[in] Src A pointer to the buffer to copy from. 594 @param[in] PrefixLength The number of bits to copy. 595 596 **/ 597 VOID 598 Ip6CopyAddressByPrefix ( 599 OUT EFI_IPv6_ADDRESS *Dest, 600 IN EFI_IPv6_ADDRESS *Src, 601 IN UINT8 PrefixLength 602 ) 603 { 604 UINT8 Byte; 605 UINT8 Bit; 606 UINT8 Mask; 607 608 ASSERT (Dest != NULL && Src != NULL); 609 ASSERT (PrefixLength <= IP6_PREFIX_MAX); 610 611 Byte = (UINT8) (PrefixLength / 8); 612 Bit = (UINT8) (PrefixLength % 8); 613 614 ZeroMem (Dest, sizeof (EFI_IPv6_ADDRESS)); 615 616 CopyMem (Dest, Src, Byte); 617 618 if (Bit > 0) { 619 Mask = (UINT8) (0xFF << (8 - Bit)); 620 ASSERT (Byte < 16); 621 Dest->Addr[Byte] = (UINT8) (Src->Addr[Byte] & Mask); 622 } 623 } 624 625 /** 626 Get the MAC address for a multicast IP address. Call 627 Mnp's McastIpToMac to find the MAC address instead of 628 hard-coding the NIC to be Ethernet. 629 630 @param[in] Mnp The Mnp instance to get the MAC address. 631 @param[in] Multicast The multicast IP address to translate. 632 @param[out] Mac The buffer to hold the translated address. 633 634 @retval EFI_SUCCESS The multicast IP successfully 635 translated to a multicast MAC address. 636 @retval Other The address is not converted because an error occurred. 637 638 **/ 639 EFI_STATUS 640 Ip6GetMulticastMac ( 641 IN EFI_MANAGED_NETWORK_PROTOCOL *Mnp, 642 IN EFI_IPv6_ADDRESS *Multicast, 643 OUT EFI_MAC_ADDRESS *Mac 644 ) 645 { 646 EFI_IP_ADDRESS EfiIp; 647 648 IP6_COPY_ADDRESS (&EfiIp.v6, Multicast); 649 650 return Mnp->McastIpToMac (Mnp, TRUE, &EfiIp, Mac); 651 } 652 653 /** 654 Convert the multibyte field in IP header's byter order. 655 In spite of its name, it can also be used to convert from 656 host to network byte order. 657 658 @param[in, out] Head The IP head to convert. 659 660 @return Point to the converted IP head. 661 662 **/ 663 EFI_IP6_HEADER * 664 Ip6NtohHead ( 665 IN OUT EFI_IP6_HEADER *Head 666 ) 667 { 668 Head->FlowLabelL = NTOHS (Head->FlowLabelL); 669 Head->PayloadLength = NTOHS (Head->PayloadLength); 670 671 return Head; 672 } 673 674