LCOV - code coverage report
Current view: top level - src/backend/utils/adt - mac8.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 221 263 84.0 %
Date: 2024-02-28 22:11:00 Functions: 19 22 86.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * mac8.c
       4             :  *    PostgreSQL type definitions for 8 byte (EUI-64) MAC addresses.
       5             :  *
       6             :  * EUI-48 (6 byte) MAC addresses are accepted as input and are stored in
       7             :  * EUI-64 format, with the 4th and 5th bytes set to FF and FE, respectively.
       8             :  *
       9             :  * Output is always in 8 byte (EUI-64) format.
      10             :  *
      11             :  * The following code is written with the assumption that the OUI field
      12             :  * size is 24 bits.
      13             :  *
      14             :  * Portions Copyright (c) 1998-2024, PostgreSQL Global Development Group
      15             :  *
      16             :  * IDENTIFICATION
      17             :  *        src/backend/utils/adt/mac8.c
      18             :  *
      19             :  *-------------------------------------------------------------------------
      20             :  */
      21             : 
      22             : #include "postgres.h"
      23             : 
      24             : #include "common/hashfn.h"
      25             : #include "libpq/pqformat.h"
      26             : #include "utils/builtins.h"
      27             : #include "utils/inet.h"
      28             : 
      29             : /*
      30             :  *  Utility macros used for sorting and comparing:
      31             :  */
      32             : #define hibits(addr) \
      33             :   ((unsigned long)(((addr)->a<<24) | ((addr)->b<<16) | ((addr)->c<<8) | ((addr)->d)))
      34             : 
      35             : #define lobits(addr) \
      36             :   ((unsigned long)(((addr)->e<<24) | ((addr)->f<<16) | ((addr)->g<<8) | ((addr)->h)))
      37             : 
      38             : static unsigned char hex2_to_uchar(const unsigned char *ptr, bool *badhex);
      39             : 
      40             : static const signed char hexlookup[128] = {
      41             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      42             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      43             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      44             :     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
      45             :     -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      46             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      47             :     -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      48             :     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
      49             : };
      50             : 
      51             : /*
      52             :  * hex2_to_uchar - convert 2 hex digits to a byte (unsigned char)
      53             :  *
      54             :  * Sets *badhex to true if the end of the string is reached ('\0' found), or if
      55             :  * either character is not a valid hex digit.
      56             :  */
      57             : static inline unsigned char
      58       16358 : hex2_to_uchar(const unsigned char *ptr, bool *badhex)
      59             : {
      60             :     unsigned char ret;
      61             :     signed char lookup;
      62             : 
      63             :     /* Handle the first character */
      64       16358 :     if (*ptr > 127)
      65           0 :         goto invalid_input;
      66             : 
      67       16358 :     lookup = hexlookup[*ptr];
      68       16358 :     if (lookup < 0)
      69          24 :         goto invalid_input;
      70             : 
      71       16334 :     ret = lookup << 4;
      72             : 
      73             :     /* Move to the second character */
      74       16334 :     ptr++;
      75             : 
      76       16334 :     if (*ptr > 127)
      77           0 :         goto invalid_input;
      78             : 
      79       16334 :     lookup = hexlookup[*ptr];
      80       16334 :     if (lookup < 0)
      81          18 :         goto invalid_input;
      82             : 
      83       16316 :     ret += lookup;
      84             : 
      85       16316 :     return ret;
      86             : 
      87          42 : invalid_input:
      88          42 :     *badhex = true;
      89          42 :     return 0;
      90             : }
      91             : 
      92             : /*
      93             :  * MAC address (EUI-48 and EUI-64) reader. Accepts several common notations.
      94             :  */
      95             : Datum
      96        2422 : macaddr8_in(PG_FUNCTION_ARGS)
      97             : {
      98        2422 :     const unsigned char *str = (unsigned char *) PG_GETARG_CSTRING(0);
      99        2422 :     Node       *escontext = fcinfo->context;
     100        2422 :     const unsigned char *ptr = str;
     101        2422 :     bool        badhex = false;
     102             :     macaddr8   *result;
     103        2422 :     unsigned char a = 0,
     104        2422 :                 b = 0,
     105        2422 :                 c = 0,
     106        2422 :                 d = 0,
     107        2422 :                 e = 0,
     108        2422 :                 f = 0,
     109        2422 :                 g = 0,
     110        2422 :                 h = 0;
     111        2422 :     int         count = 0;
     112        2422 :     unsigned char spacer = '\0';
     113             : 
     114             :     /* skip leading spaces */
     115        2518 :     while (*ptr && isspace(*ptr))
     116          96 :         ptr++;
     117             : 
     118             :     /* digits must always come in pairs */
     119       18702 :     while (*ptr && *(ptr + 1))
     120             :     {
     121             :         /*
     122             :          * Attempt to decode each byte, which must be 2 hex digits in a row.
     123             :          * If either digit is not hex, hex2_to_uchar will throw ereport() for
     124             :          * us.  Either 6 or 8 byte MAC addresses are supported.
     125             :          */
     126             : 
     127             :         /* Attempt to collect a byte */
     128       16382 :         count++;
     129             : 
     130       16382 :         switch (count)
     131             :         {
     132        2422 :             case 1:
     133        2422 :                 a = hex2_to_uchar(ptr, &badhex);
     134        2422 :                 break;
     135        2410 :             case 2:
     136        2410 :                 b = hex2_to_uchar(ptr, &badhex);
     137        2410 :                 break;
     138        2386 :             case 3:
     139        2386 :                 c = hex2_to_uchar(ptr, &badhex);
     140        2386 :                 break;
     141        2386 :             case 4:
     142        2386 :                 d = hex2_to_uchar(ptr, &badhex);
     143        2386 :                 break;
     144        2374 :             case 5:
     145        2374 :                 e = hex2_to_uchar(ptr, &badhex);
     146        2374 :                 break;
     147        2374 :             case 6:
     148        2374 :                 f = hex2_to_uchar(ptr, &badhex);
     149        2374 :                 break;
     150        1012 :             case 7:
     151        1012 :                 g = hex2_to_uchar(ptr, &badhex);
     152        1012 :                 break;
     153         994 :             case 8:
     154         994 :                 h = hex2_to_uchar(ptr, &badhex);
     155         994 :                 break;
     156          24 :             default:
     157             :                 /* must be trailing garbage... */
     158          24 :                 goto fail;
     159             :         }
     160             : 
     161       16358 :         if (badhex)
     162          42 :             goto fail;
     163             : 
     164             :         /* Move forward to where the next byte should be */
     165       16316 :         ptr += 2;
     166             : 
     167             :         /* Check for a spacer, these are valid, anything else is not */
     168       16316 :         if (*ptr == ':' || *ptr == '-' || *ptr == '.')
     169             :         {
     170             :             /* remember the spacer used, if it changes then it isn't valid */
     171        8932 :             if (spacer == '\0')
     172        1714 :                 spacer = *ptr;
     173             : 
     174             :             /* Have to use the same spacer throughout */
     175        7218 :             else if (spacer != *ptr)
     176          24 :                 goto fail;
     177             : 
     178             :             /* move past the spacer */
     179        8908 :             ptr++;
     180             :         }
     181             : 
     182             :         /* allow trailing whitespace after if we have 6 or 8 bytes */
     183       16292 :         if (count == 6 || count == 8)
     184             :         {
     185        3356 :             if (isspace(*ptr))
     186             :             {
     187         144 :                 while (*++ptr && isspace(*ptr));
     188             : 
     189             :                 /* If we found a space and then non-space, it's invalid */
     190          36 :                 if (*ptr)
     191          12 :                     goto fail;
     192             :             }
     193             :         }
     194             :     }
     195             : 
     196             :     /* Convert a 6 byte MAC address to macaddr8 */
     197        2320 :     if (count == 6)
     198             :     {
     199        1356 :         h = f;
     200        1356 :         g = e;
     201        1356 :         f = d;
     202             : 
     203        1356 :         d = 0xFF;
     204        1356 :         e = 0xFE;
     205             :     }
     206         964 :     else if (count != 8)
     207          12 :         goto fail;
     208             : 
     209        2308 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     210             : 
     211        2308 :     result->a = a;
     212        2308 :     result->b = b;
     213        2308 :     result->c = c;
     214        2308 :     result->d = d;
     215        2308 :     result->e = e;
     216        2308 :     result->f = f;
     217        2308 :     result->g = g;
     218        2308 :     result->h = h;
     219             : 
     220        2308 :     PG_RETURN_MACADDR8_P(result);
     221             : 
     222         114 : fail:
     223         114 :     ereturn(escontext, (Datum) 0,
     224             :             (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
     225             :              errmsg("invalid input syntax for type %s: \"%s\"", "macaddr8",
     226             :                     str)));
     227             : }
     228             : 
     229             : /*
     230             :  * MAC8 address (EUI-64) output function. Fixed format.
     231             :  */
     232             : Datum
     233        1744 : macaddr8_out(PG_FUNCTION_ARGS)
     234             : {
     235        1744 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     236             :     char       *result;
     237             : 
     238        1744 :     result = (char *) palloc(32);
     239             : 
     240        1744 :     snprintf(result, 32, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",
     241        1744 :              addr->a, addr->b, addr->c, addr->d,
     242        1744 :              addr->e, addr->f, addr->g, addr->h);
     243             : 
     244        1744 :     PG_RETURN_CSTRING(result);
     245             : }
     246             : 
     247             : /*
     248             :  * macaddr8_recv - converts external binary format(EUI-48 and EUI-64) to macaddr8
     249             :  *
     250             :  * The external representation is just the eight bytes, MSB first.
     251             :  */
     252             : Datum
     253           0 : macaddr8_recv(PG_FUNCTION_ARGS)
     254             : {
     255           0 :     StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
     256             :     macaddr8   *addr;
     257             : 
     258           0 :     addr = (macaddr8 *) palloc0(sizeof(macaddr8));
     259             : 
     260           0 :     addr->a = pq_getmsgbyte(buf);
     261           0 :     addr->b = pq_getmsgbyte(buf);
     262           0 :     addr->c = pq_getmsgbyte(buf);
     263             : 
     264           0 :     if (buf->len == 6)
     265             :     {
     266           0 :         addr->d = 0xFF;
     267           0 :         addr->e = 0xFE;
     268             :     }
     269             :     else
     270             :     {
     271           0 :         addr->d = pq_getmsgbyte(buf);
     272           0 :         addr->e = pq_getmsgbyte(buf);
     273             :     }
     274             : 
     275           0 :     addr->f = pq_getmsgbyte(buf);
     276           0 :     addr->g = pq_getmsgbyte(buf);
     277           0 :     addr->h = pq_getmsgbyte(buf);
     278             : 
     279           0 :     PG_RETURN_MACADDR8_P(addr);
     280             : }
     281             : 
     282             : /*
     283             :  * macaddr8_send - converts macaddr8(EUI-64) to binary format
     284             :  */
     285             : Datum
     286           0 : macaddr8_send(PG_FUNCTION_ARGS)
     287             : {
     288           0 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     289             :     StringInfoData buf;
     290             : 
     291           0 :     pq_begintypsend(&buf);
     292           0 :     pq_sendbyte(&buf, addr->a);
     293           0 :     pq_sendbyte(&buf, addr->b);
     294           0 :     pq_sendbyte(&buf, addr->c);
     295           0 :     pq_sendbyte(&buf, addr->d);
     296           0 :     pq_sendbyte(&buf, addr->e);
     297           0 :     pq_sendbyte(&buf, addr->f);
     298           0 :     pq_sendbyte(&buf, addr->g);
     299           0 :     pq_sendbyte(&buf, addr->h);
     300             : 
     301           0 :     PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
     302             : }
     303             : 
     304             : 
     305             : /*
     306             :  * macaddr8_cmp_internal - comparison function for sorting:
     307             :  */
     308             : static int32
     309       49762 : macaddr8_cmp_internal(macaddr8 *a1, macaddr8 *a2)
     310             : {
     311       49762 :     if (hibits(a1) < hibits(a2))
     312       22206 :         return -1;
     313       27556 :     else if (hibits(a1) > hibits(a2))
     314       20618 :         return 1;
     315        6938 :     else if (lobits(a1) < lobits(a2))
     316         222 :         return -1;
     317        6716 :     else if (lobits(a1) > lobits(a2))
     318          24 :         return 1;
     319             :     else
     320        6692 :         return 0;
     321             : }
     322             : 
     323             : Datum
     324       14506 : macaddr8_cmp(PG_FUNCTION_ARGS)
     325             : {
     326       14506 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     327       14506 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     328             : 
     329       14506 :     PG_RETURN_INT32(macaddr8_cmp_internal(a1, a2));
     330             : }
     331             : 
     332             : /*
     333             :  * Boolean comparison functions.
     334             :  */
     335             : 
     336             : Datum
     337       16012 : macaddr8_lt(PG_FUNCTION_ARGS)
     338             : {
     339       16012 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     340       16012 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     341             : 
     342       16012 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) < 0);
     343             : }
     344             : 
     345             : Datum
     346        3692 : macaddr8_le(PG_FUNCTION_ARGS)
     347             : {
     348        3692 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     349        3692 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     350             : 
     351        3692 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) <= 0);
     352             : }
     353             : 
     354             : Datum
     355        6410 : macaddr8_eq(PG_FUNCTION_ARGS)
     356             : {
     357        6410 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     358        6410 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     359             : 
     360        6410 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) == 0);
     361             : }
     362             : 
     363             : Datum
     364        2996 : macaddr8_ge(PG_FUNCTION_ARGS)
     365             : {
     366        2996 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     367        2996 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     368             : 
     369        2996 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) >= 0);
     370             : }
     371             : 
     372             : Datum
     373        6134 : macaddr8_gt(PG_FUNCTION_ARGS)
     374             : {
     375        6134 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     376        6134 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     377             : 
     378        6134 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) > 0);
     379             : }
     380             : 
     381             : Datum
     382          12 : macaddr8_ne(PG_FUNCTION_ARGS)
     383             : {
     384          12 :     macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);
     385          12 :     macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);
     386             : 
     387          12 :     PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) != 0);
     388             : }
     389             : 
     390             : /*
     391             :  * Support function for hash indexes on macaddr8.
     392             :  */
     393             : Datum
     394         180 : hashmacaddr8(PG_FUNCTION_ARGS)
     395             : {
     396         180 :     macaddr8   *key = PG_GETARG_MACADDR8_P(0);
     397             : 
     398         180 :     return hash_any((unsigned char *) key, sizeof(macaddr8));
     399             : }
     400             : 
     401             : Datum
     402          60 : hashmacaddr8extended(PG_FUNCTION_ARGS)
     403             : {
     404          60 :     macaddr8   *key = PG_GETARG_MACADDR8_P(0);
     405             : 
     406          60 :     return hash_any_extended((unsigned char *) key, sizeof(macaddr8),
     407          60 :                              PG_GETARG_INT64(1));
     408             : }
     409             : 
     410             : /*
     411             :  * Arithmetic functions: bitwise NOT, AND, OR.
     412             :  */
     413             : Datum
     414         120 : macaddr8_not(PG_FUNCTION_ARGS)
     415             : {
     416         120 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     417             :     macaddr8   *result;
     418             : 
     419         120 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     420         120 :     result->a = ~addr->a;
     421         120 :     result->b = ~addr->b;
     422         120 :     result->c = ~addr->c;
     423         120 :     result->d = ~addr->d;
     424         120 :     result->e = ~addr->e;
     425         120 :     result->f = ~addr->f;
     426         120 :     result->g = ~addr->g;
     427         120 :     result->h = ~addr->h;
     428             : 
     429         120 :     PG_RETURN_MACADDR8_P(result);
     430             : }
     431             : 
     432             : Datum
     433         120 : macaddr8_and(PG_FUNCTION_ARGS)
     434             : {
     435         120 :     macaddr8   *addr1 = PG_GETARG_MACADDR8_P(0);
     436         120 :     macaddr8   *addr2 = PG_GETARG_MACADDR8_P(1);
     437             :     macaddr8   *result;
     438             : 
     439         120 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     440         120 :     result->a = addr1->a & addr2->a;
     441         120 :     result->b = addr1->b & addr2->b;
     442         120 :     result->c = addr1->c & addr2->c;
     443         120 :     result->d = addr1->d & addr2->d;
     444         120 :     result->e = addr1->e & addr2->e;
     445         120 :     result->f = addr1->f & addr2->f;
     446         120 :     result->g = addr1->g & addr2->g;
     447         120 :     result->h = addr1->h & addr2->h;
     448             : 
     449         120 :     PG_RETURN_MACADDR8_P(result);
     450             : }
     451             : 
     452             : Datum
     453         120 : macaddr8_or(PG_FUNCTION_ARGS)
     454             : {
     455         120 :     macaddr8   *addr1 = PG_GETARG_MACADDR8_P(0);
     456         120 :     macaddr8   *addr2 = PG_GETARG_MACADDR8_P(1);
     457             :     macaddr8   *result;
     458             : 
     459         120 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     460         120 :     result->a = addr1->a | addr2->a;
     461         120 :     result->b = addr1->b | addr2->b;
     462         120 :     result->c = addr1->c | addr2->c;
     463         120 :     result->d = addr1->d | addr2->d;
     464         120 :     result->e = addr1->e | addr2->e;
     465         120 :     result->f = addr1->f | addr2->f;
     466         120 :     result->g = addr1->g | addr2->g;
     467         120 :     result->h = addr1->h | addr2->h;
     468             : 
     469         120 :     PG_RETURN_MACADDR8_P(result);
     470             : }
     471             : 
     472             : /*
     473             :  * Truncation function to allow comparing macaddr8 manufacturers.
     474             :  */
     475             : Datum
     476         120 : macaddr8_trunc(PG_FUNCTION_ARGS)
     477             : {
     478         120 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     479             :     macaddr8   *result;
     480             : 
     481         120 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     482             : 
     483         120 :     result->a = addr->a;
     484         120 :     result->b = addr->b;
     485         120 :     result->c = addr->c;
     486         120 :     result->d = 0;
     487         120 :     result->e = 0;
     488         120 :     result->f = 0;
     489         120 :     result->g = 0;
     490         120 :     result->h = 0;
     491             : 
     492         120 :     PG_RETURN_MACADDR8_P(result);
     493             : }
     494             : 
     495             : /*
     496             :  * Set 7th bit for modified EUI-64 as used in IPv6.
     497             :  */
     498             : Datum
     499           6 : macaddr8_set7bit(PG_FUNCTION_ARGS)
     500             : {
     501           6 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     502             :     macaddr8   *result;
     503             : 
     504           6 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     505             : 
     506           6 :     result->a = addr->a | 0x02;
     507           6 :     result->b = addr->b;
     508           6 :     result->c = addr->c;
     509           6 :     result->d = addr->d;
     510           6 :     result->e = addr->e;
     511           6 :     result->f = addr->f;
     512           6 :     result->g = addr->g;
     513           6 :     result->h = addr->h;
     514             : 
     515           6 :     PG_RETURN_MACADDR8_P(result);
     516             : }
     517             : 
     518             : /*----------------------------------------------------------
     519             :  *  Conversion operators.
     520             :  *---------------------------------------------------------*/
     521             : 
     522             : Datum
     523           0 : macaddrtomacaddr8(PG_FUNCTION_ARGS)
     524             : {
     525           0 :     macaddr    *addr6 = PG_GETARG_MACADDR_P(0);
     526             :     macaddr8   *result;
     527             : 
     528           0 :     result = (macaddr8 *) palloc0(sizeof(macaddr8));
     529             : 
     530           0 :     result->a = addr6->a;
     531           0 :     result->b = addr6->b;
     532           0 :     result->c = addr6->c;
     533           0 :     result->d = 0xFF;
     534           0 :     result->e = 0xFE;
     535           0 :     result->f = addr6->d;
     536           0 :     result->g = addr6->e;
     537           0 :     result->h = addr6->f;
     538             : 
     539             : 
     540           0 :     PG_RETURN_MACADDR8_P(result);
     541             : }
     542             : 
     543             : Datum
     544          24 : macaddr8tomacaddr(PG_FUNCTION_ARGS)
     545             : {
     546          24 :     macaddr8   *addr = PG_GETARG_MACADDR8_P(0);
     547             :     macaddr    *result;
     548             : 
     549          24 :     result = (macaddr *) palloc0(sizeof(macaddr));
     550             : 
     551          24 :     if ((addr->d != 0xFF) || (addr->e != 0xFE))
     552           0 :         ereport(ERROR,
     553             :                 (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
     554             :                  errmsg("macaddr8 data out of range to convert to macaddr"),
     555             :                  errhint("Only addresses that have FF and FE as values in the "
     556             :                          "4th and 5th bytes from the left, for example "
     557             :                          "xx:xx:xx:ff:fe:xx:xx:xx, are eligible to be converted "
     558             :                          "from macaddr8 to macaddr.")));
     559             : 
     560          24 :     result->a = addr->a;
     561          24 :     result->b = addr->b;
     562          24 :     result->c = addr->c;
     563          24 :     result->d = addr->f;
     564          24 :     result->e = addr->g;
     565          24 :     result->f = addr->h;
     566             : 
     567          24 :     PG_RETURN_MACADDR_P(result);
     568             : }

Generated by: LCOV version 1.14