From 8849655d24bf6d73102b92f900d6d78b6600dca2 Mon Sep 17 00:00:00 2001 From: Bruce Momjian Date: Thu, 8 Oct 1998 00:19:47 +0000 Subject: I agree. I think, though, that the best argument presented in the debate was from Paul Vixie, who wanted INET to be the name covering both IPV4 and IPV6. The following kit makes the needed changes: Tom Ivar Helbekkmo --- src/backend/utils/adt/inet.c | 287 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 287 insertions(+) create mode 100644 src/backend/utils/adt/inet.c (limited to 'src/backend/utils/adt/inet.c') diff --git a/src/backend/utils/adt/inet.c b/src/backend/utils/adt/inet.c new file mode 100644 index 00000000000..25e04362148 --- /dev/null +++ b/src/backend/utils/adt/inet.c @@ -0,0 +1,287 @@ +/* + * PostgreSQL type definitions for the INET type. This + * is for IP V4 CIDR notation, but prepared for V6: just + * add the necessary bits where the comments indicate. + * + * $Id: inet.c,v 1.1 1998/10/08 00:19:35 momjian Exp $ + */ + +#include +#include + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include + +static int v4bitncmp(unsigned int a1, unsigned int a2, int bits); + +/* + * Access macros. Add IPV6 support. + */ + +#define ip_addrsize(inetptr) \ + (((inet_struct *)VARDATA(inetptr))->family == AF_INET ? 4 : -1) + +#define ip_family(inetptr) \ + (((inet_struct *)VARDATA(inetptr))->family) + +#define ip_bits(inetptr) \ + (((inet_struct *)VARDATA(inetptr))->bits) + +#define ip_v4addr(inetptr) \ + (((inet_struct *)VARDATA(inetptr))->addr.ipv4_addr) + +/* + * IP address reader. + */ + +inet * +inet_in(char *src) +{ + int bits; + inet *dst; + + dst = palloc(VARHDRSZ + sizeof(inet_struct)); + if (dst == NULL) + { + elog(ERROR, "unable to allocate memory in inet_in()"); + return (NULL); + } + /* First, try for an IP V4 address: */ + ip_family(dst) = AF_INET; + bits = inet_net_pton(ip_family(dst), src, &ip_v4addr(dst), ip_addrsize(dst)); + if ((bits < 0) || (bits > 32)) + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "could not parse \"%s\"", src); + pfree(dst); + return (NULL); + } + VARSIZE(dst) = VARHDRSZ + + ((char *) &ip_v4addr(dst) - (char *) VARDATA(dst)) + + ip_addrsize(dst); + ip_bits(dst) = bits; + return (dst); +} + +/* + * IP address output function. + */ + +char * +inet_out(inet *src) +{ + char *dst, + tmp[sizeof("255.255.255.255/32")]; + + if (ip_family(src) == AF_INET) + { + /* It's an IP V4 address: */ + if (inet_net_ntop(AF_INET, &ip_v4addr(src), ip_bits(src), + tmp, sizeof(tmp)) < 0) + { + elog(ERROR, "unable to print address (%s)", strerror(errno)); + return (NULL); + } + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "unknown address family (%d)", ip_family(src)); + return (NULL); + } + dst = palloc(strlen(tmp) + 1); + if (dst == NULL) + { + elog(ERROR, "unable to allocate memory in inet_out()"); + return (NULL); + } + strcpy(dst, tmp); + return (dst); +} + +/* + * Boolean tests for magnitude. Add V4/V6 testing! + */ + +bool +inet_lt(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + int order = v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a2)); + + return ((order < 0) || ((order == 0) && (ip_bits(a1) < ip_bits(a2)))); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_le(inet *a1, inet *a2) +{ + return (inet_lt(a1, a2) || inet_eq(a1, a2)); +} + +bool +inet_eq(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + return ((ip_bits(a1) == ip_bits(a2)) + && (v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a1)) == 0)); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_ge(inet *a1, inet *a2) +{ + return (inet_gt(a1, a2) || inet_eq(a1, a2)); +} + +bool +inet_gt(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + int order = v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a2)); + + return ((order > 0) || ((order == 0) && (ip_bits(a1) > ip_bits(a2)))); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_ne(inet *a1, inet *a2) +{ + return (!inet_eq(a1, a2)); +} + +bool +inet_sub(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + return ((ip_bits(a1) > ip_bits(a2)) + && (v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a2)) == 0)); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_subeq(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + return ((ip_bits(a1) >= ip_bits(a2)) + && (v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a2)) == 0)); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_sup(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + return ((ip_bits(a1) < ip_bits(a2)) + && (v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a1)) == 0)); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +bool +inet_supeq(inet *a1, inet *a2) +{ + if ((ip_family(a1) == AF_INET) && (ip_family(a2) == AF_INET)) + { + return ((ip_bits(a1) <= ip_bits(a2)) + && (v4bitncmp(ip_v4addr(a1), ip_v4addr(a2), ip_bits(a1)) == 0)); + } + else + { + /* Go for an IPV6 address here, before faulting out: */ + elog(ERROR, "cannot compare address families %d and %d", + ip_family(a1), ip_family(a2)); + return (FALSE); + } +} + +/* + * Comparison function for sorting. Add V4/V6 testing! + */ + +int4 +inet_cmp(inet *a1, inet *a2) +{ + if (ntohl(ip_v4addr(a1)) < ntohl(ip_v4addr(a2))) + return (-1); + else if (ntohl(ip_v4addr(a1)) > ntohl(ip_v4addr(a2))) + return (1); + return 0; +} + +/* + * Bitwise comparison for V4 addresses. Add V6 implementation! + */ + +static int +v4bitncmp(unsigned int a1, unsigned int a2, int bits) +{ + unsigned long mask = 0; + int i; + + for (i = 0; i < bits; i++) + mask = (mask >> 1) | 0x80000000; + a1 = ntohl(a1); + a2 = ntohl(a2); + if ((a1 & mask) < (a2 & mask)) + return (-1); + else if ((a1 & mask) > (a2 & mask)) + return (1); + return (0); +} -- cgit v1.2.3