/*-------------------------------------------------------------------------

 *

 * mac8.c

 *    PostgreSQL type definitions for 8 byte (EUI-64) MAC addresses.

 *

 * EUI-48 (6 byte) MAC addresses are accepted as input and are stored in

 * EUI-64 format, with the 4th and 5th bytes set to FF and FE, respectively.

 *

 * Output is always in 8 byte (EUI-64) format.

 *

 * The following code is written with the assumption that the OUI field

 * size is 24 bits.

 *

 * Portions Copyright (c) 1998-2025, PostgreSQL Global Development Group

 *

 * IDENTIFICATION

 *      src/backend/utils/adt/mac8.c

 *

 *-------------------------------------------------------------------------

 */

#include "postgres.h"

#include "common/hashfn.h"

#include "libpq/pqformat.h"

#include "nodes/nodes.h"

#include "utils/fmgrprotos.h"

#include "utils/inet.h"

/*

 *  Utility macros used for sorting and comparing:

 */

#define hibits(addr) \

  ((unsigned long)(((addr)->a<<24) | ((addr)->b<<16) | ((addr)->c<<8) | ((addr)->d)))

#define lobits(addr) \

  ((unsigned long)(((addr)->e<<24) | ((addr)->f<<16) | ((addr)->g<<8) | ((addr)->h)))

static unsigned char hex2_to_uchar(const unsigned char *ptr, bool *badhex);

static const signed char hexlookup[128] = {

  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,

  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1,

  -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

};

/*

 * hex2_to_uchar - convert 2 hex digits to a byte (unsigned char)

 *

 * Sets *badhex to true if the end of the string is reached ('\0' found), or if

 * either character is not a valid hex digit.

 */

static inline unsigned char

hex2_to_uchar(const unsigned char *ptr, bool *badhex)

{

  unsigned char ret;

  signed char lookup;

  /* Handle the first character */

  if (*ptr > 127)

    goto invalid_input;

  lookup = hexlookup[*ptr];

  if (lookup < 0)

    goto invalid_input;

  ret = lookup << 4;

  /* Move to the second character */

  ptr++;

  if (*ptr > 127)

    goto invalid_input;

  lookup = hexlookup[*ptr];

  if (lookup < 0)

    goto invalid_input;

  ret += lookup;

  return ret;

invalid_input:

  *badhex = true;

  return 0;

}

/*

 * MAC address (EUI-48 and EUI-64) reader. Accepts several common notations.

 */

Datum

macaddr8_in(PG_FUNCTION_ARGS)

{

  const unsigned char *str = (unsigned char *) PG_GETARG_CSTRING(0);

  Node     *escontext = fcinfo->context;

  const unsigned char *ptr = str;

  bool    badhex = false;

  macaddr8   *result;

  unsigned char a = 0,

        b = 0,

        c = 0,

        d = 0,

        e = 0,

        f = 0,

        g = 0,

        h = 0;

  int     count = 0;

  unsigned char spacer = '\0';

  /* skip leading spaces */

  while (*ptr && isspace(*ptr))

    ptr++;

  /* digits must always come in pairs */

  while (*ptr && *(ptr + 1))

  {

    /*

     * Attempt to decode each byte, which must be 2 hex digits in a row.

     * If either digit is not hex, hex2_to_uchar will throw ereport() for

     * us.  Either 6 or 8 byte MAC addresses are supported.

     */

    /* Attempt to collect a byte */

    count++;

    switch (count)

    {

      case 1:

        a = hex2_to_uchar(ptr, &badhex);

        break;

      case 2:

        b = hex2_to_uchar(ptr, &badhex);

        break;

      case 3:

        c = hex2_to_uchar(ptr, &badhex);

        break;

      case 4:

        d = hex2_to_uchar(ptr, &badhex);

        break;

      case 5:

        e = hex2_to_uchar(ptr, &badhex);

        break;

      case 6:

        f = hex2_to_uchar(ptr, &badhex);

        break;

      case 7:

        g = hex2_to_uchar(ptr, &badhex);

        break;

      case 8:

        h = hex2_to_uchar(ptr, &badhex);

        break;

      default:

        /* must be trailing garbage... */

        goto fail;

    }

    if (badhex)

      goto fail;

    /* Move forward to where the next byte should be */

    ptr += 2;

    /* Check for a spacer, these are valid, anything else is not */

    if (*ptr == ':' || *ptr == '-' || *ptr == '.')

    {

      /* remember the spacer used, if it changes then it isn't valid */

      if (spacer == '\0')

        spacer = *ptr;

      /* Have to use the same spacer throughout */

      else if (spacer != *ptr)

        goto fail;

      /* move past the spacer */

      ptr++;

    }

    /* allow trailing whitespace after if we have 6 or 8 bytes */

    if (count == 6 || count == 8)

    {

      if (isspace(*ptr))

      {

        while (*++ptr && isspace(*ptr));

        /* If we found a space and then non-space, it's invalid */

        if (*ptr)

          goto fail;

      }

    }

  }

  /* Convert a 6 byte MAC address to macaddr8 */

  if (count == 6)

  {

    h = f;

    g = e;

    f = d;

    d = 0xFF;

    e = 0xFE;

  }

  else if (count != 8)

    goto fail;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = a;

  result->b = b;

  result->c = c;

  result->d = d;

  result->e = e;

  result->f = f;

  result->g = g;

  result->h = h;

  PG_RETURN_MACADDR8_P(result);

fail:

  ereturn(escontext, (Datum) 0,

      (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),

       errmsg("invalid input syntax for type %s: \"%s\"", "macaddr8",

          str)));

}

/*

 * MAC8 address (EUI-64) output function. Fixed format.

 */

Datum

macaddr8_out(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  char     *result;

  result = (char *) palloc(32);

  snprintf(result, 32, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x",

       addr->a, addr->b, addr->c, addr->d,

       addr->e, addr->f, addr->g, addr->h);

  PG_RETURN_CSTRING(result);

}

/*

 * macaddr8_recv - converts external binary format(EUI-48 and EUI-64) to macaddr8

 *

 * The external representation is just the eight bytes, MSB first.

 */

Datum

macaddr8_recv(PG_FUNCTION_ARGS)

{

  StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);

  macaddr8   *addr;

  addr = (macaddr8 *) palloc0(sizeof(macaddr8));

  addr->a = pq_getmsgbyte(buf);

  addr->b = pq_getmsgbyte(buf);

  addr->c = pq_getmsgbyte(buf);

  if (buf->len == 6)

  {

    addr->d = 0xFF;

    addr->e = 0xFE;

  }

  else

  {

    addr->d = pq_getmsgbyte(buf);

    addr->e = pq_getmsgbyte(buf);

  }

  addr->f = pq_getmsgbyte(buf);

  addr->g = pq_getmsgbyte(buf);

  addr->h = pq_getmsgbyte(buf);

  PG_RETURN_MACADDR8_P(addr);

}

/*

 * macaddr8_send - converts macaddr8(EUI-64) to binary format

 */

Datum

macaddr8_send(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  StringInfoData buf;

  pq_begintypsend(&buf);

  pq_sendbyte(&buf, addr->a);

  pq_sendbyte(&buf, addr->b);

  pq_sendbyte(&buf, addr->c);

  pq_sendbyte(&buf, addr->d);

  pq_sendbyte(&buf, addr->e);

  pq_sendbyte(&buf, addr->f);

  pq_sendbyte(&buf, addr->g);

  pq_sendbyte(&buf, addr->h);

  PG_RETURN_BYTEA_P(pq_endtypsend(&buf));

}

/*

 * macaddr8_cmp_internal - comparison function for sorting:

 */

static int32

macaddr8_cmp_internal(macaddr8 *a1, macaddr8 *a2)

{

  if (hibits(a1) < hibits(a2))

    return -1;

  else if (hibits(a1) > hibits(a2))

    return 1;

  else if (lobits(a1) < lobits(a2))

    return -1;

  else if (lobits(a1) > lobits(a2))

    return 1;

  else

    return 0;

}

Datum

macaddr8_cmp(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_INT32(macaddr8_cmp_internal(a1, a2));

}

/*

 * Boolean comparison functions.

 */

Datum

macaddr8_lt(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) < 0);

}

Datum

macaddr8_le(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) <= 0);

}

Datum

macaddr8_eq(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) == 0);

}

Datum

macaddr8_ge(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) >= 0);

}

Datum

macaddr8_gt(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) > 0);

}

Datum

macaddr8_ne(PG_FUNCTION_ARGS)

{

  macaddr8   *a1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *a2 = PG_GETARG_MACADDR8_P(1);

  PG_RETURN_BOOL(macaddr8_cmp_internal(a1, a2) != 0);

}

/*

 * Support function for hash indexes on macaddr8.

 */

Datum

hashmacaddr8(PG_FUNCTION_ARGS)

{

  macaddr8   *key = PG_GETARG_MACADDR8_P(0);

  return hash_any((unsigned char *) key, sizeof(macaddr8));

}

Datum

hashmacaddr8extended(PG_FUNCTION_ARGS)

{

  macaddr8   *key = PG_GETARG_MACADDR8_P(0);

  return hash_any_extended((unsigned char *) key, sizeof(macaddr8),

               PG_GETARG_INT64(1));

}

/*

 * Arithmetic functions: bitwise NOT, AND, OR.

 */

Datum

macaddr8_not(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = ~addr->a;

  result->b = ~addr->b;

  result->c = ~addr->c;

  result->d = ~addr->d;

  result->e = ~addr->e;

  result->f = ~addr->f;

  result->g = ~addr->g;

  result->h = ~addr->h;

  PG_RETURN_MACADDR8_P(result);

}

Datum

macaddr8_and(PG_FUNCTION_ARGS)

{

  macaddr8   *addr1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *addr2 = PG_GETARG_MACADDR8_P(1);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = addr1->a & addr2->a;

  result->b = addr1->b & addr2->b;

  result->c = addr1->c & addr2->c;

  result->d = addr1->d & addr2->d;

  result->e = addr1->e & addr2->e;

  result->f = addr1->f & addr2->f;

  result->g = addr1->g & addr2->g;

  result->h = addr1->h & addr2->h;

  PG_RETURN_MACADDR8_P(result);

}

Datum

macaddr8_or(PG_FUNCTION_ARGS)

{

  macaddr8   *addr1 = PG_GETARG_MACADDR8_P(0);

  macaddr8   *addr2 = PG_GETARG_MACADDR8_P(1);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = addr1->a | addr2->a;

  result->b = addr1->b | addr2->b;

  result->c = addr1->c | addr2->c;

  result->d = addr1->d | addr2->d;

  result->e = addr1->e | addr2->e;

  result->f = addr1->f | addr2->f;

  result->g = addr1->g | addr2->g;

  result->h = addr1->h | addr2->h;

  PG_RETURN_MACADDR8_P(result);

}

/*

 * Truncation function to allow comparing macaddr8 manufacturers.

 */

Datum

macaddr8_trunc(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = addr->a;

  result->b = addr->b;

  result->c = addr->c;

  result->d = 0;

  result->e = 0;

  result->f = 0;

  result->g = 0;

  result->h = 0;

  PG_RETURN_MACADDR8_P(result);

}

/*

 * Set 7th bit for modified EUI-64 as used in IPv6.

 */

Datum

macaddr8_set7bit(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = addr->a | 0x02;

  result->b = addr->b;

  result->c = addr->c;

  result->d = addr->d;

  result->e = addr->e;

  result->f = addr->f;

  result->g = addr->g;

  result->h = addr->h;

  PG_RETURN_MACADDR8_P(result);

}

/*----------------------------------------------------------

 *  Conversion operators.

 *---------------------------------------------------------*/

Datum

macaddrtomacaddr8(PG_FUNCTION_ARGS)

{

  macaddr    *addr6 = PG_GETARG_MACADDR_P(0);

  macaddr8   *result;

  result = (macaddr8 *) palloc0(sizeof(macaddr8));

  result->a = addr6->a;

  result->b = addr6->b;

  result->c = addr6->c;

  result->d = 0xFF;

  result->e = 0xFE;

  result->f = addr6->d;

  result->g = addr6->e;

  result->h = addr6->f;

  PG_RETURN_MACADDR8_P(result);

}

Datum

macaddr8tomacaddr(PG_FUNCTION_ARGS)

{

  macaddr8   *addr = PG_GETARG_MACADDR8_P(0);

  macaddr    *result;

  result = (macaddr *) palloc0(sizeof(macaddr));

  if ((addr->d != 0xFF) || (addr->e != 0xFE))

    ereport(ERROR,

        (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),

         errmsg("macaddr8 data out of range to convert to macaddr"),

         errhint("Only addresses that have FF and FE as values in the "

             "4th and 5th bytes from the left, for example "

             "xx:xx:xx:ff:fe:xx:xx:xx, are eligible to be converted "

             "from macaddr8 to macaddr.")));

  result->a = addr->a;

  result->b = addr->b;

  result->c = addr->c;

  result->d = addr->f;

  result->e = addr->g;

  result->f = addr->h;

  PG_RETURN_MACADDR_P(result);

}