rdelaage
/
postgresql
mirror of https://git.postgresql.org/git/postgresql.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
postgresql/src/backend/utils/adt/network.c

977 lines
19 KiB
C
Raw Normal View History

INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
/*
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* PostgreSQL type definitions for the INET and CIDR types.
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
*
pgindent run.
2003-08-04 02:43:34 +02:00
* $Header: /cvsroot/pgsql/src/backend/utils/adt/network.c,v 1.45 2003/08/04 00:43:25 momjian Exp $
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
*
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
* Jon Postel RIP 16 Oct 1998
*/
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
#include "postgres.h"
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
#include <errno.h>
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
#include <sys/socket.h>
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
#include <netinet/in.h>
#include <arpa/inet.h>
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
#include "catalog/pg_type.h"
More binary I/O routines.
2003-05-13 20:03:08 +02:00
#include "libpq/pqformat.h"
Change #include's to use <> and "" as appropriate.
1999-07-16 01:04:24 +02:00
#include "utils/builtins.h"
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
#include "utils/inet.h"
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
static Datum text_network(text *src, int type);
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
static int32 network_cmp_internal(inet *a1, inet *a2);
pgindent run.
2003-08-04 02:43:34 +02:00
static int bitncmp(void *l, void *r, int n);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
static bool addressOK(unsigned char *a, int bits, int family);
pgindent run.
2003-08-04 02:43:34 +02:00
static int ip_addrsize(inet *inetptr);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
/*
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* Access macros.
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
*/
#define ip_family(inetptr) \
(((inet_struct *)VARDATA(inetptr))->family)
#define ip_bits(inetptr) \
(((inet_struct *)VARDATA(inetptr))->bits)
#define ip_type(inetptr) \
(((inet_struct *)VARDATA(inetptr))->type)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
#define ip_addr(inetptr) \
(((inet_struct *)VARDATA(inetptr))->ip_addr)
#define ip_maxbits(inetptr) \
(ip_family(inetptr) == PGSQL_AF_INET ? 32 : 128)
/*
* Return the number of bytes of storage needed for this data type.
*/
static int
ip_addrsize(inet *inetptr)
{
pgindent run.
2003-08-04 02:43:34 +02:00
switch (ip_family(inetptr))
{
case PGSQL_AF_INET:
return 4;
case PGSQL_AF_INET6:
return 16;
default:
return -1;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
}
}
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
/* Common input routine */
static inet *
network_in(char *src, int type)
{
pgindent run.
2003-08-04 02:43:34 +02:00
int bits;
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
inet *dst;
Add new palloc0 call as merge of palloc and MemSet(0).
2002-11-13 01:39:48 +01:00
dst = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* First, check to see if this is an IPv6 or IPv4 address. IPv6
* addresses will have a : somewhere in them (several, in fact) so if
* there is one present, assume it's V6, otherwise assume it's V4.
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
*/
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
if (strchr(src, ':') != NULL)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
ip_family(dst) = PGSQL_AF_INET6;
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
ip_family(dst) = PGSQL_AF_INET;
pgindent run.
2003-08-04 02:43:34 +02:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
bits = inet_net_pton(ip_family(dst), src, ip_addr(dst),
pgindent run.
2003-08-04 02:43:34 +02:00
type ? ip_addrsize(dst) : -1);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if ((bits < 0) || (bits > ip_maxbits(dst)))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
pgindent run.
2003-08-04 02:43:34 +02:00
/* translator: first %s is inet or cidr */
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
errmsg("invalid input syntax for %s: \"%s\"",
pgindent run.
2003-08-04 02:43:34 +02:00
type ? "cidr" : "inet", src)));
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Error check: CIDR values must not have any bits set beyond the
* masklen.
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
*/
if (type)
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (!addressOK(ip_addr(dst), bits, ip_family(dst)))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid cidr value: \"%s\"", src),
errdetail("Value has bits set to right of mask.")));
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
}
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
TOAST WARNING: This is actually broken - we have self-deadlocks due to concurrent changes in buffer management. Vadim and me are working on it. Jan
2000-07-04 01:10:14 +02:00
VARATT_SIZEP(dst) = VARHDRSZ
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
+ ((char *) ip_addr(dst) - (char *) VARDATA(dst))
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
+ ip_addrsize(dst);
ip_bits(dst) = bits;
ip_type(dst) = type;
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
return dst;
}
/* INET address reader. */
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
inet_in(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
char *src = PG_GETARG_CSTRING(0);
PG_RETURN_INET_P(network_in(src, 0));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
/* CIDR address reader. */
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
cidr_in(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
char *src = PG_GETARG_CSTRING(0);
PG_RETURN_INET_P(network_in(src, 1));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
/*
* INET address output function.
*/
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
inet_out(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *src = PG_GETARG_INET_P(0);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
char *dst;
Change default output formatting for CIDR to be unabbreviated, per recommendation from Paul Vixie. Add a new abbrev() function to produce abbreviated format as text. No forced initdb, but new function is not available unless you do an initdb or add the pg_proc row manually.
2000-12-22 19:00:24 +01:00
int len;
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
dst = inet_net_ntop(ip_family(src), ip_addr(src), ip_bits(src),
pgindent run.
2003-08-04 02:43:34 +02:00
tmp, sizeof(tmp));
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (dst == NULL)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format inet value: %m")));
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
/* For CIDR, add /n if not present */
if (ip_type(src) && strchr(tmp, '/') == NULL)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
len = strlen(tmp);
snprintf(tmp + len, sizeof(tmp) - len, "/%u", ip_bits(src));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_CSTRING(pstrdup(tmp));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
/* share code with INET case */
Datum
cidr_out(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
return inet_out(fcinfo);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
More binary I/O routines.
2003-05-13 20:03:08 +02:00
/*
* inet_recv - converts external binary format to inet
*
* The external representation is (one byte apiece for)
* family, bits, type, address length, address in network byte order.
*/
Datum
inet_recv(PG_FUNCTION_ARGS)
{
StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
inet *addr;
char *addrptr;
int bits;
int nb,
i;
/* make sure any unused bits in a CIDR value are zeroed */
addr = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
ip_family(addr) = pq_getmsgbyte(buf);
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
if (ip_family(addr) != PGSQL_AF_INET &&
ip_family(addr) != PGSQL_AF_INET6)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid family in external inet")));
More binary I/O routines.
2003-05-13 20:03:08 +02:00
bits = pq_getmsgbyte(buf);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (bits < 0 || bits > ip_maxbits(addr))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid bits in external inet")));
More binary I/O routines.
2003-05-13 20:03:08 +02:00
ip_bits(addr) = bits;
ip_type(addr) = pq_getmsgbyte(buf);
if (ip_type(addr) != 0 && ip_type(addr) != 1)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid type in external inet")));
More binary I/O routines.
2003-05-13 20:03:08 +02:00
nb = pq_getmsgbyte(buf);
if (nb != ip_addrsize(addr))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid length in external inet")));
More binary I/O routines.
2003-05-13 20:03:08 +02:00
VARATT_SIZEP(addr) = VARHDRSZ
pgindent run.
2003-08-04 02:43:34 +02:00
+ ((char *) ip_addr(addr) - (char *) VARDATA(addr))
More binary I/O routines.
2003-05-13 20:03:08 +02:00
+ ip_addrsize(addr);
pgindent run.
2003-08-04 02:43:34 +02:00
addrptr = (char *) ip_addr(addr);
More binary I/O routines.
2003-05-13 20:03:08 +02:00
for (i = 0; i < nb; i++)
addrptr[i] = pq_getmsgbyte(buf);
/*
* Error check: CIDR values must not have any bits set beyond the
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
* masklen.
More binary I/O routines.
2003-05-13 20:03:08 +02:00
*/
if (ip_type(addr))
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (!addressOK(ip_addr(addr), bits, ip_family(addr)))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("invalid external CIDR value"),
errdetail("Value has bits set to right of mask.")));
More binary I/O routines.
2003-05-13 20:03:08 +02:00
}
PG_RETURN_INET_P(addr);
}
/* share code with INET case */
Datum
cidr_recv(PG_FUNCTION_ARGS)
{
return inet_recv(fcinfo);
}
/*
* inet_send - converts inet to binary format
*/
Datum
inet_send(PG_FUNCTION_ARGS)
{
inet *addr = PG_GETARG_INET_P(0);
StringInfoData buf;
char *addrptr;
int nb,
i;
pq_begintypsend(&buf);
pq_sendbyte(&buf, ip_family(addr));
pq_sendbyte(&buf, ip_bits(addr));
pq_sendbyte(&buf, ip_type(addr));
nb = ip_addrsize(addr);
if (nb < 0)
nb = 0;
pq_sendbyte(&buf, nb);
pgindent run.
2003-08-04 02:43:34 +02:00
addrptr = (char *) ip_addr(addr);
More binary I/O routines.
2003-05-13 20:03:08 +02:00
for (i = 0; i < nb; i++)
pq_sendbyte(&buf, addrptr[i]);
PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}
/* share code with INET case */
Datum
cidr_send(PG_FUNCTION_ARGS)
{
return inet_send(fcinfo);
}
Fix confusion over static-ness of a subroutine.
2001-08-27 22:03:38 +02:00
static Datum
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
text_network(text *src, int type)
{
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
int len = VARSIZE(src) - VARHDRSZ;
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
char *str = palloc(len + 1);
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
memcpy(str, VARDATA(src), len);
*(str + len) = '\0';
PG_RETURN_INET_P(network_in(str, type));
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
Datum
text_cidr(PG_FUNCTION_ARGS)
{
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
return text_network(PG_GETARG_TEXT_P(0), 1);
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
}
Datum
text_inet(PG_FUNCTION_ARGS)
{
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
return text_network(PG_GETARG_TEXT_P(0), 0);
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
}
Datum
inet_set_masklen(PG_FUNCTION_ARGS)
{
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
inet *src = PG_GETARG_INET_P(0);
int bits = PG_GETARG_INT32(1);
inet *dst;
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
pgindent run.
2003-08-04 02:43:34 +02:00
if (bits == -1)
bits = ip_maxbits(src);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if ((bits < 0) || (bits > ip_maxbits(src)))
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
errmsg("invalid mask length: %d", bits)));
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
/* clone the original data */
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
dst = (inet *) palloc(VARHDRSZ + sizeof(inet_struct));
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
memcpy(dst, src, VARHDRSZ + sizeof(inet_struct));
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
ip_bits(dst) = bits;
Attached is a patch adding following functions: inet(text), cidr(text): convert a text value into inet/cidr set_masklen(inet): set masklen on the inet value Patch also contains regression checks for these functions. Alex Pilosov
2001-06-13 23:09:00 +02:00
PG_RETURN_INET_P(dst);
}
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
/*
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
* Basic comparison function for sorting and inet/cidr comparisons.
*
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
* Comparison is first on the common bits of the network part, then on
* the length of the network part, and then on the whole unmasked address.
* The effect is that the network part is the major sort key, and for
* equal network parts we sort on the host part. Note this is only sane
* for CIDR if address bits to the right of the mask are guaranteed zero;
* otherwise logically-equal CIDRs might compare different.
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
*/
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
static int32
network_cmp_internal(inet *a1, inet *a2)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_family(a1) == ip_family(a2))
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
{
pgindent run. Make it all clean.
2001-03-22 05:01:46 +01:00
int order;
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
order = bitncmp(ip_addr(a1), ip_addr(a2),
pgindent run.
2003-08-04 02:43:34 +02:00
Min(ip_bits(a1), ip_bits(a2)));
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
if (order != 0)
return order;
order = ((int) ip_bits(a1)) - ((int) ip_bits(a2));
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
if (order != 0)
return order;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
return bitncmp(ip_addr(a1), ip_addr(a2), ip_maxbits(a1));
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
return ip_family(a1) - ip_family(a2);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_cmp(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_INT32(network_cmp_internal(a1, a2));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
/*
* Boolean ordering tests.
*/
Datum
network_lt(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_BOOL(network_cmp_internal(a1, a2) < 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_le(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_BOOL(network_cmp_internal(a1, a2) <= 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_eq(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_BOOL(network_cmp_internal(a1, a2) == 0);
}
Datum
network_ge(PG_FUNCTION_ARGS)
{
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_BOOL(network_cmp_internal(a1, a2) >= 0);
}
Datum
network_gt(PG_FUNCTION_ARGS)
{
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_BOOL(network_cmp_internal(a1, a2) > 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_ne(PG_FUNCTION_ARGS)
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
PG_RETURN_BOOL(network_cmp_internal(a1, a2) != 0);
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
/*
* Boolean network-inclusion tests.
*/
Datum
network_sub(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
pgindent run over code.
1999-05-25 18:15:34 +02:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_family(a1) == ip_family(a2))
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_BOOL(ip_bits(a1) > ip_bits(a2)
pgindent run.
2003-08-04 02:43:34 +02:00
&& bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a2)) == 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
PG_RETURN_BOOL(false);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_subeq(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_family(a1) == ip_family(a2))
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_BOOL(ip_bits(a1) >= ip_bits(a2)
pgindent run.
2003-08-04 02:43:34 +02:00
&& bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a2)) == 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
PG_RETURN_BOOL(false);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_sup(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_family(a1) == ip_family(a2))
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_BOOL(ip_bits(a1) < ip_bits(a2)
pgindent run.
2003-08-04 02:43:34 +02:00
&& bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a1)) == 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
PG_RETURN_BOOL(false);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_supeq(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *a1 = PG_GETARG_INET_P(0);
inet *a2 = PG_GETARG_INET_P(1);
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_family(a1) == ip_family(a2))
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_BOOL(ip_bits(a1) <= ip_bits(a2)
pgindent run.
2003-08-04 02:43:34 +02:00
&& bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a1)) == 0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
PG_RETURN_BOOL(false);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
/*
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
* Extract data from a network datatype.
Oops, commited a test version of this file by accident. Revert.
2000-02-21 19:49:54 +01:00
*/
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Datum
network_host(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
inet *ip = PG_GETARG_INET_P(0);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
text *ret;
int len;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
char *ptr;
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
/* force display of max bits, regardless of masklen... */
if (inet_net_ntop(ip_family(ip), ip_addr(ip), ip_maxbits(ip),
pgindent run.
2003-08-04 02:43:34 +02:00
tmp, sizeof(tmp)) == NULL)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format inet value: %m")));
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
/* Suppress /n if present (shouldn't happen now) */
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
if ((ptr = strchr(tmp, '/')) != NULL)
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
*ptr = '\0';
/* Return string as a text datum */
len = strlen(tmp);
ret = (text *) palloc(len + VARHDRSZ);
VARATT_SIZEP(ret) = len + VARHDRSZ;
memcpy(VARDATA(ret), tmp, len);
PG_RETURN_TEXT_P(ret);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
Datum
network_show(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
text *ret;
int len;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (inet_net_ntop(ip_family(ip), ip_addr(ip), ip_maxbits(ip),
pgindent run.
2003-08-04 02:43:34 +02:00
tmp, sizeof(tmp)) == NULL)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format inet value: %m")));
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
/* Add /n if not present (which it won't be) */
if (strchr(tmp, '/') == NULL)
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
len = strlen(tmp);
snprintf(tmp + len, sizeof(tmp) - len, "/%u", ip_bits(ip));
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
}
Change default output formatting for CIDR to be unabbreviated, per recommendation from Paul Vixie. Add a new abbrev() function to produce abbreviated format as text. No forced initdb, but new function is not available unless you do an initdb or add the pg_proc row manually.
2000-12-22 19:00:24 +01:00
/* Return string as a text datum */
len = strlen(tmp);
ret = (text *) palloc(len + VARHDRSZ);
VARATT_SIZEP(ret) = len + VARHDRSZ;
memcpy(VARDATA(ret), tmp, len);
PG_RETURN_TEXT_P(ret);
}
Datum
network_abbrev(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
text *ret;
char *dst;
int len;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
char tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
Change default output formatting for CIDR to be unabbreviated, per recommendation from Paul Vixie. Add a new abbrev() function to produce abbreviated format as text. No forced initdb, but new function is not available unless you do an initdb or add the pg_proc row manually.
2000-12-22 19:00:24 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (ip_type(ip))
dst = inet_cidr_ntop(ip_family(ip), ip_addr(ip),
pgindent run.
2003-08-04 02:43:34 +02:00
ip_bits(ip), tmp, sizeof(tmp));
Change default output formatting for CIDR to be unabbreviated, per recommendation from Paul Vixie. Add a new abbrev() function to produce abbreviated format as text. No forced initdb, but new function is not available unless you do an initdb or add the pg_proc row manually.
2000-12-22 19:00:24 +01:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
dst = inet_net_ntop(ip_family(ip), ip_addr(ip),
pgindent run.
2003-08-04 02:43:34 +02:00
ip_bits(ip), tmp, sizeof(tmp));
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (dst == NULL)
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
ereport(ERROR,
(errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
errmsg("could not format inet value: %m")));
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
/* Return string as a text datum */
len = strlen(tmp);
ret = (text *) palloc(len + VARHDRSZ);
VARATT_SIZEP(ret) = len + VARHDRSZ;
memcpy(VARDATA(ret), tmp, len);
PG_RETURN_TEXT_P(ret);
}
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
Datum
network_masklen(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
inet *ip = PG_GETARG_INET_P(0);
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Convert inet-related functions to new fmgr style. I have also taken it on myself to do something about the non-self-consistency of the inet comparison functions. The results are probably still semantically wrong (inet and cidr should have different comparison semantics, I think) but at least the boolean operators now agree with each other and with the sort order of indexes on inet/cidr.
2000-08-04 01:07:51 +02:00
PG_RETURN_INT32(ip_bits(ip));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
Datum
network_family(PG_FUNCTION_ARGS)
{
pgindent run.
2003-08-04 02:43:34 +02:00
inet *ip = PG_GETARG_INET_P(0);
switch (ip_family(ip))
{
case PGSQL_AF_INET:
PG_RETURN_INT32(4);
break;
case PGSQL_AF_INET6:
PG_RETURN_INT32(6);
break;
default:
PG_RETURN_INT32(0);
break;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
}
}
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Datum
network_broadcast(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
inet *ip = PG_GETARG_INET_P(0);
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
inet *dst;
pgindent run.
2003-08-04 02:43:34 +02:00
int byte;
int bits;
int maxbytes;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
unsigned char mask;
pgindent run.
2003-08-04 02:43:34 +02:00
unsigned char *a,
*b;
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
/* make sure any unused bits are zeroed */
Add new palloc0 call as merge of palloc and MemSet(0).
2002-11-13 01:39:48 +01:00
dst = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
pgindent run.
2003-08-04 02:43:34 +02:00
if (ip_family(ip) == PGSQL_AF_INET)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 4;
pgindent run.
2003-08-04 02:43:34 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 16;
bits = ip_bits(ip);
a = ip_addr(ip);
b = ip_addr(dst);
pgindent run.
2003-08-04 02:43:34 +02:00
for (byte = 0; byte < maxbytes; byte++)
{
if (bits >= 8)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0x00;
bits -= 8;
pgindent run.
2003-08-04 02:43:34 +02:00
}
else if (bits == 0)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff;
pgindent run.
2003-08-04 02:43:34 +02:00
else
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff >> bits;
bits = 0;
}
b[byte] = a[byte] | mask;
pgindent run.
2003-08-04 02:43:34 +02:00
}
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
ip_family(dst) = ip_family(ip);
ip_bits(dst) = ip_bits(ip);
ip_type(dst) = 0;
VARATT_SIZEP(dst) = VARHDRSZ
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
+ ((char *) ip_addr(dst) - (char *) VARDATA(dst))
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
+ ip_addrsize(dst);
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
PG_RETURN_INET_P(dst);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Datum
network_network(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
inet *ip = PG_GETARG_INET_P(0);
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
inet *dst;
pgindent run.
2003-08-04 02:43:34 +02:00
int byte;
int bits;
int maxbytes;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
unsigned char mask;
pgindent run.
2003-08-04 02:43:34 +02:00
unsigned char *a,
*b;
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
/* make sure any unused bits are zeroed */
Add new palloc0 call as merge of palloc and MemSet(0).
2002-11-13 01:39:48 +01:00
dst = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
pgindent run.
2003-08-04 02:43:34 +02:00
if (ip_family(ip) == PGSQL_AF_INET)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 4;
pgindent run.
2003-08-04 02:43:34 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 16;
bits = ip_bits(ip);
a = ip_addr(ip);
b = ip_addr(dst);
byte = 0;
pgindent run.
2003-08-04 02:43:34 +02:00
while (bits)
{
if (bits >= 8)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff;
bits -= 8;
pgindent run.
2003-08-04 02:43:34 +02:00
}
else
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff << (8 - bits);
bits = 0;
}
b[byte] = a[byte] & mask;
byte++;
pgindent run.
2003-08-04 02:43:34 +02:00
}
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
ip_family(dst) = ip_family(ip);
ip_bits(dst) = ip_bits(ip);
ip_type(dst) = 1;
VARATT_SIZEP(dst) = VARHDRSZ
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
+ ((char *) ip_addr(dst) - (char *) VARDATA(dst))
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
+ ip_addrsize(dst);
PG_RETURN_INET_P(dst);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Datum
network_netmask(PG_FUNCTION_ARGS)
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
{
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
inet *ip = PG_GETARG_INET_P(0);
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
inet *dst;
pgindent run.
2003-08-04 02:43:34 +02:00
int byte;
int bits;
int maxbytes;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
unsigned char mask;
unsigned char *b;
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
/* make sure any unused bits are zeroed */
Add new palloc0 call as merge of palloc and MemSet(0).
2002-11-13 01:39:48 +01:00
dst = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
pgindent run.
2003-08-04 02:43:34 +02:00
if (ip_family(ip) == PGSQL_AF_INET)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 4;
pgindent run.
2003-08-04 02:43:34 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 16;
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
bits = ip_bits(ip);
b = ip_addr(dst);
byte = 0;
pgindent run.
2003-08-04 02:43:34 +02:00
while (bits)
{
if (bits >= 8)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff;
bits -= 8;
pgindent run.
2003-08-04 02:43:34 +02:00
}
else
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff << (8 - bits);
bits = 0;
}
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
b[byte] = mask;
byte++;
pgindent run.
2003-08-04 02:43:34 +02:00
}
Cleanup of NULL in inet types.
1999-03-22 06:00:57 +01:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
ip_family(dst) = ip_family(ip);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
ip_bits(dst) = ip_bits(ip);
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
ip_type(dst) = 0;
VARATT_SIZEP(dst) = VARHDRSZ
pgindent run.
2003-08-04 02:43:34 +02:00
+ ((char *) ip_addr(dst) - (char *) VARDATA(dst))
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
+ ip_addrsize(dst);
Functions on 'text' type updated to new fmgr style. 'text' is now TOAST-able.
2000-07-06 07:48:31 +02:00
Adjust INET/CIDR display conventions and reimplement some INET/CIDR functions, per recent discussions on pghackers. For now, I have called the verbose-display formatting function text(), but will reconsider if enough people object. initdb forced.
2000-11-10 21:13:27 +01:00
PG_RETURN_INET_P(dst);
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
}
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
Datum
network_hostmask(PG_FUNCTION_ARGS)
{
inet *ip = PG_GETARG_INET_P(0);
inet *dst;
pgindent run.
2003-08-04 02:43:34 +02:00
int byte;
int bits;
int maxbytes;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
unsigned char mask;
unsigned char *b;
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
/* make sure any unused bits are zeroed */
Fix compile warning.
2003-03-22 00:18:52 +01:00
dst = (inet *) palloc0(VARHDRSZ + sizeof(inet_struct));
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
pgindent run.
2003-08-04 02:43:34 +02:00
if (ip_family(ip) == PGSQL_AF_INET)
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 4;
pgindent run.
2003-08-04 02:43:34 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbytes = 16;
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
bits = ip_maxbits(ip) - ip_bits(ip);
b = ip_addr(dst);
byte = maxbytes - 1;
pgindent run.
2003-08-04 02:43:34 +02:00
while (bits)
{
if (bits >= 8)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff;
bits -= 8;
pgindent run.
2003-08-04 02:43:34 +02:00
}
else
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff >> (8 - bits);
bits = 0;
}
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
b[byte] = mask;
byte--;
pgindent run.
2003-08-04 02:43:34 +02:00
}
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
ip_family(dst) = ip_family(ip);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
ip_bits(dst) = ip_bits(ip);
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
ip_type(dst) = 0;
VARATT_SIZEP(dst) = VARHDRSZ
pgindent run.
2003-08-04 02:43:34 +02:00
+ ((char *) ip_addr(dst) - (char *) VARDATA(dst))
Add hostmask() function: + <entry><function>hostmask</function>(<type>inet</type>)</entry> + <entry><type>inet</type></entry> + <entry>construct hostmask for network</entry> + <entry><literal>hostmask('192.168.23.20/30')</literal></entry> + <entry><literal>0.0.0.3</literal></entry> Greg Wickham
2003-03-21 22:54:29 +01:00
+ ip_addrsize(dst);
PG_RETURN_INET_P(dst);
}
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
/*
* Convert a value of a network datatype to an approximate scalar value.
* This is used for estimating selectivities of inequality operators
* involving network types.
*
* Currently, inet/cidr values are simply converted to the IPv4 address;
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
* this will need more thought when IPv6 is supported too. MAC addresses
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
* are converted to their numeric equivalent as well (OK since we have a
* double to play in).
*/
double
convert_network_to_scalar(Datum value, Oid typid)
{
switch (typid)
{
case INETOID:
case CIDROID:
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
{
inet *ip = DatumGetInetP(value);
pgindent run.
2003-08-04 02:43:34 +02:00
int len;
double res;
int i;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
/*
pgindent run.
2003-08-04 02:43:34 +02:00
* Note that we don't use the full address here.
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
*/
if (ip_family(ip) == PGSQL_AF_INET)
len = 4;
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
else
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
len = 5;
res = ip_family(ip);
pgindent run.
2003-08-04 02:43:34 +02:00
for (i = 0; i < len; i++)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
res *= 256;
res += ip_addr(ip)[i];
}
return res;
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
break;
}
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
case MACADDROID:
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
{
macaddr *mac = DatumGetMacaddrP(value);
double res;
res = (mac->a << 16) | (mac->b << 8) | (mac->c);
res *= 256 * 256 * 256;
res += (mac->d << 16) | (mac->e << 8) | (mac->f);
return res;
}
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
}
/*
* Can't get here unless someone tries to use scalarltsel/scalargtsel
* on an operator with one network and one non-network operand.
*/
Error message editing in utils/adt. Again thanks to Joe Conway for doing the bulk of the heavy lifting ...
2003-07-27 06:53:12 +02:00
elog(ERROR, "unsupported type: %u", typid);
Teach convert_to_scalar about datatypes timetz, inet, cidr, macaddr.
2001-06-10 00:16:18 +02:00
return 0;
}
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
/*
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* int
* bitncmp(l, r, n)
pgindent run.
2003-08-04 02:43:34 +02:00
* compare bit masks l and r, for n bits.
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* return:
pgindent run.
2003-08-04 02:43:34 +02:00
* -1, 1, or 0 in the libc tradition.
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* note:
pgindent run.
2003-08-04 02:43:34 +02:00
* network byte order assumed. this means 192.5.5.240/28 has
* 0x11110000 in its fourth octet.
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* author:
pgindent run.
2003-08-04 02:43:34 +02:00
* Paul Vixie (ISC), June 1996
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
*/
static int
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
bitncmp(void *l, void *r, int n)
{
pgindent run.
2003-08-04 02:43:34 +02:00
u_int lb,
rb;
int x,
b;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
b = n / 8;
x = memcmp(l, r, b);
if (x)
return (x);
pgindent run.
2003-08-04 02:43:34 +02:00
lb = ((const u_char *) l)[b];
rb = ((const u_char *) r)[b];
for (b = n % 8; b > 0; b--)
{
if ((lb & 0x80) != (rb & 0x80))
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (lb & 0x80)
return (1);
return (-1);
}
lb <<= 1;
rb <<= 1;
}
INET/CIDR cleanup from D'Arcy.
1998-10-22 22:40:50 +02:00
return (0);
}
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
static bool
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
addressOK(unsigned char *a, int bits, int family)
{
pgindent run.
2003-08-04 02:43:34 +02:00
int byte;
int nbits;
int maxbits;
int maxbytes;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
unsigned char mask;
pgindent run.
2003-08-04 02:43:34 +02:00
if (family == PGSQL_AF_INET)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbits = 32;
maxbytes = 4;
pgindent run.
2003-08-04 02:43:34 +02:00
}
else
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
maxbits = 128;
maxbytes = 16;
}
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
Assert(bits <= maxbits);
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if (bits == maxbits)
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
return true;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
byte = (bits + 7) / 8;
nbits = bits % 8;
mask = 0xff;
if (bits != 0)
mask >>= nbits;
pgindent run.
2003-08-04 02:43:34 +02:00
while (byte < maxbytes)
{
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
if ((a[byte] & mask) != 0)
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
return false;
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
mask = 0xff;
byte++;
}
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
inet_recv() wasn't IPv6-ready.
2003-08-02 01:22:52 +02:00
return true;
Disallow bits beyond the mask length for CIDR values, per discussion on pghackers. Arrange for the sort ordering of general INET values to be network part as major sort key, host part as minor sort key. I did not force an initdb for this change, but anyone who's running indexes on general INET values may need to recreate those indexes.
2000-10-27 03:55:23 +02:00
}
Make inet/cidr << and <<= operators indexable. From Alex Pilosov <alex@pilosoft.com>.
2001-06-17 04:05:20 +02:00
/*
* These functions are used by planner to generate indexscan limits
* for clauses a << b and a <<= b
*/
/* return the minimal value for an IP on a given network */
Datum
network_scan_first(Datum in)
{
return DirectFunctionCall1(network_network, in);
}
/*
pgindent run on all C files. Java run to follow. initdb/regression tests pass.
2001-10-25 07:50:21 +02:00
* return "last" IP on a given network. It's the broadcast address,
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* however, masklen has to be set to its max btis, since
Make inet/cidr << and <<= operators indexable. From Alex Pilosov <alex@pilosoft.com>.
2001-06-17 04:05:20 +02:00
* 192.168.0.255/24 is considered less than 192.168.0.255/32
*
Add ipv6 address parsing support to 'inet' and 'cidr' data types. Regression tests for IPv6 operations added. Documentation updated to document IPv6 bits. Stop treating IPv4 as an "unsigned int" and IPv6 as an array of characters. Instead, always use the array of characters so we can have one function fits all. This makes bitncmp(), addressOK(), and several other functions "just work" on both address families. add family() function which returns integer 4 or 6 for IPv4 or IPv6. (See examples below) Note that to add this new function you will need to dump/initdb/reload or find the correct magic to add the function to the postgresql function catalogs. IPv4 addresses always sort before IPv6. On disk we use AF_INET for IPv4, and AF_INET+1 for IPv6 addresses. This prevents the need for a dump and reload, but lets IPv6 parsing work on machines without AF_INET6. To select all IPv4 addresses from a table: select * from foo where family(addr) = 4 ... Order by and other bits should all work. Michael Graff
2003-06-25 00:21:24 +02:00
* inet_set_masklen() hacked to max out the masklength to 128 for IPv6
* and 32 for IPv4 when given '-1' as argument.
Make inet/cidr << and <<= operators indexable. From Alex Pilosov <alex@pilosoft.com>.
2001-06-17 04:05:20 +02:00
*/
Datum
network_scan_last(Datum in)
{
return DirectFunctionCall2(inet_set_masklen,
DirectFunctionCall1(network_broadcast, in),
pgindent run.
2003-08-04 02:43:34 +02:00
Int32GetDatum(-1));
Make inet/cidr << and <<= operators indexable. From Alex Pilosov <alex@pilosoft.com>.
2001-06-17 04:05:20 +02:00
}