1 /** @file 2 This library is only intended to be used by UEFI network stack modules. 3 It provides basic functions for the UEFI network stack. 4 5 Copyright (c) 2005 - 2016, Intel Corporation. All rights reserved.<BR> 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<BR> 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 #ifndef _NET_LIB_H_ 17 #define _NET_LIB_H_ 18 19 #include <Protocol/Ip6.h> 20 21 #include <Library/BaseLib.h> 22 #include <Library/BaseMemoryLib.h> 23 24 typedef UINT32 IP4_ADDR; 25 typedef UINT32 TCP_SEQNO; 26 typedef UINT16 TCP_PORTNO; 27 28 29 #define NET_ETHER_ADDR_LEN 6 30 #define NET_IFTYPE_ETHERNET 0x01 31 32 #define NET_VLAN_TAG_LEN 4 33 #define ETHER_TYPE_VLAN 0x8100 34 35 #define EFI_IP_PROTO_UDP 0x11 36 #define EFI_IP_PROTO_TCP 0x06 37 #define EFI_IP_PROTO_ICMP 0x01 38 #define IP4_PROTO_IGMP 0x02 39 #define IP6_ICMP 58 40 #define DNS_MAX_NAME_SIZE 255 41 #define DNS_MAX_MESSAGE_SIZE 512 42 43 // 44 // The address classification 45 // 46 #define IP4_ADDR_CLASSA 1 // Deprecated 47 #define IP4_ADDR_CLASSB 2 // Deprecated 48 #define IP4_ADDR_CLASSC 3 // Deprecated 49 #define IP4_ADDR_CLASSD 4 50 #define IP4_ADDR_CLASSE 5 51 52 #define IP4_MASK_NUM 33 53 #define IP6_PREFIX_NUM 129 54 55 #define IP4_MASK_MAX 32 56 #define IP6_PREFIX_MAX 128 57 58 #define IP6_HOP_BY_HOP 0 59 #define IP6_DESTINATION 60 60 #define IP6_ROUTING 43 61 #define IP6_FRAGMENT 44 62 #define IP6_AH 51 63 #define IP6_ESP 50 64 #define IP6_NO_NEXT_HEADER 59 65 66 #define IP_VERSION_4 4 67 #define IP_VERSION_6 6 68 69 #define IP6_PREFIX_LENGTH 64 70 71 // 72 // DNS QTYPE values 73 // 74 #define DNS_TYPE_A 1 75 #define DNS_TYPE_NS 2 76 #define DNS_TYPE_CNAME 5 77 #define DNS_TYPE_SOA 6 78 #define DNS_TYPE_WKS 11 79 #define DNS_TYPE_PTR 12 80 #define DNS_TYPE_HINFO 13 81 #define DNS_TYPE_MINFO 14 82 #define DNS_TYPE_MX 15 83 #define DNS_TYPE_TXT 16 84 #define DNS_TYPE_AAAA 28 85 #define DNS_TYPE_SRV_RR 33 86 #define DNS_TYPE_AXFR 252 87 #define DNS_TYPE_MAILB 253 88 #define DNS_TYPE_ANY 255 89 90 // 91 // DNS QCLASS values 92 // 93 #define DNS_CLASS_INET 1 94 #define DNS_CLASS_CH 3 95 #define DNS_CLASS_HS 4 96 #define DNS_CLASS_ANY 255 97 98 #pragma pack(1) 99 100 // 101 // Ethernet head definition 102 // 103 typedef struct { 104 UINT8 DstMac [NET_ETHER_ADDR_LEN]; 105 UINT8 SrcMac [NET_ETHER_ADDR_LEN]; 106 UINT16 EtherType; 107 } ETHER_HEAD; 108 109 // 110 // 802.1Q VLAN Tag Control Information 111 // 112 typedef union { 113 struct { 114 UINT16 Vid : 12; // Unique VLAN identifier (0 to 4094) 115 UINT16 Cfi : 1; // Canonical Format Indicator 116 UINT16 Priority : 3; // 802.1Q priority level (0 to 7) 117 } Bits; 118 UINT16 Uint16; 119 } VLAN_TCI; 120 121 #define VLAN_TCI_CFI_CANONICAL_MAC 0 122 #define VLAN_TCI_CFI_NON_CANONICAL_MAC 1 123 124 // 125 // The EFI_IP4_HEADER is hard to use because the source and 126 // destination address are defined as EFI_IPv4_ADDRESS, which 127 // is a structure. Two structures can't be compared or masked 128 // directly. This is why there is an internal representation. 129 // 130 typedef struct { 131 UINT8 HeadLen : 4; 132 UINT8 Ver : 4; 133 UINT8 Tos; 134 UINT16 TotalLen; 135 UINT16 Id; 136 UINT16 Fragment; 137 UINT8 Ttl; 138 UINT8 Protocol; 139 UINT16 Checksum; 140 IP4_ADDR Src; 141 IP4_ADDR Dst; 142 } IP4_HEAD; 143 144 145 // 146 // ICMP head definition. Each ICMP message is categorized as either an error 147 // message or query message. Two message types have their own head format. 148 // 149 typedef struct { 150 UINT8 Type; 151 UINT8 Code; 152 UINT16 Checksum; 153 } IP4_ICMP_HEAD; 154 155 typedef struct { 156 IP4_ICMP_HEAD Head; 157 UINT32 Fourth; // 4th filed of the head, it depends on Type. 158 IP4_HEAD IpHead; 159 } IP4_ICMP_ERROR_HEAD; 160 161 typedef struct { 162 IP4_ICMP_HEAD Head; 163 UINT16 Id; 164 UINT16 Seq; 165 } IP4_ICMP_QUERY_HEAD; 166 167 typedef struct { 168 UINT8 Type; 169 UINT8 Code; 170 UINT16 Checksum; 171 } IP6_ICMP_HEAD; 172 173 typedef struct { 174 IP6_ICMP_HEAD Head; 175 UINT32 Fourth; 176 EFI_IP6_HEADER IpHead; 177 } IP6_ICMP_ERROR_HEAD; 178 179 typedef struct { 180 IP6_ICMP_HEAD Head; 181 UINT32 Fourth; 182 } IP6_ICMP_INFORMATION_HEAD; 183 184 // 185 // UDP header definition 186 // 187 typedef struct { 188 UINT16 SrcPort; 189 UINT16 DstPort; 190 UINT16 Length; 191 UINT16 Checksum; 192 } EFI_UDP_HEADER; 193 194 // 195 // TCP header definition 196 // 197 typedef struct { 198 TCP_PORTNO SrcPort; 199 TCP_PORTNO DstPort; 200 TCP_SEQNO Seq; 201 TCP_SEQNO Ack; 202 UINT8 Res : 4; 203 UINT8 HeadLen : 4; 204 UINT8 Flag; 205 UINT16 Wnd; 206 UINT16 Checksum; 207 UINT16 Urg; 208 } TCP_HEAD; 209 210 #pragma pack() 211 212 #define NET_MAC_EQUAL(pMac1, pMac2, Len) \ 213 (CompareMem ((pMac1), (pMac2), Len) == 0) 214 215 #define NET_MAC_IS_MULTICAST(Mac, BMac, Len) \ 216 (((*((UINT8 *) Mac) & 0x01) == 0x01) && (!NET_MAC_EQUAL (Mac, BMac, Len))) 217 218 #define NTOHL(x) SwapBytes32 (x) 219 220 #define HTONL(x) NTOHL(x) 221 222 #define NTOHS(x) SwapBytes16 (x) 223 224 #define HTONS(x) NTOHS(x) 225 #define NTOHLL(x) SwapBytes64 (x) 226 #define HTONLL(x) NTOHLL(x) 227 #define NTOHLLL(x) Ip6Swap128 (x) 228 #define HTONLLL(x) NTOHLLL(x) 229 230 // 231 // Test the IP's attribute, All the IPs are in host byte order. 232 // 233 #define IP4_IS_MULTICAST(Ip) (((Ip) & 0xF0000000) == 0xE0000000) 234 #define IP4_IS_UNSPECIFIED(Ip) ((Ip) == 0) 235 #define IP4_IS_LOCAL_BROADCAST(Ip) ((Ip) == 0xFFFFFFFF) 236 #define IP4_NET_EQUAL(Ip1, Ip2, NetMask) (((Ip1) & (NetMask)) == ((Ip2) & (NetMask))) 237 #define IP4_IS_VALID_NETMASK(Ip) (NetGetMaskLength (Ip) != (IP4_MASK_MAX + 1)) 238 239 #define IP6_IS_MULTICAST(Ip6) (((Ip6)->Addr[0]) == 0xFF) 240 241 // 242 // Convert the EFI_IP4_ADDRESS to plain UINT32 IP4 address. 243 // 244 #define EFI_IP4(EfiIpAddr) (*(IP4_ADDR *) ((EfiIpAddr).Addr)) 245 #define EFI_NTOHL(EfiIp) (NTOHL (EFI_IP4 ((EfiIp)))) 246 #define EFI_IP4_EQUAL(Ip1, Ip2) (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv4_ADDRESS)) == 0) 247 248 #define EFI_IP6_EQUAL(Ip1, Ip2) (CompareMem ((Ip1), (Ip2), sizeof (EFI_IPv6_ADDRESS)) == 0) 249 250 #define IP4_COPY_ADDRESS(Dest, Src) (CopyMem ((Dest), (Src), sizeof (EFI_IPv4_ADDRESS))) 251 #define IP6_COPY_ADDRESS(Dest, Src) (CopyMem ((Dest), (Src), sizeof (EFI_IPv6_ADDRESS))) 252 #define IP6_COPY_LINK_ADDRESS(Mac1, Mac2) (CopyMem ((Mac1), (Mac2), sizeof (EFI_MAC_ADDRESS))) 253 254 // 255 // The debug level definition. This value is also used as the 256 // syslog's severity level. Don't change it. 257 // 258 #define NETDEBUG_LEVEL_TRACE 5 259 #define NETDEBUG_LEVEL_WARNING 4 260 #define NETDEBUG_LEVEL_ERROR 3 261 262 // 263 // Network debug message is sent out as syslog packet. 264 // 265 #define NET_SYSLOG_FACILITY 16 // Syslog local facility local use 266 #define NET_SYSLOG_PACKET_LEN 512 267 #define NET_SYSLOG_TX_TIMEOUT (500 * 1000 * 10) // 500ms 268 #define NET_DEBUG_MSG_LEN 470 // 512 - (ether+ip4+udp4 head length) 269 270 // 271 // The debug output expects the ASCII format string, Use %a to print ASCII 272 // string, and %s to print UNICODE string. PrintArg must be enclosed in (). 273 // For example: NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name)); 274 // 275 #define NET_DEBUG_TRACE(Module, PrintArg) \ 276 NetDebugOutput ( \ 277 NETDEBUG_LEVEL_TRACE, \ 278 Module, \ 279 __FILE__, \ 280 __LINE__, \ 281 NetDebugASPrint PrintArg \ 282 ) 283 284 #define NET_DEBUG_WARNING(Module, PrintArg) \ 285 NetDebugOutput ( \ 286 NETDEBUG_LEVEL_WARNING, \ 287 Module, \ 288 __FILE__, \ 289 __LINE__, \ 290 NetDebugASPrint PrintArg \ 291 ) 292 293 #define NET_DEBUG_ERROR(Module, PrintArg) \ 294 NetDebugOutput ( \ 295 NETDEBUG_LEVEL_ERROR, \ 296 Module, \ 297 __FILE__, \ 298 __LINE__, \ 299 NetDebugASPrint PrintArg \ 300 ) 301 302 /** 303 Allocate a buffer, then format the message to it. This is a 304 help function for the NET_DEBUG_XXX macros. The PrintArg of 305 these macros treats the variable length print parameters as a 306 single parameter, and pass it to the NetDebugASPrint. For 307 example, NET_DEBUG_TRACE ("Tcp", ("State transit to %a\n", Name)) 308 if extracted to: 309 310 NetDebugOutput ( 311 NETDEBUG_LEVEL_TRACE, 312 "Tcp", 313 __FILE__, 314 __LINE__, 315 NetDebugASPrint ("State transit to %a\n", Name) 316 ) 317 318 @param Format The ASCII format string. 319 @param ... The variable length parameter whose format is determined 320 by the Format string. 321 322 @return The buffer containing the formatted message, 323 or NULL if memory allocation failed. 324 325 **/ 326 CHAR8 * 327 EFIAPI 328 NetDebugASPrint ( 329 IN CHAR8 *Format, 330 ... 331 ); 332 333 /** 334 Builds an UDP4 syslog packet and send it using SNP. 335 336 This function will locate a instance of SNP then send the message through it. 337 Because it isn't open the SNP BY_DRIVER, apply caution when using it. 338 339 @param Level The severity level of the message. 340 @param Module The Module that generates the log. 341 @param File The file that contains the log. 342 @param Line The exact line that contains the log. 343 @param Message The user message to log. 344 345 @retval EFI_INVALID_PARAMETER Any input parameter is invalid. 346 @retval EFI_OUT_OF_RESOURCES Failed to allocate memory for the packet 347 @retval EFI_SUCCESS The log is discard because that it is more verbose 348 than the mNetDebugLevelMax. Or, it has been sent out. 349 **/ 350 EFI_STATUS 351 EFIAPI 352 NetDebugOutput ( 353 IN UINT32 Level, 354 IN UINT8 *Module, 355 IN UINT8 *File, 356 IN UINT32 Line, 357 IN UINT8 *Message 358 ); 359 360 361 /** 362 Return the length of the mask. 363 364 Return the length of the mask. Valid values are 0 to 32. 365 If the mask is invalid, return the invalid length 33, which is IP4_MASK_NUM. 366 NetMask is in the host byte order. 367 368 @param[in] NetMask The netmask to get the length from. 369 370 @return The length of the netmask, or IP4_MASK_NUM (33) if the mask is invalid. 371 372 **/ 373 INTN 374 EFIAPI 375 NetGetMaskLength ( 376 IN IP4_ADDR NetMask 377 ); 378 379 /** 380 Return the class of the IP address, such as class A, B, C. 381 Addr is in host byte order. 382 383 [ATTENTION] 384 Classful addressing (IP class A/B/C) has been deprecated according to RFC4632. 385 Caller of this function could only check the returned value against 386 IP4_ADDR_CLASSD (multicast) or IP4_ADDR_CLASSE (reserved) now. 387 388 The address of class A starts with 0. 389 If the address belong to class A, return IP4_ADDR_CLASSA. 390 The address of class B starts with 10. 391 If the address belong to class B, return IP4_ADDR_CLASSB. 392 The address of class C starts with 110. 393 If the address belong to class C, return IP4_ADDR_CLASSC. 394 The address of class D starts with 1110. 395 If the address belong to class D, return IP4_ADDR_CLASSD. 396 The address of class E starts with 1111. 397 If the address belong to class E, return IP4_ADDR_CLASSE. 398 399 400 @param[in] Addr The address to get the class from. 401 402 @return IP address class, such as IP4_ADDR_CLASSA. 403 404 **/ 405 INTN 406 EFIAPI 407 NetGetIpClass ( 408 IN IP4_ADDR Addr 409 ); 410 411 /** 412 Check whether the IP is a valid unicast address according to 413 the netmask. 414 415 ASSERT if NetMask is zero. 416 417 If all bits of the host address of IP are 0 or 1, IP is also not a valid unicast address. 418 419 @param[in] Ip The IP to check against. 420 @param[in] NetMask The mask of the IP. 421 422 @return TRUE if IP is a valid unicast address on the network, otherwise FALSE. 423 424 **/ 425 BOOLEAN 426 EFIAPI 427 NetIp4IsUnicast ( 428 IN IP4_ADDR Ip, 429 IN IP4_ADDR NetMask 430 ); 431 432 /** 433 Check whether the incoming IPv6 address is a valid unicast address. 434 435 If the address is a multicast address has binary 0xFF at the start, it is not 436 a valid unicast address. If the address is unspecified ::, it is not a valid 437 unicast address to be assigned to any node. If the address is loopback address 438 ::1, it is also not a valid unicast address to be assigned to any physical 439 interface. 440 441 @param[in] Ip6 The IPv6 address to check against. 442 443 @return TRUE if Ip6 is a valid unicast address on the network, otherwise FALSE. 444 445 **/ 446 BOOLEAN 447 EFIAPI 448 NetIp6IsValidUnicast ( 449 IN EFI_IPv6_ADDRESS *Ip6 450 ); 451 452 453 /** 454 Check whether the incoming Ipv6 address is the unspecified address or not. 455 456 @param[in] Ip6 - Ip6 address, in network order. 457 458 @retval TRUE - Yes, incoming Ipv6 address is the unspecified address. 459 @retval FALSE - The incoming Ipv6 address is not the unspecified address 460 461 **/ 462 BOOLEAN 463 EFIAPI 464 NetIp6IsUnspecifiedAddr ( 465 IN EFI_IPv6_ADDRESS *Ip6 466 ); 467 468 /** 469 Check whether the incoming Ipv6 address is a link-local address. 470 471 @param[in] Ip6 - Ip6 address, in network order. 472 473 @retval TRUE - The incoming Ipv6 address is a link-local address. 474 @retval FALSE - The incoming Ipv6 address is not a link-local address. 475 476 **/ 477 BOOLEAN 478 EFIAPI 479 NetIp6IsLinkLocalAddr ( 480 IN EFI_IPv6_ADDRESS *Ip6 481 ); 482 483 /** 484 Check whether the Ipv6 address1 and address2 are on the connected network. 485 486 @param[in] Ip1 - Ip6 address1, in network order. 487 @param[in] Ip2 - Ip6 address2, in network order. 488 @param[in] PrefixLength - The prefix length of the checking net. 489 490 @retval TRUE - Yes, the Ipv6 address1 and address2 are connected. 491 @retval FALSE - No the Ipv6 address1 and address2 are not connected. 492 493 **/ 494 BOOLEAN 495 EFIAPI 496 NetIp6IsNetEqual ( 497 EFI_IPv6_ADDRESS *Ip1, 498 EFI_IPv6_ADDRESS *Ip2, 499 UINT8 PrefixLength 500 ); 501 502 /** 503 Switches the endianess of an IPv6 address. 504 505 This function swaps the bytes in a 128-bit IPv6 address to switch the value 506 from little endian to big endian or vice versa. The byte swapped value is 507 returned. 508 509 @param Ip6 Points to an IPv6 address. 510 511 @return The byte swapped IPv6 address. 512 513 **/ 514 EFI_IPv6_ADDRESS * 515 EFIAPI 516 Ip6Swap128 ( 517 EFI_IPv6_ADDRESS *Ip6 518 ); 519 520 extern IP4_ADDR gIp4AllMasks[IP4_MASK_NUM]; 521 522 523 extern EFI_IPv4_ADDRESS mZeroIp4Addr; 524 525 #define NET_IS_DIGIT(Ch) (('0' <= (Ch)) && ((Ch) <= '9')) 526 #define NET_IS_HEX(Ch) ((('0' <= (Ch)) && ((Ch) <= '9')) || (('A' <= (Ch)) && ((Ch) <= 'F')) || (('a' <= (Ch)) && ((Ch) <= 'f'))) 527 #define NET_ROUNDUP(size, unit) (((size) + (unit) - 1) & (~((unit) - 1))) 528 #define NET_IS_LOWER_CASE_CHAR(Ch) (('a' <= (Ch)) && ((Ch) <= 'z')) 529 #define NET_IS_UPPER_CASE_CHAR(Ch) (('A' <= (Ch)) && ((Ch) <= 'Z')) 530 531 #define TICKS_PER_MS 10000U 532 #define TICKS_PER_SECOND 10000000U 533 534 #define NET_RANDOM(Seed) ((UINT32) ((UINT32) (Seed) * 1103515245UL + 12345) % 4294967295UL) 535 536 /** 537 Extract a UINT32 from a byte stream. 538 539 This function copies a UINT32 from a byte stream, and then converts it from Network 540 byte order to host byte order. Use this function to avoid alignment error. 541 542 @param[in] Buf The buffer to extract the UINT32. 543 544 @return The UINT32 extracted. 545 546 **/ 547 UINT32 548 EFIAPI 549 NetGetUint32 ( 550 IN UINT8 *Buf 551 ); 552 553 /** 554 Puts a UINT32 into the byte stream in network byte order. 555 556 Converts a UINT32 from host byte order to network byte order, then copies it to the 557 byte stream. 558 559 @param[in, out] Buf The buffer in which to put the UINT32. 560 @param[in] Data The data to be converted and put into the byte stream. 561 562 **/ 563 VOID 564 EFIAPI 565 NetPutUint32 ( 566 IN OUT UINT8 *Buf, 567 IN UINT32 Data 568 ); 569 570 /** 571 Initialize a random seed using current time and monotonic count. 572 573 Get current time and monotonic count first. Then initialize a random seed 574 based on some basic mathematics operation on the hour, day, minute, second, 575 nanosecond and year of the current time and the monotonic count value. 576 577 @return The random seed initialized with current time. 578 579 **/ 580 UINT32 581 EFIAPI 582 NetRandomInitSeed ( 583 VOID 584 ); 585 586 587 #define NET_LIST_USER_STRUCT(Entry, Type, Field) \ 588 BASE_CR(Entry, Type, Field) 589 590 #define NET_LIST_USER_STRUCT_S(Entry, Type, Field, Sig) \ 591 CR(Entry, Type, Field, Sig) 592 593 // 594 // Iterate through the double linked list. It is NOT delete safe 595 // 596 #define NET_LIST_FOR_EACH(Entry, ListHead) \ 597 for(Entry = (ListHead)->ForwardLink; Entry != (ListHead); Entry = Entry->ForwardLink) 598 599 // 600 // Iterate through the double linked list. This is delete-safe. 601 // Don't touch NextEntry. Also, don't use this macro if list 602 // entries other than the Entry may be deleted when processing 603 // the current Entry. 604 // 605 #define NET_LIST_FOR_EACH_SAFE(Entry, NextEntry, ListHead) \ 606 for(Entry = (ListHead)->ForwardLink, NextEntry = Entry->ForwardLink; \ 607 Entry != (ListHead); \ 608 Entry = NextEntry, NextEntry = Entry->ForwardLink \ 609 ) 610 611 // 612 // Make sure the list isn't empty before getting the first/last record. 613 // 614 #define NET_LIST_HEAD(ListHead, Type, Field) \ 615 NET_LIST_USER_STRUCT((ListHead)->ForwardLink, Type, Field) 616 617 #define NET_LIST_TAIL(ListHead, Type, Field) \ 618 NET_LIST_USER_STRUCT((ListHead)->BackLink, Type, Field) 619 620 621 /** 622 Remove the first node entry on the list, and return the removed node entry. 623 624 Removes the first node entry from a doubly linked list. It is up to the caller of 625 this function to release the memory used by the first node, if that is required. On 626 exit, the removed node is returned. 627 628 If Head is NULL, then ASSERT(). 629 If Head was not initialized, then ASSERT(). 630 If PcdMaximumLinkedListLength is not zero, and the number of nodes in the 631 linked list including the head node is greater than or equal to PcdMaximumLinkedListLength, 632 then ASSERT(). 633 634 @param[in, out] Head The list header. 635 636 @return The first node entry that is removed from the list, NULL if the list is empty. 637 638 **/ 639 LIST_ENTRY * 640 EFIAPI 641 NetListRemoveHead ( 642 IN OUT LIST_ENTRY *Head 643 ); 644 645 /** 646 Remove the last node entry on the list and return the removed node entry. 647 648 Removes the last node entry from a doubly linked list. It is up to the caller of 649 this function to release the memory used by the first node, if that is required. On 650 exit, the removed node is returned. 651 652 If Head is NULL, then ASSERT(). 653 If Head was not initialized, then ASSERT(). 654 If PcdMaximumLinkedListLength is not zero, and the number of nodes in the 655 linked list including the head node is greater than or equal to PcdMaximumLinkedListLength, 656 then ASSERT(). 657 658 @param[in, out] Head The list head. 659 660 @return The last node entry that is removed from the list, NULL if the list is empty. 661 662 **/ 663 LIST_ENTRY * 664 EFIAPI 665 NetListRemoveTail ( 666 IN OUT LIST_ENTRY *Head 667 ); 668 669 /** 670 Insert a new node entry after a designated node entry of a doubly linked list. 671 672 Inserts a new node entry designated by NewEntry after the node entry designated by PrevEntry 673 of the doubly linked list. 674 675 @param[in, out] PrevEntry The entry after which to insert. 676 @param[in, out] NewEntry The new entry to insert. 677 678 **/ 679 VOID 680 EFIAPI 681 NetListInsertAfter ( 682 IN OUT LIST_ENTRY *PrevEntry, 683 IN OUT LIST_ENTRY *NewEntry 684 ); 685 686 /** 687 Insert a new node entry before a designated node entry of a doubly linked list. 688 689 Inserts a new node entry designated by NewEntry before the node entry designated by PostEntry 690 of the doubly linked list. 691 692 @param[in, out] PostEntry The entry to insert before. 693 @param[in, out] NewEntry The new entry to insert. 694 695 **/ 696 VOID 697 EFIAPI 698 NetListInsertBefore ( 699 IN OUT LIST_ENTRY *PostEntry, 700 IN OUT LIST_ENTRY *NewEntry 701 ); 702 703 /** 704 Callback function which provided by user to remove one node in NetDestroyLinkList process. 705 706 @param[in] Entry The entry to be removed. 707 @param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList. 708 709 @retval EFI_SUCCESS The entry has been removed successfully. 710 @retval Others Fail to remove the entry. 711 712 **/ 713 typedef 714 EFI_STATUS 715 (EFIAPI *NET_DESTROY_LINK_LIST_CALLBACK) ( 716 IN LIST_ENTRY *Entry, 717 IN VOID *Context OPTIONAL 718 ); 719 720 /** 721 Safe destroy nodes in a linked list, and return the length of the list after all possible operations finished. 722 723 Destroy network children list by list traversals is not safe due to graph dependencies between nodes. 724 This function performs a safe traversal to destroy these nodes by checking to see if the node being destroyed 725 has been removed from the list or not. 726 If it has been removed, then restart the traversal from the head. 727 If it hasn't been removed, then continue with the next node directly. 728 This function will end the iterate and return the CallBack's last return value if error happens, 729 or retrun EFI_SUCCESS if 2 complete passes are made with no changes in the number of children in the list. 730 731 @param[in] List The head of the list. 732 @param[in] CallBack Pointer to the callback function to destroy one node in the list. 733 @param[in] Context Pointer to the callback function's context: corresponds to the 734 parameter Context in NET_DESTROY_LINK_LIST_CALLBACK. 735 @param[out] ListLength The length of the link list if the function returns successfully. 736 737 @retval EFI_SUCCESS Two complete passes are made with no changes in the number of children. 738 @retval EFI_INVALID_PARAMETER The input parameter is invalid. 739 @retval Others Return the CallBack's last return value. 740 741 **/ 742 EFI_STATUS 743 EFIAPI 744 NetDestroyLinkList ( 745 IN LIST_ENTRY *List, 746 IN NET_DESTROY_LINK_LIST_CALLBACK CallBack, 747 IN VOID *Context, OPTIONAL 748 OUT UINTN *ListLength OPTIONAL 749 ); 750 751 /** 752 This function checks the input Handle to see if it's one of these handles in ChildHandleBuffer. 753 754 @param[in] Handle Handle to be checked. 755 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. 756 @param[in] ChildHandleBuffer An array of child handles to be freed. May be NULL 757 if NumberOfChildren is 0. 758 759 @retval TRUE Found the input Handle in ChildHandleBuffer. 760 @retval FALSE Can't find the input Handle in ChildHandleBuffer. 761 762 **/ 763 BOOLEAN 764 EFIAPI 765 NetIsInHandleBuffer ( 766 IN EFI_HANDLE Handle, 767 IN UINTN NumberOfChildren, 768 IN EFI_HANDLE *ChildHandleBuffer OPTIONAL 769 ); 770 771 // 772 // Object container: EFI network stack spec defines various kinds of 773 // tokens. The drivers can share code to manage those objects. 774 // 775 typedef struct { 776 LIST_ENTRY Link; 777 VOID *Key; 778 VOID *Value; 779 } NET_MAP_ITEM; 780 781 typedef struct { 782 LIST_ENTRY Used; 783 LIST_ENTRY Recycled; 784 UINTN Count; 785 } NET_MAP; 786 787 #define NET_MAP_INCREAMENT 64 788 789 /** 790 Initialize the netmap. Netmap is a reposity to keep the <Key, Value> pairs. 791 792 Initialize the forward and backward links of two head nodes donated by Map->Used 793 and Map->Recycled of two doubly linked lists. 794 Initializes the count of the <Key, Value> pairs in the netmap to zero. 795 796 If Map is NULL, then ASSERT(). 797 If the address of Map->Used is NULL, then ASSERT(). 798 If the address of Map->Recycled is NULl, then ASSERT(). 799 800 @param[in, out] Map The netmap to initialize. 801 802 **/ 803 VOID 804 EFIAPI 805 NetMapInit ( 806 IN OUT NET_MAP *Map 807 ); 808 809 /** 810 To clean up the netmap, that is, release allocated memories. 811 812 Removes all nodes of the Used doubly linked list and frees memory of all related netmap items. 813 Removes all nodes of the Recycled doubly linked list and free memory of all related netmap items. 814 The number of the <Key, Value> pairs in the netmap is set to zero. 815 816 If Map is NULL, then ASSERT(). 817 818 @param[in, out] Map The netmap to clean up. 819 820 **/ 821 VOID 822 EFIAPI 823 NetMapClean ( 824 IN OUT NET_MAP *Map 825 ); 826 827 /** 828 Test whether the netmap is empty and return true if it is. 829 830 If the number of the <Key, Value> pairs in the netmap is zero, return TRUE. 831 832 If Map is NULL, then ASSERT(). 833 834 835 @param[in] Map The net map to test. 836 837 @return TRUE if the netmap is empty, otherwise FALSE. 838 839 **/ 840 BOOLEAN 841 EFIAPI 842 NetMapIsEmpty ( 843 IN NET_MAP *Map 844 ); 845 846 /** 847 Return the number of the <Key, Value> pairs in the netmap. 848 849 @param[in] Map The netmap to get the entry number. 850 851 @return The entry number in the netmap. 852 853 **/ 854 UINTN 855 EFIAPI 856 NetMapGetCount ( 857 IN NET_MAP *Map 858 ); 859 860 /** 861 Allocate an item to save the <Key, Value> pair to the head of the netmap. 862 863 Allocate an item to save the <Key, Value> pair and add corresponding node entry 864 to the beginning of the Used doubly linked list. The number of the <Key, Value> 865 pairs in the netmap increase by 1. 866 867 If Map is NULL, then ASSERT(). 868 869 @param[in, out] Map The netmap to insert into. 870 @param[in] Key The user's key. 871 @param[in] Value The user's value for the key. 872 873 @retval EFI_OUT_OF_RESOURCES Failed to allocate the memory for the item. 874 @retval EFI_SUCCESS The item is inserted to the head. 875 876 **/ 877 EFI_STATUS 878 EFIAPI 879 NetMapInsertHead ( 880 IN OUT NET_MAP *Map, 881 IN VOID *Key, 882 IN VOID *Value OPTIONAL 883 ); 884 885 /** 886 Allocate an item to save the <Key, Value> pair to the tail of the netmap. 887 888 Allocate an item to save the <Key, Value> pair and add corresponding node entry 889 to the tail of the Used doubly linked list. The number of the <Key, Value> 890 pairs in the netmap increase by 1. 891 892 If Map is NULL, then ASSERT(). 893 894 @param[in, out] Map The netmap to insert into. 895 @param[in] Key The user's key. 896 @param[in] Value The user's value for the key. 897 898 @retval EFI_OUT_OF_RESOURCES Failed to allocate the memory for the item. 899 @retval EFI_SUCCESS The item is inserted to the tail. 900 901 **/ 902 EFI_STATUS 903 EFIAPI 904 NetMapInsertTail ( 905 IN OUT NET_MAP *Map, 906 IN VOID *Key, 907 IN VOID *Value OPTIONAL 908 ); 909 910 /** 911 Finds the key in the netmap and returns the point to the item containing the Key. 912 913 Iterate the Used doubly linked list of the netmap to get every item. Compare the key of every 914 item with the key to search. It returns the point to the item contains the Key if found. 915 916 If Map is NULL, then ASSERT(). 917 918 @param[in] Map The netmap to search within. 919 @param[in] Key The key to search. 920 921 @return The point to the item contains the Key, or NULL if Key isn't in the map. 922 923 **/ 924 NET_MAP_ITEM * 925 EFIAPI 926 NetMapFindKey ( 927 IN NET_MAP *Map, 928 IN VOID *Key 929 ); 930 931 /** 932 Remove the node entry of the item from the netmap and return the key of the removed item. 933 934 Remove the node entry of the item from the Used doubly linked list of the netmap. 935 The number of the <Key, Value> pairs in the netmap decrease by 1. Then add the node 936 entry of the item to the Recycled doubly linked list of the netmap. If Value is not NULL, 937 Value will point to the value of the item. It returns the key of the removed item. 938 939 If Map is NULL, then ASSERT(). 940 If Item is NULL, then ASSERT(). 941 if item in not in the netmap, then ASSERT(). 942 943 @param[in, out] Map The netmap to remove the item from. 944 @param[in, out] Item The item to remove. 945 @param[out] Value The variable to receive the value if not NULL. 946 947 @return The key of the removed item. 948 949 **/ 950 VOID * 951 EFIAPI 952 NetMapRemoveItem ( 953 IN OUT NET_MAP *Map, 954 IN OUT NET_MAP_ITEM *Item, 955 OUT VOID **Value OPTIONAL 956 ); 957 958 /** 959 Remove the first node entry on the netmap and return the key of the removed item. 960 961 Remove the first node entry from the Used doubly linked list of the netmap. 962 The number of the <Key, Value> pairs in the netmap decrease by 1. Then add the node 963 entry to the Recycled doubly linked list of the netmap. If parameter Value is not NULL, 964 parameter Value will point to the value of the item. It returns the key of the removed item. 965 966 If Map is NULL, then ASSERT(). 967 If the Used doubly linked list is empty, then ASSERT(). 968 969 @param[in, out] Map The netmap to remove the head from. 970 @param[out] Value The variable to receive the value if not NULL. 971 972 @return The key of the item removed. 973 974 **/ 975 VOID * 976 EFIAPI 977 NetMapRemoveHead ( 978 IN OUT NET_MAP *Map, 979 OUT VOID **Value OPTIONAL 980 ); 981 982 /** 983 Remove the last node entry on the netmap and return the key of the removed item. 984 985 Remove the last node entry from the Used doubly linked list of the netmap. 986 The number of the <Key, Value> pairs in the netmap decrease by 1. Then add the node 987 entry to the Recycled doubly linked list of the netmap. If parameter Value is not NULL, 988 parameter Value will point to the value of the item. It returns the key of the removed item. 989 990 If Map is NULL, then ASSERT(). 991 If the Used doubly linked list is empty, then ASSERT(). 992 993 @param[in, out] Map The netmap to remove the tail from. 994 @param[out] Value The variable to receive the value if not NULL. 995 996 @return The key of the item removed. 997 998 **/ 999 VOID * 1000 EFIAPI 1001 NetMapRemoveTail ( 1002 IN OUT NET_MAP *Map, 1003 OUT VOID **Value OPTIONAL 1004 ); 1005 1006 typedef 1007 EFI_STATUS 1008 (EFIAPI *NET_MAP_CALLBACK) ( 1009 IN NET_MAP *Map, 1010 IN NET_MAP_ITEM *Item, 1011 IN VOID *Arg 1012 ); 1013 1014 /** 1015 Iterate through the netmap and call CallBack for each item. 1016 1017 It will continue the traverse if CallBack returns EFI_SUCCESS, otherwise, break 1018 from the loop. It returns the CallBack's last return value. This function is 1019 delete safe for the current item. 1020 1021 If Map is NULL, then ASSERT(). 1022 If CallBack is NULL, then ASSERT(). 1023 1024 @param[in] Map The Map to iterate through. 1025 @param[in] CallBack The callback function to call for each item. 1026 @param[in] Arg The opaque parameter to the callback. 1027 1028 @retval EFI_SUCCESS There is no item in the netmap, or CallBack for each item 1029 returns EFI_SUCCESS. 1030 @retval Others It returns the CallBack's last return value. 1031 1032 **/ 1033 EFI_STATUS 1034 EFIAPI 1035 NetMapIterate ( 1036 IN NET_MAP *Map, 1037 IN NET_MAP_CALLBACK CallBack, 1038 IN VOID *Arg OPTIONAL 1039 ); 1040 1041 1042 // 1043 // Helper functions to implement driver binding and service binding protocols. 1044 // 1045 /** 1046 Create a child of the service that is identified by ServiceBindingGuid. 1047 1048 Get the ServiceBinding Protocol first, then use it to create a child. 1049 1050 If ServiceBindingGuid is NULL, then ASSERT(). 1051 If ChildHandle is NULL, then ASSERT(). 1052 1053 @param[in] Controller The controller which has the service installed. 1054 @param[in] Image The image handle used to open service. 1055 @param[in] ServiceBindingGuid The service's Guid. 1056 @param[in, out] ChildHandle The handle to receive the created child. 1057 1058 @retval EFI_SUCCESS The child was successfully created. 1059 @retval Others Failed to create the child. 1060 1061 **/ 1062 EFI_STATUS 1063 EFIAPI 1064 NetLibCreateServiceChild ( 1065 IN EFI_HANDLE Controller, 1066 IN EFI_HANDLE Image, 1067 IN EFI_GUID *ServiceBindingGuid, 1068 IN OUT EFI_HANDLE *ChildHandle 1069 ); 1070 1071 /** 1072 Destroy a child of the service that is identified by ServiceBindingGuid. 1073 1074 Get the ServiceBinding Protocol first, then use it to destroy a child. 1075 1076 If ServiceBindingGuid is NULL, then ASSERT(). 1077 1078 @param[in] Controller The controller which has the service installed. 1079 @param[in] Image The image handle used to open service. 1080 @param[in] ServiceBindingGuid The service's Guid. 1081 @param[in] ChildHandle The child to destroy. 1082 1083 @retval EFI_SUCCESS The child was destroyed. 1084 @retval Others Failed to destroy the child. 1085 1086 **/ 1087 EFI_STATUS 1088 EFIAPI 1089 NetLibDestroyServiceChild ( 1090 IN EFI_HANDLE Controller, 1091 IN EFI_HANDLE Image, 1092 IN EFI_GUID *ServiceBindingGuid, 1093 IN EFI_HANDLE ChildHandle 1094 ); 1095 1096 /** 1097 Get handle with Simple Network Protocol installed on it. 1098 1099 There should be MNP Service Binding Protocol installed on the input ServiceHandle. 1100 If Simple Network Protocol is already installed on the ServiceHandle, the 1101 ServiceHandle will be returned. If SNP is not installed on the ServiceHandle, 1102 try to find its parent handle with SNP installed. 1103 1104 @param[in] ServiceHandle The handle where network service binding protocols are 1105 installed on. 1106 @param[out] Snp The pointer to store the address of the SNP instance. 1107 This is an optional parameter that may be NULL. 1108 1109 @return The SNP handle, or NULL if not found. 1110 1111 **/ 1112 EFI_HANDLE 1113 EFIAPI 1114 NetLibGetSnpHandle ( 1115 IN EFI_HANDLE ServiceHandle, 1116 OUT EFI_SIMPLE_NETWORK_PROTOCOL **Snp OPTIONAL 1117 ); 1118 1119 /** 1120 Retrieve VLAN ID of a VLAN device handle. 1121 1122 Search VLAN device path node in Device Path of specified ServiceHandle and 1123 return its VLAN ID. If no VLAN device path node found, then this ServiceHandle 1124 is not a VLAN device handle, and 0 will be returned. 1125 1126 @param[in] ServiceHandle The handle where network service binding protocols are 1127 installed on. 1128 1129 @return VLAN ID of the device handle, or 0 if not a VLAN device. 1130 1131 **/ 1132 UINT16 1133 EFIAPI 1134 NetLibGetVlanId ( 1135 IN EFI_HANDLE ServiceHandle 1136 ); 1137 1138 /** 1139 Find VLAN device handle with specified VLAN ID. 1140 1141 The VLAN child device handle is created by VLAN Config Protocol on ControllerHandle. 1142 This function will append VLAN device path node to the parent device path, 1143 and then use LocateDevicePath() to find the correct VLAN device handle. 1144 1145 @param[in] ControllerHandle The handle where network service binding protocols are 1146 installed on. 1147 @param[in] VlanId The configured VLAN ID for the VLAN device. 1148 1149 @return The VLAN device handle, or NULL if not found. 1150 1151 **/ 1152 EFI_HANDLE 1153 EFIAPI 1154 NetLibGetVlanHandle ( 1155 IN EFI_HANDLE ControllerHandle, 1156 IN UINT16 VlanId 1157 ); 1158 1159 /** 1160 Get MAC address associated with the network service handle. 1161 1162 There should be MNP Service Binding Protocol installed on the input ServiceHandle. 1163 If SNP is installed on the ServiceHandle or its parent handle, MAC address will 1164 be retrieved from SNP. If no SNP found, try to get SNP mode data use MNP. 1165 1166 @param[in] ServiceHandle The handle where network service binding protocols are 1167 installed on. 1168 @param[out] MacAddress The pointer to store the returned MAC address. 1169 @param[out] AddressSize The length of returned MAC address. 1170 1171 @retval EFI_SUCCESS MAC address was returned successfully. 1172 @retval Others Failed to get SNP mode data. 1173 1174 **/ 1175 EFI_STATUS 1176 EFIAPI 1177 NetLibGetMacAddress ( 1178 IN EFI_HANDLE ServiceHandle, 1179 OUT EFI_MAC_ADDRESS *MacAddress, 1180 OUT UINTN *AddressSize 1181 ); 1182 1183 /** 1184 Convert MAC address of the NIC associated with specified Service Binding Handle 1185 to a unicode string. Callers are responsible for freeing the string storage. 1186 1187 Locate simple network protocol associated with the Service Binding Handle and 1188 get the mac address from SNP. Then convert the mac address into a unicode 1189 string. It takes 2 unicode characters to represent a 1 byte binary buffer. 1190 Plus one unicode character for the null-terminator. 1191 1192 @param[in] ServiceHandle The handle where network service binding protocol is 1193 installed. 1194 @param[in] ImageHandle The image handle used to act as the agent handle to 1195 get the simple network protocol. This parameter is 1196 optional and may be NULL. 1197 @param[out] MacString The pointer to store the address of the string 1198 representation of the mac address. 1199 1200 @retval EFI_SUCCESS Converted the mac address a unicode string successfully. 1201 @retval EFI_OUT_OF_RESOURCES There are not enough memory resources. 1202 @retval Others Failed to open the simple network protocol. 1203 1204 **/ 1205 EFI_STATUS 1206 EFIAPI 1207 NetLibGetMacString ( 1208 IN EFI_HANDLE ServiceHandle, 1209 IN EFI_HANDLE ImageHandle, OPTIONAL 1210 OUT CHAR16 **MacString 1211 ); 1212 1213 /** 1214 Detect media status for specified network device. 1215 1216 The underlying UNDI driver may or may not support reporting media status from 1217 GET_STATUS command (PXE_STATFLAGS_GET_STATUS_NO_MEDIA_SUPPORTED). This routine 1218 will try to invoke Snp->GetStatus() to get the media status. If media is already 1219 present, it returns directly. If media is not present, it will stop SNP and then 1220 restart SNP to get the latest media status. This provides an opportunity to get 1221 the correct media status for old UNDI driver, which doesn't support reporting 1222 media status from GET_STATUS command. 1223 Note: there are two limitations for the current algorithm: 1224 1) For UNDI with this capability, when the cable is not attached, there will 1225 be an redundant Stop/Start() process. 1226 2) for UNDI without this capability, in case that network cable is attached when 1227 Snp->Initialize() is invoked while network cable is unattached later, 1228 NetLibDetectMedia() will report MediaPresent as TRUE, causing upper layer 1229 apps to wait for timeout time. 1230 1231 @param[in] ServiceHandle The handle where network service binding protocols are 1232 installed. 1233 @param[out] MediaPresent The pointer to store the media status. 1234 1235 @retval EFI_SUCCESS Media detection success. 1236 @retval EFI_INVALID_PARAMETER ServiceHandle is not a valid network device handle. 1237 @retval EFI_UNSUPPORTED The network device does not support media detection. 1238 @retval EFI_DEVICE_ERROR SNP is in an unknown state. 1239 1240 **/ 1241 EFI_STATUS 1242 EFIAPI 1243 NetLibDetectMedia ( 1244 IN EFI_HANDLE ServiceHandle, 1245 OUT BOOLEAN *MediaPresent 1246 ); 1247 1248 /** 1249 Create an IPv4 device path node. 1250 1251 The header type of IPv4 device path node is MESSAGING_DEVICE_PATH. 1252 The header subtype of IPv4 device path node is MSG_IPv4_DP. 1253 The length of the IPv4 device path node in bytes is 19. 1254 Get other information from parameters to make up the whole IPv4 device path node. 1255 1256 @param[in, out] Node The pointer to the IPv4 device path node. 1257 @param[in] Controller The controller handle. 1258 @param[in] LocalIp The local IPv4 address. 1259 @param[in] LocalPort The local port. 1260 @param[in] RemoteIp The remote IPv4 address. 1261 @param[in] RemotePort The remote port. 1262 @param[in] Protocol The protocol type in the IP header. 1263 @param[in] UseDefaultAddress Whether this instance is using default address or not. 1264 1265 **/ 1266 VOID 1267 EFIAPI 1268 NetLibCreateIPv4DPathNode ( 1269 IN OUT IPv4_DEVICE_PATH *Node, 1270 IN EFI_HANDLE Controller, 1271 IN IP4_ADDR LocalIp, 1272 IN UINT16 LocalPort, 1273 IN IP4_ADDR RemoteIp, 1274 IN UINT16 RemotePort, 1275 IN UINT16 Protocol, 1276 IN BOOLEAN UseDefaultAddress 1277 ); 1278 1279 /** 1280 Create an IPv6 device path node. 1281 1282 The header type of IPv6 device path node is MESSAGING_DEVICE_PATH. 1283 The header subtype of IPv6 device path node is MSG_IPv6_DP. 1284 The length of the IPv6 device path node in bytes is 43. 1285 Get other information from parameters to make up the whole IPv6 device path node. 1286 1287 @param[in, out] Node The pointer to the IPv6 device path node. 1288 @param[in] Controller The controller handle. 1289 @param[in] LocalIp The local IPv6 address. 1290 @param[in] LocalPort The local port. 1291 @param[in] RemoteIp The remote IPv6 address. 1292 @param[in] RemotePort The remote port. 1293 @param[in] Protocol The protocol type in the IP header. 1294 1295 **/ 1296 VOID 1297 EFIAPI 1298 NetLibCreateIPv6DPathNode ( 1299 IN OUT IPv6_DEVICE_PATH *Node, 1300 IN EFI_HANDLE Controller, 1301 IN EFI_IPv6_ADDRESS *LocalIp, 1302 IN UINT16 LocalPort, 1303 IN EFI_IPv6_ADDRESS *RemoteIp, 1304 IN UINT16 RemotePort, 1305 IN UINT16 Protocol 1306 ); 1307 1308 1309 /** 1310 Find the UNDI/SNP handle from controller and protocol GUID. 1311 1312 For example, IP will open an MNP child to transmit/receive 1313 packets. When MNP is stopped, IP should also be stopped. IP 1314 needs to find its own private data that is related the IP's 1315 service binding instance that is installed on the UNDI/SNP handle. 1316 The controller is then either an MNP or an ARP child handle. Note that 1317 IP opens these handles using BY_DRIVER. Use that information to get the 1318 UNDI/SNP handle. 1319 1320 @param[in] Controller The protocol handle to check. 1321 @param[in] ProtocolGuid The protocol that is related with the handle. 1322 1323 @return The UNDI/SNP handle or NULL for errors. 1324 1325 **/ 1326 EFI_HANDLE 1327 EFIAPI 1328 NetLibGetNicHandle ( 1329 IN EFI_HANDLE Controller, 1330 IN EFI_GUID *ProtocolGuid 1331 ); 1332 1333 /** 1334 This is the default unload handle for all the network drivers. 1335 1336 Disconnect the driver specified by ImageHandle from all the devices in the handle database. 1337 Uninstall all the protocols installed in the driver entry point. 1338 1339 @param[in] ImageHandle The drivers' driver image. 1340 1341 @retval EFI_SUCCESS The image is unloaded. 1342 @retval Others Failed to unload the image. 1343 1344 **/ 1345 EFI_STATUS 1346 EFIAPI 1347 NetLibDefaultUnload ( 1348 IN EFI_HANDLE ImageHandle 1349 ); 1350 1351 /** 1352 Convert one Null-terminated ASCII string (decimal dotted) to EFI_IPv4_ADDRESS. 1353 1354 @param[in] String The pointer to the Ascii string. 1355 @param[out] Ip4Address The pointer to the converted IPv4 address. 1356 1357 @retval EFI_SUCCESS Converted to an IPv4 address successfully. 1358 @retval EFI_INVALID_PARAMETER The string is malformatted, or Ip4Address is NULL. 1359 1360 **/ 1361 EFI_STATUS 1362 EFIAPI 1363 NetLibAsciiStrToIp4 ( 1364 IN CONST CHAR8 *String, 1365 OUT EFI_IPv4_ADDRESS *Ip4Address 1366 ); 1367 1368 /** 1369 Convert one Null-terminated ASCII string to EFI_IPv6_ADDRESS. The format of the 1370 string is defined in RFC 4291 - Text Representation of Addresses. 1371 1372 @param[in] String The pointer to the Ascii string. 1373 @param[out] Ip6Address The pointer to the converted IPv6 address. 1374 1375 @retval EFI_SUCCESS Converted to an IPv6 address successfully. 1376 @retval EFI_INVALID_PARAMETER The string is malformatted, or Ip6Address is NULL. 1377 1378 **/ 1379 EFI_STATUS 1380 EFIAPI 1381 NetLibAsciiStrToIp6 ( 1382 IN CONST CHAR8 *String, 1383 OUT EFI_IPv6_ADDRESS *Ip6Address 1384 ); 1385 1386 /** 1387 Convert one Null-terminated Unicode string (decimal dotted) to EFI_IPv4_ADDRESS. 1388 1389 @param[in] String The pointer to the Ascii string. 1390 @param[out] Ip4Address The pointer to the converted IPv4 address. 1391 1392 @retval EFI_SUCCESS Converted to an IPv4 address successfully. 1393 @retval EFI_INVALID_PARAMETER The string is mal-formatted or Ip4Address is NULL. 1394 @retval EFI_OUT_OF_RESOURCES Failed to perform the operation due to lack of resources. 1395 1396 **/ 1397 EFI_STATUS 1398 EFIAPI 1399 NetLibStrToIp4 ( 1400 IN CONST CHAR16 *String, 1401 OUT EFI_IPv4_ADDRESS *Ip4Address 1402 ); 1403 1404 /** 1405 Convert one Null-terminated Unicode string to EFI_IPv6_ADDRESS. The format of 1406 the string is defined in RFC 4291 - Text Representation of Addresses. 1407 1408 @param[in] String The pointer to the Ascii string. 1409 @param[out] Ip6Address The pointer to the converted IPv6 address. 1410 1411 @retval EFI_SUCCESS Converted to an IPv6 address successfully. 1412 @retval EFI_INVALID_PARAMETER The string is malformatted or Ip6Address is NULL. 1413 @retval EFI_OUT_OF_RESOURCES Failed to perform the operation due to a lack of resources. 1414 1415 **/ 1416 EFI_STATUS 1417 EFIAPI 1418 NetLibStrToIp6 ( 1419 IN CONST CHAR16 *String, 1420 OUT EFI_IPv6_ADDRESS *Ip6Address 1421 ); 1422 1423 /** 1424 Convert one Null-terminated Unicode string to EFI_IPv6_ADDRESS and prefix length. 1425 The format of the string is defined in RFC 4291 - Text Representation of Addresses 1426 Prefixes: ipv6-address/prefix-length. 1427 1428 @param[in] String The pointer to the Ascii string. 1429 @param[out] Ip6Address The pointer to the converted IPv6 address. 1430 @param[out] PrefixLength The pointer to the converted prefix length. 1431 1432 @retval EFI_SUCCESS Converted to an IPv6 address successfully. 1433 @retval EFI_INVALID_PARAMETER The string is malformatted, or Ip6Address is NULL. 1434 @retval EFI_OUT_OF_RESOURCES Failed to perform the operation due to a lack of resources. 1435 1436 **/ 1437 EFI_STATUS 1438 EFIAPI 1439 NetLibStrToIp6andPrefix ( 1440 IN CONST CHAR16 *String, 1441 OUT EFI_IPv6_ADDRESS *Ip6Address, 1442 OUT UINT8 *PrefixLength 1443 ); 1444 1445 /** 1446 1447 Convert one EFI_IPv6_ADDRESS to Null-terminated Unicode string. 1448 The text representation of address is defined in RFC 4291. 1449 1450 @param[in] Ip6Address The pointer to the IPv6 address. 1451 @param[out] String The buffer to return the converted string. 1452 @param[in] StringSize The length in bytes of the input String. 1453 1454 @retval EFI_SUCCESS Convert to string successfully. 1455 @retval EFI_INVALID_PARAMETER The input parameter is invalid. 1456 @retval EFI_BUFFER_TOO_SMALL The BufferSize is too small for the result. BufferSize has been 1457 updated with the size needed to complete the request. 1458 **/ 1459 EFI_STATUS 1460 EFIAPI 1461 NetLibIp6ToStr ( 1462 IN EFI_IPv6_ADDRESS *Ip6Address, 1463 OUT CHAR16 *String, 1464 IN UINTN StringSize 1465 ); 1466 1467 // 1468 // Various signatures 1469 // 1470 #define NET_BUF_SIGNATURE SIGNATURE_32 ('n', 'b', 'u', 'f') 1471 #define NET_VECTOR_SIGNATURE SIGNATURE_32 ('n', 'v', 'e', 'c') 1472 #define NET_QUE_SIGNATURE SIGNATURE_32 ('n', 'b', 'q', 'u') 1473 1474 1475 #define NET_PROTO_DATA 64 // Opaque buffer for protocols 1476 #define NET_BUF_HEAD 1 // Trim or allocate space from head 1477 #define NET_BUF_TAIL 0 // Trim or allocate space from tail 1478 #define NET_VECTOR_OWN_FIRST 0x01 // We allocated the 1st block in the vector 1479 1480 #define NET_CHECK_SIGNATURE(PData, SIGNATURE) \ 1481 ASSERT (((PData) != NULL) && ((PData)->Signature == (SIGNATURE))) 1482 1483 // 1484 // Single memory block in the vector. 1485 // 1486 typedef struct { 1487 UINT32 Len; // The block's length 1488 UINT8 *Bulk; // The block's Data 1489 } NET_BLOCK; 1490 1491 typedef VOID (EFIAPI *NET_VECTOR_EXT_FREE) (VOID *Arg); 1492 1493 // 1494 //NET_VECTOR contains several blocks to hold all packet's 1495 //fragments and other house-keeping stuff for sharing. It 1496 //doesn't specify the where actual packet fragment begins. 1497 // 1498 typedef struct { 1499 UINT32 Signature; 1500 INTN RefCnt; // Reference count to share NET_VECTOR. 1501 NET_VECTOR_EXT_FREE Free; // external function to free NET_VECTOR 1502 VOID *Arg; // opaque argument to Free 1503 UINT32 Flag; // Flags, NET_VECTOR_OWN_FIRST 1504 UINT32 Len; // Total length of the associated BLOCKs 1505 1506 UINT32 BlockNum; 1507 NET_BLOCK Block[1]; 1508 } NET_VECTOR; 1509 1510 // 1511 //NET_BLOCK_OP operates on the NET_BLOCK. It specifies 1512 //where the actual fragment begins and ends 1513 // 1514 typedef struct { 1515 UINT8 *BlockHead; // Block's head, or the smallest valid Head 1516 UINT8 *BlockTail; // Block's tail. BlockTail-BlockHead=block length 1517 UINT8 *Head; // 1st byte of the data in the block 1518 UINT8 *Tail; // Tail of the data in the block, Tail-Head=Size 1519 UINT32 Size; // The size of the data 1520 } NET_BLOCK_OP; 1521 1522 typedef union { 1523 IP4_HEAD *Ip4; 1524 EFI_IP6_HEADER *Ip6; 1525 } NET_IP_HEAD; 1526 1527 // 1528 //NET_BUF is the buffer manage structure used by the 1529 //network stack. Every network packet may be fragmented. The Vector points to 1530 //memory blocks used by each fragment, and BlockOp 1531 //specifies where each fragment begins and ends. 1532 // 1533 //It also contains an opaque area for the protocol to store 1534 //per-packet information. Protocol must be careful not 1535 //to overwrite the members after that. 1536 // 1537 typedef struct { 1538 UINT32 Signature; 1539 INTN RefCnt; 1540 LIST_ENTRY List; // The List this NET_BUF is on 1541 1542 NET_IP_HEAD Ip; // Network layer header, for fast access 1543 TCP_HEAD *Tcp; // Transport layer header, for fast access 1544 EFI_UDP_HEADER *Udp; // User Datagram Protocol header 1545 UINT8 ProtoData [NET_PROTO_DATA]; //Protocol specific data 1546 1547 NET_VECTOR *Vector; // The vector containing the packet 1548 1549 UINT32 BlockOpNum; // Total number of BlockOp in the buffer 1550 UINT32 TotalSize; // Total size of the actual packet 1551 NET_BLOCK_OP BlockOp[1]; // Specify the position of actual packet 1552 } NET_BUF; 1553 1554 // 1555 //A queue of NET_BUFs. It is a thin extension of 1556 //NET_BUF functions. 1557 // 1558 typedef struct { 1559 UINT32 Signature; 1560 INTN RefCnt; 1561 LIST_ENTRY List; // The List this buffer queue is on 1562 1563 LIST_ENTRY BufList; // list of queued buffers 1564 UINT32 BufSize; // total length of DATA in the buffers 1565 UINT32 BufNum; // total number of buffers on the chain 1566 } NET_BUF_QUEUE; 1567 1568 // 1569 // Pseudo header for TCP and UDP checksum 1570 // 1571 #pragma pack(1) 1572 typedef struct { 1573 IP4_ADDR SrcIp; 1574 IP4_ADDR DstIp; 1575 UINT8 Reserved; 1576 UINT8 Protocol; 1577 UINT16 Len; 1578 } NET_PSEUDO_HDR; 1579 1580 typedef struct { 1581 EFI_IPv6_ADDRESS SrcIp; 1582 EFI_IPv6_ADDRESS DstIp; 1583 UINT32 Len; 1584 UINT32 Reserved:24; 1585 UINT32 NextHeader:8; 1586 } NET_IP6_PSEUDO_HDR; 1587 #pragma pack() 1588 1589 // 1590 // The fragment entry table used in network interfaces. This is 1591 // the same as NET_BLOCK now. Use two different to distinguish 1592 // the two in case that NET_BLOCK be enhanced later. 1593 // 1594 typedef struct { 1595 UINT32 Len; 1596 UINT8 *Bulk; 1597 } NET_FRAGMENT; 1598 1599 #define NET_GET_REF(PData) ((PData)->RefCnt++) 1600 #define NET_PUT_REF(PData) ((PData)->RefCnt--) 1601 #define NETBUF_FROM_PROTODATA(Info) BASE_CR((Info), NET_BUF, ProtoData) 1602 1603 #define NET_BUF_SHARED(Buf) \ 1604 (((Buf)->RefCnt > 1) || ((Buf)->Vector->RefCnt > 1)) 1605 1606 #define NET_VECTOR_SIZE(BlockNum) \ 1607 (sizeof (NET_VECTOR) + ((BlockNum) - 1) * sizeof (NET_BLOCK)) 1608 1609 #define NET_BUF_SIZE(BlockOpNum) \ 1610 (sizeof (NET_BUF) + ((BlockOpNum) - 1) * sizeof (NET_BLOCK_OP)) 1611 1612 #define NET_HEADSPACE(BlockOp) \ 1613 (UINTN)((BlockOp)->Head - (BlockOp)->BlockHead) 1614 1615 #define NET_TAILSPACE(BlockOp) \ 1616 (UINTN)((BlockOp)->BlockTail - (BlockOp)->Tail) 1617 1618 /** 1619 Allocate a single block NET_BUF. Upon allocation, all the 1620 free space is in the tail room. 1621 1622 @param[in] Len The length of the block. 1623 1624 @return The pointer to the allocated NET_BUF, or NULL if the 1625 allocation failed due to resource limitations. 1626 1627 **/ 1628 NET_BUF * 1629 EFIAPI 1630 NetbufAlloc ( 1631 IN UINT32 Len 1632 ); 1633 1634 /** 1635 Free the net buffer and its associated NET_VECTOR. 1636 1637 Decrease the reference count of the net buffer by one. Free the associated net 1638 vector and itself if the reference count of the net buffer is decreased to 0. 1639 The net vector free operation decreases the reference count of the net 1640 vector by one, and performs the resource free operation when the reference count 1641 of the net vector is 0. 1642 1643 @param[in] Nbuf The pointer to the NET_BUF to be freed. 1644 1645 **/ 1646 VOID 1647 EFIAPI 1648 NetbufFree ( 1649 IN NET_BUF *Nbuf 1650 ); 1651 1652 /** 1653 Get the index of NET_BLOCK_OP that contains the byte at Offset in the net 1654 buffer. 1655 1656 For example, this function can be used to retrieve the IP header in the packet. It 1657 also can be used to get the fragment that contains the byte used 1658 mainly by the library implementation itself. 1659 1660 @param[in] Nbuf The pointer to the net buffer. 1661 @param[in] Offset The offset of the byte. 1662 @param[out] Index Index of the NET_BLOCK_OP that contains the byte at 1663 Offset. 1664 1665 @return The pointer to the Offset'th byte of data in the net buffer, or NULL 1666 if there is no such data in the net buffer. 1667 1668 **/ 1669 UINT8 * 1670 EFIAPI 1671 NetbufGetByte ( 1672 IN NET_BUF *Nbuf, 1673 IN UINT32 Offset, 1674 OUT UINT32 *Index OPTIONAL 1675 ); 1676 1677 /** 1678 Create a copy of the net buffer that shares the associated net vector. 1679 1680 The reference count of the newly created net buffer is set to 1. The reference 1681 count of the associated net vector is increased by one. 1682 1683 @param[in] Nbuf The pointer to the net buffer to be cloned. 1684 1685 @return The pointer to the cloned net buffer, or NULL if the 1686 allocation failed due to resource limitations. 1687 1688 **/ 1689 NET_BUF * 1690 EFIAPI 1691 NetbufClone ( 1692 IN NET_BUF *Nbuf 1693 ); 1694 1695 /** 1696 Create a duplicated copy of the net buffer with data copied and HeadSpace 1697 bytes of head space reserved. 1698 1699 The duplicated net buffer will allocate its own memory to hold the data of the 1700 source net buffer. 1701 1702 @param[in] Nbuf The pointer to the net buffer to be duplicated from. 1703 @param[in, out] Duplicate The pointer to the net buffer to duplicate to. If 1704 NULL, a new net buffer is allocated. 1705 @param[in] HeadSpace The length of the head space to reserve. 1706 1707 @return The pointer to the duplicated net buffer, or NULL if 1708 the allocation failed due to resource limitations. 1709 1710 **/ 1711 NET_BUF * 1712 EFIAPI 1713 NetbufDuplicate ( 1714 IN NET_BUF *Nbuf, 1715 IN OUT NET_BUF *Duplicate OPTIONAL, 1716 IN UINT32 HeadSpace 1717 ); 1718 1719 /** 1720 Create a NET_BUF structure which contains Len byte data of Nbuf starting from 1721 Offset. 1722 1723 A new NET_BUF structure will be created but the associated data in NET_VECTOR 1724 is shared. This function exists to perform IP packet fragmentation. 1725 1726 @param[in] Nbuf The pointer to the net buffer to be extracted. 1727 @param[in] Offset Starting point of the data to be included in the new 1728 net buffer. 1729 @param[in] Len The bytes of data to be included in the new net buffer. 1730 @param[in] HeadSpace The bytes of the head space to reserve for the protocol header. 1731 1732 @return The pointer to the cloned net buffer, or NULL if the 1733 allocation failed due to resource limitations. 1734 1735 **/ 1736 NET_BUF * 1737 EFIAPI 1738 NetbufGetFragment ( 1739 IN NET_BUF *Nbuf, 1740 IN UINT32 Offset, 1741 IN UINT32 Len, 1742 IN UINT32 HeadSpace 1743 ); 1744 1745 /** 1746 Reserve some space in the header room of the net buffer. 1747 1748 Upon allocation, all the space is in the tail room of the buffer. Call this 1749 function to move space to the header room. This function is quite limited 1750 in that it can only reserve space from the first block of an empty NET_BUF not 1751 built from the external. However, it should be enough for the network stack. 1752 1753 @param[in, out] Nbuf The pointer to the net buffer. 1754 @param[in] Len The length of buffer to be reserved from the header. 1755 1756 **/ 1757 VOID 1758 EFIAPI 1759 NetbufReserve ( 1760 IN OUT NET_BUF *Nbuf, 1761 IN UINT32 Len 1762 ); 1763 1764 /** 1765 Allocate Len bytes of space from the header or tail of the buffer. 1766 1767 @param[in, out] Nbuf The pointer to the net buffer. 1768 @param[in] Len The length of the buffer to be allocated. 1769 @param[in] FromHead The flag to indicate whether to reserve the data 1770 from head (TRUE) or tail (FALSE). 1771 1772 @return The pointer to the first byte of the allocated buffer, 1773 or NULL, if there is no sufficient space. 1774 1775 **/ 1776 UINT8* 1777 EFIAPI 1778 NetbufAllocSpace ( 1779 IN OUT NET_BUF *Nbuf, 1780 IN UINT32 Len, 1781 IN BOOLEAN FromHead 1782 ); 1783 1784 /** 1785 Trim Len bytes from the header or the tail of the net buffer. 1786 1787 @param[in, out] Nbuf The pointer to the net buffer. 1788 @param[in] Len The length of the data to be trimmed. 1789 @param[in] FromHead The flag to indicate whether trim data is from the 1790 head (TRUE) or the tail (FALSE). 1791 1792 @return The length of the actual trimmed data, which may be less 1793 than Len if the TotalSize of Nbuf is less than Len. 1794 1795 **/ 1796 UINT32 1797 EFIAPI 1798 NetbufTrim ( 1799 IN OUT NET_BUF *Nbuf, 1800 IN UINT32 Len, 1801 IN BOOLEAN FromHead 1802 ); 1803 1804 /** 1805 Copy Len bytes of data from the specific offset of the net buffer to the 1806 destination memory. 1807 1808 The Len bytes of data may cross several fragments of the net buffer. 1809 1810 @param[in] Nbuf The pointer to the net buffer. 1811 @param[in] Offset The sequence number of the first byte to copy. 1812 @param[in] Len The length of the data to copy. 1813 @param[in] Dest The destination of the data to copy to. 1814 1815 @return The length of the actual copied data, or 0 if the offset 1816 specified exceeds the total size of net buffer. 1817 1818 **/ 1819 UINT32 1820 EFIAPI 1821 NetbufCopy ( 1822 IN NET_BUF *Nbuf, 1823 IN UINT32 Offset, 1824 IN UINT32 Len, 1825 IN UINT8 *Dest 1826 ); 1827 1828 /** 1829 Build a NET_BUF from external blocks. 1830 1831 A new NET_BUF structure will be created from external blocks. An additional block 1832 of memory will be allocated to hold reserved HeadSpace bytes of header room 1833 and existing HeadLen bytes of header, but the external blocks are shared by the 1834 net buffer to avoid data copying. 1835 1836 @param[in] ExtFragment The pointer to the data block. 1837 @param[in] ExtNum The number of the data blocks. 1838 @param[in] HeadSpace The head space to be reserved. 1839 @param[in] HeadLen The length of the protocol header. The function 1840 pulls this amount of data into a linear block. 1841 @param[in] ExtFree The pointer to the caller-provided free function. 1842 @param[in] Arg The argument passed to ExtFree when ExtFree is 1843 called. 1844 1845 @return The pointer to the net buffer built from the data blocks, 1846 or NULL if the allocation failed due to resource 1847 limit. 1848 1849 **/ 1850 NET_BUF * 1851 EFIAPI 1852 NetbufFromExt ( 1853 IN NET_FRAGMENT *ExtFragment, 1854 IN UINT32 ExtNum, 1855 IN UINT32 HeadSpace, 1856 IN UINT32 HeadLen, 1857 IN NET_VECTOR_EXT_FREE ExtFree, 1858 IN VOID *Arg OPTIONAL 1859 ); 1860 1861 /** 1862 Build a fragment table to contain the fragments in the net buffer. This is the 1863 opposite operation of the NetbufFromExt. 1864 1865 @param[in] Nbuf Points to the net buffer. 1866 @param[in, out] ExtFragment The pointer to the data block. 1867 @param[in, out] ExtNum The number of the data blocks. 1868 1869 @retval EFI_BUFFER_TOO_SMALL The number of non-empty blocks is bigger than 1870 ExtNum. 1871 @retval EFI_SUCCESS The fragment table was built successfully. 1872 1873 **/ 1874 EFI_STATUS 1875 EFIAPI 1876 NetbufBuildExt ( 1877 IN NET_BUF *Nbuf, 1878 IN OUT NET_FRAGMENT *ExtFragment, 1879 IN OUT UINT32 *ExtNum 1880 ); 1881 1882 /** 1883 Build a net buffer from a list of net buffers. 1884 1885 All the fragments will be collected from the list of NEW_BUF, and then a new 1886 net buffer will be created through NetbufFromExt. 1887 1888 @param[in] BufList A List of the net buffer. 1889 @param[in] HeadSpace The head space to be reserved. 1890 @param[in] HeaderLen The length of the protocol header. The function 1891 pulls this amount of data into a linear block. 1892 @param[in] ExtFree The pointer to the caller provided free function. 1893 @param[in] Arg The argument passed to ExtFree when ExtFree is called. 1894 1895 @return The pointer to the net buffer built from the list of net 1896 buffers. 1897 1898 **/ 1899 NET_BUF * 1900 EFIAPI 1901 NetbufFromBufList ( 1902 IN LIST_ENTRY *BufList, 1903 IN UINT32 HeadSpace, 1904 IN UINT32 HeaderLen, 1905 IN NET_VECTOR_EXT_FREE ExtFree, 1906 IN VOID *Arg OPTIONAL 1907 ); 1908 1909 /** 1910 Free a list of net buffers. 1911 1912 @param[in, out] Head The pointer to the head of linked net buffers. 1913 1914 **/ 1915 VOID 1916 EFIAPI 1917 NetbufFreeList ( 1918 IN OUT LIST_ENTRY *Head 1919 ); 1920 1921 /** 1922 Initiate the net buffer queue. 1923 1924 @param[in, out] NbufQue The pointer to the net buffer queue to be initialized. 1925 1926 **/ 1927 VOID 1928 EFIAPI 1929 NetbufQueInit ( 1930 IN OUT NET_BUF_QUEUE *NbufQue 1931 ); 1932 1933 /** 1934 Allocate and initialize a net buffer queue. 1935 1936 @return The pointer to the allocated net buffer queue, or NULL if the 1937 allocation failed due to resource limit. 1938 1939 **/ 1940 NET_BUF_QUEUE * 1941 EFIAPI 1942 NetbufQueAlloc ( 1943 VOID 1944 ); 1945 1946 /** 1947 Free a net buffer queue. 1948 1949 Decrease the reference count of the net buffer queue by one. The real resource 1950 free operation isn't performed until the reference count of the net buffer 1951 queue is decreased to 0. 1952 1953 @param[in] NbufQue The pointer to the net buffer queue to be freed. 1954 1955 **/ 1956 VOID 1957 EFIAPI 1958 NetbufQueFree ( 1959 IN NET_BUF_QUEUE *NbufQue 1960 ); 1961 1962 /** 1963 Remove a net buffer from the head in the specific queue and return it. 1964 1965 @param[in, out] NbufQue The pointer to the net buffer queue. 1966 1967 @return The pointer to the net buffer removed from the specific queue, 1968 or NULL if there is no net buffer in the specific queue. 1969 1970 **/ 1971 NET_BUF * 1972 EFIAPI 1973 NetbufQueRemove ( 1974 IN OUT NET_BUF_QUEUE *NbufQue 1975 ); 1976 1977 /** 1978 Append a net buffer to the net buffer queue. 1979 1980 @param[in, out] NbufQue The pointer to the net buffer queue. 1981 @param[in, out] Nbuf The pointer to the net buffer to be appended. 1982 1983 **/ 1984 VOID 1985 EFIAPI 1986 NetbufQueAppend ( 1987 IN OUT NET_BUF_QUEUE *NbufQue, 1988 IN OUT NET_BUF *Nbuf 1989 ); 1990 1991 /** 1992 Copy Len bytes of data from the net buffer queue at the specific offset to the 1993 destination memory. 1994 1995 The copying operation is the same as NetbufCopy, but applies to the net buffer 1996 queue instead of the net buffer. 1997 1998 @param[in] NbufQue The pointer to the net buffer queue. 1999 @param[in] Offset The sequence number of the first byte to copy. 2000 @param[in] Len The length of the data to copy. 2001 @param[out] Dest The destination of the data to copy to. 2002 2003 @return The length of the actual copied data, or 0 if the offset 2004 specified exceeds the total size of net buffer queue. 2005 2006 **/ 2007 UINT32 2008 EFIAPI 2009 NetbufQueCopy ( 2010 IN NET_BUF_QUEUE *NbufQue, 2011 IN UINT32 Offset, 2012 IN UINT32 Len, 2013 OUT UINT8 *Dest 2014 ); 2015 2016 /** 2017 Trim Len bytes of data from the buffer queue and free any net buffer 2018 that is completely trimmed. 2019 2020 The trimming operation is the same as NetbufTrim but applies to the net buffer 2021 queue instead of the net buffer. 2022 2023 @param[in, out] NbufQue The pointer to the net buffer queue. 2024 @param[in] Len The length of the data to trim. 2025 2026 @return The actual length of the data trimmed. 2027 2028 **/ 2029 UINT32 2030 EFIAPI 2031 NetbufQueTrim ( 2032 IN OUT NET_BUF_QUEUE *NbufQue, 2033 IN UINT32 Len 2034 ); 2035 2036 2037 /** 2038 Flush the net buffer queue. 2039 2040 @param[in, out] NbufQue The pointer to the queue to be flushed. 2041 2042 **/ 2043 VOID 2044 EFIAPI 2045 NetbufQueFlush ( 2046 IN OUT NET_BUF_QUEUE *NbufQue 2047 ); 2048 2049 /** 2050 Compute the checksum for a bulk of data. 2051 2052 @param[in] Bulk The pointer to the data. 2053 @param[in] Len The length of the data, in bytes. 2054 2055 @return The computed checksum. 2056 2057 **/ 2058 UINT16 2059 EFIAPI 2060 NetblockChecksum ( 2061 IN UINT8 *Bulk, 2062 IN UINT32 Len 2063 ); 2064 2065 /** 2066 Add two checksums. 2067 2068 @param[in] Checksum1 The first checksum to be added. 2069 @param[in] Checksum2 The second checksum to be added. 2070 2071 @return The new checksum. 2072 2073 **/ 2074 UINT16 2075 EFIAPI 2076 NetAddChecksum ( 2077 IN UINT16 Checksum1, 2078 IN UINT16 Checksum2 2079 ); 2080 2081 /** 2082 Compute the checksum for a NET_BUF. 2083 2084 @param[in] Nbuf The pointer to the net buffer. 2085 2086 @return The computed checksum. 2087 2088 **/ 2089 UINT16 2090 EFIAPI 2091 NetbufChecksum ( 2092 IN NET_BUF *Nbuf 2093 ); 2094 2095 /** 2096 Compute the checksum for TCP/UDP pseudo header. 2097 2098 Src and Dst are in network byte order, and Len is in host byte order. 2099 2100 @param[in] Src The source address of the packet. 2101 @param[in] Dst The destination address of the packet. 2102 @param[in] Proto The protocol type of the packet. 2103 @param[in] Len The length of the packet. 2104 2105 @return The computed checksum. 2106 2107 **/ 2108 UINT16 2109 EFIAPI 2110 NetPseudoHeadChecksum ( 2111 IN IP4_ADDR Src, 2112 IN IP4_ADDR Dst, 2113 IN UINT8 Proto, 2114 IN UINT16 Len 2115 ); 2116 2117 /** 2118 Compute the checksum for the TCP6/UDP6 pseudo header. 2119 2120 Src and Dst are in network byte order, and Len is in host byte order. 2121 2122 @param[in] Src The source address of the packet. 2123 @param[in] Dst The destination address of the packet. 2124 @param[in] NextHeader The protocol type of the packet. 2125 @param[in] Len The length of the packet. 2126 2127 @return The computed checksum. 2128 2129 **/ 2130 UINT16 2131 EFIAPI 2132 NetIp6PseudoHeadChecksum ( 2133 IN EFI_IPv6_ADDRESS *Src, 2134 IN EFI_IPv6_ADDRESS *Dst, 2135 IN UINT8 NextHeader, 2136 IN UINT32 Len 2137 ); 2138 2139 /** 2140 The function frees the net buffer which allocated by the IP protocol. It releases 2141 only the net buffer and doesn't call the external free function. 2142 2143 This function should be called after finishing the process of mIpSec->ProcessExt() 2144 for outbound traffic. The (EFI_IPSEC2_PROTOCOL)->ProcessExt() allocates a new 2145 buffer for the ESP, so there needs a function to free the old net buffer. 2146 2147 @param[in] Nbuf The network buffer to be freed. 2148 2149 **/ 2150 VOID 2151 NetIpSecNetbufFree ( 2152 NET_BUF *Nbuf 2153 ); 2154 2155 /** 2156 This function obtains the system guid from the smbios table. 2157 2158 @param[out] SystemGuid The pointer of the returned system guid. 2159 2160 @retval EFI_SUCCESS Successfully obtained the system guid. 2161 @retval EFI_NOT_FOUND Did not find the SMBIOS table. 2162 2163 **/ 2164 EFI_STATUS 2165 EFIAPI 2166 NetLibGetSystemGuid ( 2167 OUT EFI_GUID *SystemGuid 2168 ); 2169 2170 /** 2171 Create Dns QName according the queried domain name. 2172 QName is a domain name represented as a sequence of labels, 2173 where each label consists of a length octet followed by that 2174 number of octets. The QName terminates with the zero 2175 length octet for the null label of the root. Caller should 2176 take responsibility to free the buffer in returned pointer. 2177 2178 @param DomainName The pointer to the queried domain name string. 2179 2180 @retval NULL Failed to fill QName. 2181 @return QName filled successfully. 2182 2183 **/ 2184 CHAR8 * 2185 EFIAPI 2186 NetLibCreateDnsQName ( 2187 IN CHAR16 *DomainName 2188 ); 2189 2190 #endif 2191