lib/libefivar/uefi-dplib.h

   1 /*-
   2  * Copyright (c) 2017 Netflix, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  *
  26  * $FreeBSD$
  27  */
  28
  29 /*
  30  * Taken from MdePkg/Library/UefiDevicePathLib/UefiDevicePathLib.h
  31  * hash a11928f3310518ab1c6fd34e8d0fdbb72de9602c 2017-Mar-01
  32  */
  33
  34 /** @file
  35   Definition for Device Path library.
  36
  37 Copyright (c) 2013 - 2015, Intel Corporation. All rights reserved.<BR>
  38 This program and the accompanying materials
  39 are licensed and made available under the terms and conditions of the BSD License
  40 which accompanies this distribution.  The full text of the license may be found at
  41 http://opensource.org/licenses/bsd-license.php
  42
  43 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  44 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  45
  46 **/
  47
  48 #ifndef _UEFI_DEVICE_PATH_LIB_H_
  49 #define _UEFI_DEVICE_PATH_LIB_H_
  50 #include <Uefi.h>
  51 #include <Protocol/DevicePathUtilities.h>
  52 #include <Protocol/DebugPort.h>
  53 #include <Protocol/DevicePathToText.h>
  54 #include <Protocol/DevicePathFromText.h>
  55 #include <Guid/PcAnsi.h>
  56 #include <Library/DebugLib.h>
  57 #include <Library/PrintLib.h>
  58 #include <Library/BaseLib.h>
  59 #include <Library/BaseMemoryLib.h>
  60 #include <Library/MemoryAllocationLib.h>
  61 #include <Library/UefiBootServicesTableLib.h>
  62 #include <Library/DevicePathLib.h>
  63 #include <Library/PcdLib.h>
  64 #include <IndustryStandard/Bluetooth.h>
  65
  66 #define IS_COMMA(a)                ((a) == ',')
  67 #define IS_HYPHEN(a)               ((a) == '-')
  68 #define IS_DOT(a)                  ((a) == '.')
  69 #define IS_LEFT_PARENTH(a)         ((a) == '(')
  70 #define IS_RIGHT_PARENTH(a)        ((a) == ')')
  71 #define IS_SLASH(a)                ((a) == '/')
  72 #define IS_NULL(a)                 ((a) == '\0')
  73
  74
  75 //
  76 // Private Data structure
  77 //
  78 typedef struct {
  79   char  *Str;
  80   UINTN   Count;
  81   UINTN   Capacity;
  82 } POOL_PRINT;
  83
  84 typedef
  85 EFI_DEVICE_PATH_PROTOCOL  *
  86 (*DEVICE_PATH_FROM_TEXT) (
  87   IN char *Str
  88   );
  89
  90 typedef
  91 VOID
  92 (*DEVICE_PATH_TO_TEXT) (
  93   IN OUT POOL_PRINT  *Str,
  94   IN VOID            *DevicePath,
  95   IN BOOLEAN         DisplayOnly,
  96   IN BOOLEAN         AllowShortcuts
  97   );
  98
  99 typedef struct {
 100   UINT8                Type;
 101   UINT8                SubType;
 102   DEVICE_PATH_TO_TEXT  Function;
 103 } DEVICE_PATH_TO_TEXT_TABLE;
 104
 105 typedef struct {
 106   UINT8                Type;
 107   const char          *Text;
 108 } DEVICE_PATH_TO_TEXT_GENERIC_TABLE;
 109
 110 typedef struct {
 111   const char                *DevicePathNodeText;
 112   DEVICE_PATH_FROM_TEXT     Function;
 113 } DEVICE_PATH_FROM_TEXT_TABLE;
 114
 115 typedef struct {
 116   BOOLEAN ClassExist;
 117   UINT8   Class;
 118   BOOLEAN SubClassExist;
 119   UINT8   SubClass;
 120 } USB_CLASS_TEXT;
 121
 122 #define USB_CLASS_AUDIO            1
 123 #define USB_CLASS_CDCCONTROL       2
 124 #define USB_CLASS_HID              3
 125 #define USB_CLASS_IMAGE            6
 126 #define USB_CLASS_PRINTER          7
 127 #define USB_CLASS_MASS_STORAGE     8
 128 #define USB_CLASS_HUB              9
 129 #define USB_CLASS_CDCDATA          10
 130 #define USB_CLASS_SMART_CARD       11
 131 #define USB_CLASS_VIDEO            14
 132 #define USB_CLASS_DIAGNOSTIC       220
 133 #define USB_CLASS_WIRELESS         224
 134
 135 #define USB_CLASS_RESERVE          254
 136 #define USB_SUBCLASS_FW_UPDATE     1
 137 #define USB_SUBCLASS_IRDA_BRIDGE   2
 138 #define USB_SUBCLASS_TEST          3
 139
 140 #define RFC_1700_UDP_PROTOCOL      17
 141 #define RFC_1700_TCP_PROTOCOL      6
 142
 143 #pragma pack(1)
 144
 145 typedef struct {
 146   EFI_DEVICE_PATH_PROTOCOL  Header;
 147   EFI_GUID                  Guid;
 148   UINT8                     VendorDefinedData[1];
 149 } VENDOR_DEFINED_HARDWARE_DEVICE_PATH;
 150
 151 typedef struct {
 152   EFI_DEVICE_PATH_PROTOCOL  Header;
 153   EFI_GUID                  Guid;
 154   UINT8                     VendorDefinedData[1];
 155 } VENDOR_DEFINED_MESSAGING_DEVICE_PATH;
 156
 157 typedef struct {
 158   EFI_DEVICE_PATH_PROTOCOL  Header;
 159   EFI_GUID                  Guid;
 160   UINT8                     VendorDefinedData[1];
 161 } VENDOR_DEFINED_MEDIA_DEVICE_PATH;
 162
 163 typedef struct {
 164   EFI_DEVICE_PATH_PROTOCOL  Header;
 165   UINT32                    Hid;
 166   UINT32                    Uid;
 167   UINT32                    Cid;
 168   CHAR8                     HidUidCidStr[3];
 169 } ACPI_EXTENDED_HID_DEVICE_PATH_WITH_STR;
 170
 171 typedef struct {
 172   EFI_DEVICE_PATH_PROTOCOL  Header;
 173   UINT16                    NetworkProtocol;
 174   UINT16                    LoginOption;
 175   UINT64                    Lun;
 176   UINT16                    TargetPortalGroupTag;
 177   CHAR8                     TargetName[1];
 178 } ISCSI_DEVICE_PATH_WITH_NAME;
 179
 180 typedef struct {
 181   EFI_DEVICE_PATH_PROTOCOL  Header;
 182   EFI_GUID                  Guid;
 183   UINT8                     VendorDefinedData[1];
 184 } VENDOR_DEVICE_PATH_WITH_DATA;
 185
 186 #pragma pack()
 187
 188 #ifdef FreeBSD          /* Remove these on FreeBSD */
 189
 190 /**
 191   Returns the size of a device path in bytes.
 192
 193   This function returns the size, in bytes, of the device path data structure
 194   specified by DevicePath including the end of device path node.
 195   If DevicePath is NULL or invalid, then 0 is returned.
 196
 197   @param  DevicePath  A pointer to a device path data structure.
 198
 199   @retval 0           If DevicePath is NULL or invalid.
 200   @retval Others      The size of a device path in bytes.
 201
 202 **/
 203 UINTN
 204 EFIAPI
 205 UefiDevicePathLibGetDevicePathSize (
 206   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 207   );
 208
 209 /**
 210   Creates a new copy of an existing device path.
 211
 212   This function allocates space for a new copy of the device path specified by DevicePath.
 213   If DevicePath is NULL, then NULL is returned.  If the memory is successfully
 214   allocated, then the contents of DevicePath are copied to the newly allocated
 215   buffer, and a pointer to that buffer is returned.  Otherwise, NULL is returned.
 216   The memory for the new device path is allocated from EFI boot services memory.
 217   It is the responsibility of the caller to free the memory allocated.
 218
 219   @param  DevicePath    A pointer to a device path data structure.
 220
 221   @retval NULL          DevicePath is NULL or invalid.
 222   @retval Others        A pointer to the duplicated device path.
 223
 224 **/
 225 EFI_DEVICE_PATH_PROTOCOL *
 226 EFIAPI
 227 UefiDevicePathLibDuplicateDevicePath (
 228   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 229   );
 230
 231 /**
 232   Creates a new device path by appending a second device path to a first device path.
 233
 234   This function creates a new device path by appending a copy of SecondDevicePath
 235   to a copy of FirstDevicePath in a newly allocated buffer.  Only the end-of-device-path
 236   device node from SecondDevicePath is retained. The newly created device path is
 237   returned. If FirstDevicePath is NULL, then it is ignored, and a duplicate of
 238   SecondDevicePath is returned.  If SecondDevicePath is NULL, then it is ignored,
 239   and a duplicate of FirstDevicePath is returned. If both FirstDevicePath and
 240   SecondDevicePath are NULL, then a copy of an end-of-device-path is returned.
 241
 242   If there is not enough memory for the newly allocated buffer, then NULL is returned.
 243   The memory for the new device path is allocated from EFI boot services memory.
 244   It is the responsibility of the caller to free the memory allocated.
 245
 246   @param  FirstDevicePath            A pointer to a device path data structure.
 247   @param  SecondDevicePath           A pointer to a device path data structure.
 248
 249   @retval NULL      If there is not enough memory for the newly allocated buffer.
 250   @retval NULL      If FirstDevicePath or SecondDevicePath is invalid.
 251   @retval Others    A pointer to the new device path if success.
 252                     Or a copy an end-of-device-path if both FirstDevicePath and SecondDevicePath are NULL.
 253
 254 **/
 255 EFI_DEVICE_PATH_PROTOCOL *
 256 EFIAPI
 257 UefiDevicePathLibAppendDevicePath (
 258   IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath,  OPTIONAL
 259   IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
 260   );
 261
 262 /**
 263   Creates a new path by appending the device node to the device path.
 264
 265   This function creates a new device path by appending a copy of the device node
 266   specified by DevicePathNode to a copy of the device path specified by DevicePath
 267   in an allocated buffer. The end-of-device-path device node is moved after the
 268   end of the appended device node.
 269   If DevicePathNode is NULL then a copy of DevicePath is returned.
 270   If DevicePath is NULL then a copy of DevicePathNode, followed by an end-of-device
 271   path device node is returned.
 272   If both DevicePathNode and DevicePath are NULL then a copy of an end-of-device-path
 273   device node is returned.
 274   If there is not enough memory to allocate space for the new device path, then
 275   NULL is returned.
 276   The memory is allocated from EFI boot services memory. It is the responsibility
 277   of the caller to free the memory allocated.
 278
 279   @param  DevicePath                 A pointer to a device path data structure.
 280   @param  DevicePathNode             A pointer to a single device path node.
 281
 282   @retval NULL      If there is not enough memory for the new device path.
 283   @retval Others    A pointer to the new device path if success.
 284                     A copy of DevicePathNode followed by an end-of-device-path node
 285                     if both FirstDevicePath and SecondDevicePath are NULL.
 286                     A copy of an end-of-device-path node if both FirstDevicePath
 287                     and SecondDevicePath are NULL.
 288
 289 **/
 290 EFI_DEVICE_PATH_PROTOCOL *
 291 EFIAPI
 292 UefiDevicePathLibAppendDevicePathNode (
 293   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,     OPTIONAL
 294   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
 295   );
 296
 297 /**
 298   Creates a new device path by appending the specified device path instance to the specified device
 299   path.
 300
 301   This function creates a new device path by appending a copy of the device path
 302   instance specified by DevicePathInstance to a copy of the device path specified
 303   by DevicePath in a allocated buffer.
 304   The end-of-device-path device node is moved after the end of the appended device
 305   path instance and a new end-of-device-path-instance node is inserted between.
 306   If DevicePath is NULL, then a copy if DevicePathInstance is returned.
 307   If DevicePathInstance is NULL, then NULL is returned.
 308   If DevicePath or DevicePathInstance is invalid, then NULL is returned.
 309   If there is not enough memory to allocate space for the new device path, then
 310   NULL is returned.
 311   The memory is allocated from EFI boot services memory. It is the responsibility
 312   of the caller to free the memory allocated.
 313
 314   @param  DevicePath                 A pointer to a device path data structure.
 315   @param  DevicePathInstance         A pointer to a device path instance.
 316
 317   @return A pointer to the new device path.
 318
 319 **/
 320 EFI_DEVICE_PATH_PROTOCOL *
 321 EFIAPI
 322 UefiDevicePathLibAppendDevicePathInstance (
 323   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,        OPTIONAL
 324   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathInstance OPTIONAL
 325   );
 326
 327 /**
 328   Creates a copy of the current device path instance and returns a pointer to the next device path
 329   instance.
 330
 331   This function creates a copy of the current device path instance. It also updates
 332   DevicePath to point to the next device path instance in the device path (or NULL
 333   if no more) and updates Size to hold the size of the device path instance copy.
 334   If DevicePath is NULL, then NULL is returned.
 335   If DevicePath points to a invalid device path, then NULL is returned.
 336   If there is not enough memory to allocate space for the new device path, then
 337   NULL is returned.
 338   The memory is allocated from EFI boot services memory. It is the responsibility
 339   of the caller to free the memory allocated.
 340   If Size is NULL, then ASSERT().
 341
 342   @param  DevicePath                 On input, this holds the pointer to the current
 343                                      device path instance. On output, this holds
 344                                      the pointer to the next device path instance
 345                                      or NULL if there are no more device path
 346                                      instances in the device path pointer to a
 347                                      device path data structure.
 348   @param  Size                       On output, this holds the size of the device
 349                                      path instance, in bytes or zero, if DevicePath
 350                                      is NULL.
 351
 352   @return A pointer to the current device path instance.
 353
 354 **/
 355 EFI_DEVICE_PATH_PROTOCOL *
 356 EFIAPI
 357 UefiDevicePathLibGetNextDevicePathInstance (
 358   IN OUT EFI_DEVICE_PATH_PROTOCOL    **DevicePath,
 359   OUT UINTN                          *Size
 360   );
 361
 362 /**
 363   Creates a device node.
 364
 365   This function creates a new device node in a newly allocated buffer of size
 366   NodeLength and initializes the device path node header with NodeType and NodeSubType.
 367   The new device path node is returned.
 368   If NodeLength is smaller than a device path header, then NULL is returned.
 369   If there is not enough memory to allocate space for the new device path, then
 370   NULL is returned.
 371   The memory is allocated from EFI boot services memory. It is the responsibility
 372   of the caller to free the memory allocated.
 373
 374   @param  NodeType                   The device node type for the new device node.
 375   @param  NodeSubType                The device node sub-type for the new device node.
 376   @param  NodeLength                 The length of the new device node.
 377
 378   @return The new device path.
 379
 380 **/
 381 EFI_DEVICE_PATH_PROTOCOL *
 382 EFIAPI
 383 UefiDevicePathLibCreateDeviceNode (
 384   IN UINT8                           NodeType,
 385   IN UINT8                           NodeSubType,
 386   IN UINT16                          NodeLength
 387   );
 388
 389 /**
 390   Determines if a device path is single or multi-instance.
 391
 392   This function returns TRUE if the device path specified by DevicePath is
 393   multi-instance.
 394   Otherwise, FALSE is returned.
 395   If DevicePath is NULL or invalid, then FALSE is returned.
 396
 397   @param  DevicePath                 A pointer to a device path data structure.
 398
 399   @retval  TRUE                      DevicePath is multi-instance.
 400   @retval  FALSE                     DevicePath is not multi-instance, or DevicePath
 401                                      is NULL or invalid.
 402
 403 **/
 404 BOOLEAN
 405 EFIAPI
 406 UefiDevicePathLibIsDevicePathMultiInstance (
 407   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
 408   );
 409
 410
 411 /**
 412   Converts a device path to its text representation.
 413
 414   @param DevicePath      A Pointer to the device to be converted.
 415   @param DisplayOnly     If DisplayOnly is TRUE, then the shorter text representation
 416                          of the display node is used, where applicable. If DisplayOnly
 417                          is FALSE, then the longer text representation of the display node
 418                          is used.
 419   @param AllowShortcuts  If AllowShortcuts is TRUE, then the shortcut forms of text
 420                          representation for a device node can be used, where applicable.
 421
 422   @return A pointer to the allocated text representation of the device path or
 423           NULL if DeviceNode is NULL or there was insufficient memory.
 424
 425 **/
 426 CHAR16 *
 427 EFIAPI
 428 UefiDevicePathLibConvertDevicePathToText (
 429   IN CONST EFI_DEVICE_PATH_PROTOCOL   *DevicePath,
 430   IN BOOLEAN                          DisplayOnly,
 431   IN BOOLEAN                          AllowShortcuts
 432   );
 433
 434 /**
 435   Converts a device node to its string representation.
 436
 437   @param DeviceNode        A Pointer to the device node to be converted.
 438   @param DisplayOnly       If DisplayOnly is TRUE, then the shorter text representation
 439                            of the display node is used, where applicable. If DisplayOnly
 440                            is FALSE, then the longer text representation of the display node
 441                            is used.
 442   @param AllowShortcuts    If AllowShortcuts is TRUE, then the shortcut forms of text
 443                            representation for a device node can be used, where applicable.
 444
 445   @return A pointer to the allocated text representation of the device node or NULL if DeviceNode
 446           is NULL or there was insufficient memory.
 447
 448 **/
 449 CHAR16 *
 450 EFIAPI
 451 UefiDevicePathLibConvertDeviceNodeToText (
 452   IN CONST EFI_DEVICE_PATH_PROTOCOL  *DeviceNode,
 453   IN BOOLEAN                         DisplayOnly,
 454   IN BOOLEAN                         AllowShortcuts
 455   );
 456
 457 /**
 458   Convert text to the binary representation of a device node.
 459
 460   @param TextDeviceNode  TextDeviceNode points to the text representation of a device
 461                          node. Conversion starts with the first character and continues
 462                          until the first non-device node character.
 463
 464   @return A pointer to the EFI device node or NULL if TextDeviceNode is NULL or there was
 465           insufficient memory or text unsupported.
 466
 467 **/
 468 EFI_DEVICE_PATH_PROTOCOL *
 469 EFIAPI
 470 UefiDevicePathLibConvertTextToDeviceNode (
 471   IN CONST CHAR16 *TextDeviceNode
 472   );
 473
 474 /**
 475   Convert text to the binary representation of a device path.
 476
 477
 478   @param TextDevicePath  TextDevicePath points to the text representation of a device
 479                          path. Conversion starts with the first character and continues
 480                          until the first non-device node character.
 481
 482   @return A pointer to the allocated device path or NULL if TextDeviceNode is NULL or
 483           there was insufficient memory.
 484
 485 **/
 486 EFI_DEVICE_PATH_PROTOCOL *
 487 EFIAPI
 488 UefiDevicePathLibConvertTextToDevicePath (
 489   IN CONST CHAR16 *TextDevicePath
 490   );
 491 #else
 492
 493 /*
 494  * Small FreeBSD shim layer. Fast and lose hacks to make this code work with FreeBSD.
 495  */
 496
 497 #include <ctype.h>
 498
 499 #define _PCD_GET_MODE_32_PcdMaximumDevicePathNodeCount 1000
 500 #define MAX_UINTN UINTPTR_MAX
 501
 502 #define AllocatePool(x) malloc(x)
 503 #define AllocateZeroPool(x) calloc(1,x)
 504 #define AsciiStrLen(s) strlen(s)
 505 #define CopyGuid(dst, src) memcpy(dst, src, sizeof(uuid_t))
 506 #define CopyMem(d, s, l) memcpy(d, s, l)
 507 #define FreePool(x) free(x)
 508 #define LShiftU64(x, s) ((x) << s)
 509 #define ReadUnaligned64(x)    le64dec(x)
 510 #define ReallocatePool(old, new, ptr) realloc(ptr, new)
 511 /*
 512  * Quirky StrCmp returns 0 if equal, 1 if not. This is what the code
 513  * expects, though that expectation is likely a bug (it casts the
 514  * return value. EDK2's StrCmp returns values just like C's strcmp,
 515  * but the parse code casts this to an UINTN, which is bogus. This
 516  * definition papers over that bogusness to do the right thing.  If
 517  * iSCSI protocol string processing is ever fixed, we can remove this
 518  * bletcherous kludge.
 519  */
 520 #define StrCmp(a, b) (strcmp(a, b) != 0)
 521 #define StrCpyS(d, l, s) strcpy(d, s)
 522 #define StrHexToUint64(x) strtoll(x, NULL, 16)
 523 #define StrHexToUintn(x) strtoll(x, NULL, 16)
 524 #define StrLen(x) strlen(x)
 525 #define StrSize(x) (strlen(x) + 1)
 526 #define StrnCatS(d, l, s, len) strncat(d, s, len)
 527 #define StrnCmp(a, b, n) strncmp(a, b, n)
 528 #define StrnLenS(str, max) strlen(str)
 529 #define Strtoi(x) strtol(x, NULL, 0)
 530 #define Strtoi64(x, y) *(long long *)y = strtoll(x, NULL, 0)
 531 #define SwapBytes64(u64) bswap64(u64)
 532 #define UnicodeStrToAsciiStrS(src, dest, len) strlcpy(dest, src, len)
 533 #define ZeroMem(p,l) memset(p, 0, l)
 534
 535 #undef ASSERT
 536 #define ASSERT(x)
 537
 538 /*
 539  * Define AllocateCopyPool and others so that we "forget" about the
 540  * previous non-static deifnition since we want these to be static
 541  * inlines.
 542  */
 543 #define AllocateCopyPool AllocateCopyPoolFreeBSD
 544 #define CompareGuid CompareGuidFreeBSD
 545 #define StrHexToBytes StrHexToBytesFreeBSD
 546 #define StrToGuid StrToGuidFreeBSD
 547 #define WriteUnaligned64 WriteUnaligned64FreeBSD
 548
 549 static inline void *
 550 AllocateCopyPool(size_t l, const void *p)
 551 {
 552         void *rv;
 553
 554         rv = malloc(l);
 555         if (rv == NULL)
 556                 return NULL;
 557         memcpy(rv, p, l);
 558         return (rv);
 559 }
 560
 561 static inline BOOLEAN
 562 CompareGuid (const GUID *g1, const GUID *g2)
 563 {
 564         uint32_t ignored_status;
 565
 566         return (uuid_compare((const uuid_t *)g1, (const uuid_t *)g2,
 567             &ignored_status) == 0);
 568 }
 569
 570 static inline int
 571 StrHexToBytes(const char *str, size_t len, uint8_t *buf, size_t buflen)
 572 {
 573         size_t i;
 574         char hex[3];
 575
 576         /*
 577          * Sanity check preconditions.
 578          */
 579         if (buflen != len / 2 || (len % 1) == 1)
 580                 return 1;
 581         for (i = 0; i < len; i += 2) {
 582                 if (!isxdigit(str[i]) || !isxdigit(str[i + 1]))
 583                         return 1;
 584                 hex[0] = str[i];
 585                 hex[1] = str[i + 1];
 586                 hex[2] = '\0';
 587                 buf[i / 2] = strtol(hex, NULL, 16);
 588         }
 589         return 0;
 590 }
 591
 592 static inline void
 593 StrToGuid(const char *str, GUID *guid)
 594 {
 595         uint32_t status;
 596
 597         uuid_from_string(str, (uuid_t *)guid, &status);
 598 }
 599
 600 static inline void
 601 WriteUnaligned64(void *ptr, uint64_t val)
 602 {
 603         memcpy(ptr, &val, sizeof(val));
 604 }
 605
 606 /*
 607  * Hack to allow converting %g to %s in printfs. Hack because
 608  * it's single entry, uses a static buffer, etc. Sufficient for
 609  * the day for this file though. IF you ever have to convert
 610  * two %g's in one format, punt. Did I mention this was super lame.
 611  * Not to mention it's name.... Also, the error GUID is horrific.
 612  */
 613 static inline const char *
 614 guid_str(const GUID *g)
 615 {
 616         static char buf[36 + 1];
 617         char *str = NULL;
 618         int32_t ignored_status;
 619
 620         uuid_to_string((const uuid_t *)g, &str, &ignored_status);
 621         if (str != NULL)
 622                 strlcpy(buf, str, sizeof(buf));
 623         else
 624                 strlcpy(buf, "groot-cannot-decode-guid-groot-smash",
 625                     sizeof(buf)); /* ^^^^^^^ 36 characters ^^^^^^^ */
 626         free(str);
 627         return buf;
 628 }
 629 #define G(x) guid_str((const GUID *)(const void *)x)
 630 #endif
 631
 632 #undef GLOBAL_REMOVE_IF_UNREFERENCED
 633 #define GLOBAL_REMOVE_IF_UNREFERENCED static
 634
 635 #endif