network.c File Reference

#include "postgres.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "access/stratnum.h"
#include "catalog/pg_opfamily.h"
#include "catalog/pg_type.h"
#include "common/hashfn.h"
#include "common/ip.h"
#include "lib/hyperloglog.h"
#include "libpq/libpq-be.h"
#include "libpq/pqformat.h"
#include "miscadmin.h"
#include "nodes/makefuncs.h"
#include "nodes/nodeFuncs.h"
#include "nodes/supportnodes.h"
#include "utils/builtins.h"
#include "utils/fmgroids.h"
#include "utils/guc.h"
#include "utils/inet.h"
#include "utils/lsyscache.h"
#include "utils/sortsupport.h"

Include dependency graph for network.c:

Go to the source code of this file.

Data Structures
struct	network_sortsupport_state

Macros
#define	ABBREV_BITS_INET4_NETMASK_SIZE   6
#define	ABBREV_BITS_INET4_SUBNET   25

Functions
static int32	network_cmp_internal (inet *a1, inet *a2)
static int	network_fast_cmp (Datum x, Datum y, SortSupport ssup)
static bool	network_abbrev_abort (int memtupcount, SortSupport ssup)
static Datum	network_abbrev_convert (Datum original, SortSupport ssup)
static List *	match_network_function (Node *leftop, Node *rightop, int indexarg, Oid funcid, Oid opfamily)
static List *	match_network_subset (Node *leftop, Node *rightop, bool is_eq, Oid opfamily)
static bool	addressOK (unsigned char *a, int bits, int family)
static inet *	internal_inetpl (inet *ip, int64 addend)
static inet *	network_in (char *src, bool is_cidr, Node *escontext)
Datum	inet_in (PG_FUNCTION_ARGS)
Datum	cidr_in (PG_FUNCTION_ARGS)
static char *	network_out (inet *src, bool is_cidr)
Datum	inet_out (PG_FUNCTION_ARGS)
Datum	cidr_out (PG_FUNCTION_ARGS)
static inet *	network_recv (StringInfo buf, bool is_cidr)
Datum	inet_recv (PG_FUNCTION_ARGS)
Datum	cidr_recv (PG_FUNCTION_ARGS)
static bytea *	network_send (inet *addr, bool is_cidr)
Datum	inet_send (PG_FUNCTION_ARGS)
Datum	cidr_send (PG_FUNCTION_ARGS)
Datum	inet_to_cidr (PG_FUNCTION_ARGS)
Datum	inet_set_masklen (PG_FUNCTION_ARGS)
Datum	cidr_set_masklen (PG_FUNCTION_ARGS)
inet *	cidr_set_masklen_internal (const inet *src, int bits)
Datum	network_cmp (PG_FUNCTION_ARGS)
Datum	network_sortsupport (PG_FUNCTION_ARGS)
Datum	network_lt (PG_FUNCTION_ARGS)
Datum	network_le (PG_FUNCTION_ARGS)
Datum	network_eq (PG_FUNCTION_ARGS)
Datum	network_ge (PG_FUNCTION_ARGS)
Datum	network_gt (PG_FUNCTION_ARGS)
Datum	network_ne (PG_FUNCTION_ARGS)
Datum	network_smaller (PG_FUNCTION_ARGS)
Datum	network_larger (PG_FUNCTION_ARGS)
Datum	hashinet (PG_FUNCTION_ARGS)
Datum	hashinetextended (PG_FUNCTION_ARGS)
Datum	network_sub (PG_FUNCTION_ARGS)
Datum	network_subeq (PG_FUNCTION_ARGS)
Datum	network_sup (PG_FUNCTION_ARGS)
Datum	network_supeq (PG_FUNCTION_ARGS)
Datum	network_overlap (PG_FUNCTION_ARGS)
Datum	network_subset_support (PG_FUNCTION_ARGS)
Datum	network_host (PG_FUNCTION_ARGS)
Datum	network_show (PG_FUNCTION_ARGS)
Datum	inet_abbrev (PG_FUNCTION_ARGS)
Datum	cidr_abbrev (PG_FUNCTION_ARGS)
Datum	network_masklen (PG_FUNCTION_ARGS)
Datum	network_family (PG_FUNCTION_ARGS)
Datum	network_broadcast (PG_FUNCTION_ARGS)
Datum	network_network (PG_FUNCTION_ARGS)
Datum	network_netmask (PG_FUNCTION_ARGS)
Datum	network_hostmask (PG_FUNCTION_ARGS)
Datum	inet_same_family (PG_FUNCTION_ARGS)
Datum	inet_merge (PG_FUNCTION_ARGS)
double	convert_network_to_scalar (Datum value, Oid typid, bool *failure)
int	bitncmp (const unsigned char *l, const unsigned char *r, int n)
int	bitncommon (const unsigned char *l, const unsigned char *r, int n)
Datum	network_scan_first (Datum in)
Datum	network_scan_last (Datum in)
Datum	inet_client_addr (PG_FUNCTION_ARGS)
Datum	inet_client_port (PG_FUNCTION_ARGS)
Datum	inet_server_addr (PG_FUNCTION_ARGS)
Datum	inet_server_port (PG_FUNCTION_ARGS)
Datum	inetnot (PG_FUNCTION_ARGS)
Datum	inetand (PG_FUNCTION_ARGS)
Datum	inetor (PG_FUNCTION_ARGS)
Datum	inetpl (PG_FUNCTION_ARGS)
Datum	inetmi_int8 (PG_FUNCTION_ARGS)
Datum	inetmi (PG_FUNCTION_ARGS)
void	clean_ipv6_addr (int addr_family, char *addr)

Macro Definition Documentation

ABBREV_BITS_INET4_NETMASK_SIZE

#define ABBREV_BITS_INET4_NETMASK_SIZE   6

Definition at line 42 of file network.c.

ABBREV_BITS_INET4_SUBNET

#define ABBREV_BITS_INET4_SUBNET   25

Definition at line 43 of file network.c.

Function Documentation

addressOK()

static bool addressOK ( unsigned char *  a, int  bits, int  family  )

static

Definition at line 1641 of file network.c.

{
    int         byte;
    int         nbits;
    int         maxbits;
    int         maxbytes;
    unsigned char mask;
 
    if (family == PGSQL_AF_INET)
    {
        maxbits = 32;
        maxbytes = 4;
    }
    else
    {
        maxbits = 128;
        maxbytes = 16;
    }
    Assert(bits <= maxbits);
 
    if (bits == maxbits)
        return true;
 
    byte = bits / 8;
 
    nbits = bits % 8;
    mask = 0xff;
    if (bits != 0)
        mask >>= nbits;
 
    while (byte < maxbytes)
    {
        if ((a[byte] & mask) != 0)
            return false;
        mask = 0xff;
        byte++;
    }
 
    return true;
}

References a, Assert(), and PGSQL_AF_INET.

Referenced by network_in(), and network_recv().

bitncmp()

int bitncmp	(	const unsigned char *	l,
		const unsigned char *	r,
		int	n
	)

Definition at line 1569 of file network.c.

{
    unsigned int lb,
                rb;
    int         x,
                b;
 
    b = n / 8;
    x = memcmp(l, r, b);
    if (x || (n % 8) == 0)
        return x;
 
    lb = l[b];
    rb = r[b];
    for (b = n % 8; b > 0; b--)
    {
        if (IS_HIGHBIT_SET(lb) != IS_HIGHBIT_SET(rb))
        {
            if (IS_HIGHBIT_SET(lb))
                return 1;
            return -1;
        }
        lb <<= 1;
        rb <<= 1;
    }
    return 0;
}

References b, IS_HIGHBIT_SET, and x.

Referenced by inet_gist_consistent(), inet_inclusion_cmp(), inet_spg_choose(), inet_spg_consistent_bitmap(), network_cmp_internal(), network_overlap(), network_sub(), network_subeq(), network_sup(), and network_supeq().

bitncommon()

int bitncommon	(	const unsigned char *	l,
		const unsigned char *	r,
		int	n
	)

Definition at line 1603 of file network.c.

{
    int         byte,
                nbits;
 
    /* number of bits to examine in last byte */
    nbits = n % 8;
 
    /* check whole bytes */
    for (byte = 0; byte < n / 8; byte++)
    {
        if (l[byte] != r[byte])
        {
            /* at least one bit in the last byte is not common */
            nbits = 7;
            break;
        }
    }
 
    /* check bits in last partial byte */
    if (nbits != 0)
    {
        /* calculate diff of first non-matching bytes */
        unsigned int diff = l[byte] ^ r[byte];
 
        /* compare the bits from the most to the least */
        while ((diff >> (8 - nbits)) != 0)
            nbits--;
    }
 
    return (8 * byte) + nbits;
}

Referenced by calc_inet_union_params(), calc_inet_union_params_indexed(), inet_gist_penalty(), inet_hist_match_divider(), inet_merge(), inet_spg_choose(), and inet_spg_picksplit().

cidr_abbrev()

Datum cidr_abbrev

(

PG_FUNCTION_ARGS

)

Definition at line 1240 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    char       *dst;
    char        tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
 
    dst = pg_inet_cidr_ntop(ip_family(ip), ip_addr(ip),
                            ip_bits(ip), tmp, sizeof(tmp));
 
    if (dst == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("could not format cidr value: %m")));
 
    PG_RETURN_TEXT_P(cstring_to_text(tmp));
}

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, pg_inet_cidr_ntop(), and PG_RETURN_TEXT_P.

cidr_in()

Datum cidr_in

(

PG_FUNCTION_ARGS

)

Definition at line 129 of file network.c.

{
    char       *src = PG_GETARG_CSTRING(0);
 
    PG_RETURN_INET_P(network_in(src, true, fcinfo->context));
}

References network_in(), PG_GETARG_CSTRING, and PG_RETURN_INET_P.

cidr_out()

Datum cidr_out

(

PG_FUNCTION_ARGS

)

Definition at line 173 of file network.c.

{
    inet       *src = PG_GETARG_INET_PP(0);
 
    PG_RETURN_CSTRING(network_out(src, true));
}

References network_out(), PG_GETARG_INET_PP, and PG_RETURN_CSTRING.

cidr_recv()

Datum cidr_recv

(

PG_FUNCTION_ARGS

)

Definition at line 258 of file network.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
    PG_RETURN_INET_P(network_recv(buf, true));
}

References buf, network_recv(), PG_GETARG_POINTER, and PG_RETURN_INET_P.

cidr_send()

Datum cidr_send

(

PG_FUNCTION_ARGS

)

Definition at line 300 of file network.c.

{
    inet       *addr = PG_GETARG_INET_PP(0);
 
    PG_RETURN_BYTEA_P(network_send(addr, true));
}

References network_send(), PG_GETARG_INET_PP, and PG_RETURN_BYTEA_P.

cidr_set_masklen()

Datum cidr_set_masklen

(

PG_FUNCTION_ARGS

)

Definition at line 348 of file network.c.

{
    inet       *src = PG_GETARG_INET_PP(0);
    int         bits = PG_GETARG_INT32(1);
 
    if (bits == -1)
        bits = ip_maxbits(src);
 
    if ((bits < 0) || (bits > ip_maxbits(src)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid mask length: %d", bits)));
 
    PG_RETURN_INET_P(cidr_set_masklen_internal(src, bits));
}

References cidr_set_masklen_internal(), ereport, errcode(), errmsg(), ERROR, ip_maxbits, PG_GETARG_INET_PP, PG_GETARG_INT32, and PG_RETURN_INET_P.

cidr_set_masklen_internal()

inet* cidr_set_masklen_internal	(	const inet *	src,
		int	bits
	)

Definition at line 368 of file network.c.

{
    inet       *dst = (inet *) palloc0(sizeof(inet));
 
    ip_family(dst) = ip_family(src);
    ip_bits(dst) = bits;
 
    if (bits > 0)
    {
        Assert(bits <= ip_maxbits(dst));
 
        /* Clone appropriate bytes of the address, leaving the rest 0 */
        memcpy(ip_addr(dst), ip_addr(src), (bits + 7) / 8);
 
        /* Clear any unwanted bits in the last partial byte */
        if (bits % 8)
            ip_addr(dst)[bits / 8] &= ~(0xFF >> (bits % 8));
    }
 
    /* Set varlena header correctly */
    SET_INET_VARSIZE(dst);
 
    return dst;
}

References Assert(), ip_addr, ip_bits, ip_family, ip_maxbits, palloc0(), and SET_INET_VARSIZE.

Referenced by cidr_set_masklen(), inet_merge(), inet_spg_choose(), inet_spg_picksplit(), and inet_to_cidr().

clean_ipv6_addr()

void clean_ipv6_addr	(	int	addr_family,
		char *	addr
	)

Definition at line 2095 of file network.c.

{
    if (addr_family == AF_INET6)
    {
        char       *pct = strchr(addr, '%');
 
        if (pct)
            *pct = '\0';
    }
}

Referenced by fill_hba_line(), inet_client_addr(), inet_server_addr(), pg_stat_get_activity(), and pg_stat_get_backend_client_addr().

convert_network_to_scalar()

double convert_network_to_scalar	(	Datum	value,
		Oid	typid,
		bool *	failure
	)

Definition at line 1502 of file network.c.

{
    switch (typid)
    {
        case INETOID:
        case CIDROID:
            {
                inet       *ip = DatumGetInetPP(value);
                int         len;
                double      res;
                int         i;
 
                /*
                 * Note that we don't use the full address for IPv6.
                 */
                if (ip_family(ip) == PGSQL_AF_INET)
                    len = 4;
                else
                    len = 5;
 
                res = ip_family(ip);
                for (i = 0; i < len; i++)
                {
                    res *= 256;
                    res += ip_addr(ip)[i];
                }
                return res;
            }
        case MACADDROID:
            {
                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;
            }
        case MACADDR8OID:
            {
                macaddr8   *mac = DatumGetMacaddr8P(value);
                double      res;
 
                res = (mac->a << 24) | (mac->b << 16) | (mac->c << 8) | (mac->d);
                res *= ((double) 256) * 256 * 256 * 256;
                res += (mac->e << 24) | (mac->f << 16) | (mac->g << 8) | (mac->h);
                return res;
            }
    }
 
    *failure = true;
    return 0;
}

References macaddr::a, macaddr8::a, macaddr::b, macaddr8::b, macaddr::c, macaddr8::c, macaddr::d, macaddr8::d, DatumGetInetPP(), DatumGetMacaddr8P(), DatumGetMacaddrP(), macaddr::e, macaddr8::e, macaddr::f, macaddr8::f, macaddr8::g, macaddr8::h, i, ip_addr, ip_family, len, PGSQL_AF_INET, res, and value.

Referenced by convert_to_scalar(), gbt_inet_compress(), and gbt_inet_consistent().

hashinet()

Datum hashinet

(

PG_FUNCTION_ARGS

)

Definition at line 880 of file network.c.

{
    inet       *addr = PG_GETARG_INET_PP(0);
    int         addrsize = ip_addrsize(addr);
 
    /* XXX this assumes there are no pad bytes in the data structure */
    return hash_any((unsigned char *) VARDATA_ANY(addr), addrsize + 2);
}

References hash_any(), ip_addrsize, PG_GETARG_INET_PP, and VARDATA_ANY.

hashinetextended()

Datum hashinetextended

(

PG_FUNCTION_ARGS

)

Definition at line 890 of file network.c.

{
    inet       *addr = PG_GETARG_INET_PP(0);
    int         addrsize = ip_addrsize(addr);
 
    return hash_any_extended((unsigned char *) VARDATA_ANY(addr), addrsize + 2,
                             PG_GETARG_INT64(1));
}

References hash_any_extended(), ip_addrsize, PG_GETARG_INET_PP, PG_GETARG_INT64, and VARDATA_ANY.

inet_abbrev()

Datum inet_abbrev

(

PG_FUNCTION_ARGS

)

Definition at line 1222 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    char       *dst;
    char        tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
 
    dst = pg_inet_net_ntop(ip_family(ip), ip_addr(ip),
                           ip_bits(ip), tmp, sizeof(tmp));
 
    if (dst == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("could not format inet value: %m")));
 
    PG_RETURN_TEXT_P(cstring_to_text(tmp));
}

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, pg_inet_net_ntop(), and PG_RETURN_TEXT_P.

inet_client_addr()

Datum inet_client_addr

(

PG_FUNCTION_ARGS

)

Definition at line 1716 of file network.c.

{
    Port       *port = MyProcPort;
    char        remote_host[NI_MAXHOST];
    int         ret;
 
    if (port == NULL)
        PG_RETURN_NULL();
 
    switch (port->raddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        default:
            PG_RETURN_NULL();
    }
 
    remote_host[0] = '\0';
 
    ret = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
                             remote_host, sizeof(remote_host),
                             NULL, 0,
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    clean_ipv6_addr(port->raddr.addr.ss_family, remote_host);
 
    PG_RETURN_INET_P(network_in(remote_host, false, NULL));
}

References clean_ipv6_addr(), MyProcPort, network_in(), pg_getnameinfo_all(), PG_RETURN_INET_P, PG_RETURN_NULL, and port.

inet_client_port()

Datum inet_client_port

(

PG_FUNCTION_ARGS

)

Definition at line 1753 of file network.c.

{
    Port       *port = MyProcPort;
    char        remote_port[NI_MAXSERV];
    int         ret;
 
    if (port == NULL)
        PG_RETURN_NULL();
 
    switch (port->raddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        default:
            PG_RETURN_NULL();
    }
 
    remote_port[0] = '\0';
 
    ret = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
                             NULL, 0,
                             remote_port, sizeof(remote_port),
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(DirectFunctionCall1(int4in, CStringGetDatum(remote_port)));
}

References CStringGetDatum(), DirectFunctionCall1, int4in(), MyProcPort, pg_getnameinfo_all(), PG_RETURN_DATUM, PG_RETURN_NULL, and port.

inet_in()

Datum inet_in

(

PG_FUNCTION_ARGS

)

Definition at line 121 of file network.c.

{
    char       *src = PG_GETARG_CSTRING(0);
 
    PG_RETURN_INET_P(network_in(src, false, fcinfo->context));
}

References network_in(), PG_GETARG_CSTRING, and PG_RETURN_INET_P.

Referenced by leftmostvalue_inet(), pg_stat_get_activity(), and pg_stat_get_backend_client_addr().

inet_merge()

Datum inet_merge

(

PG_FUNCTION_ARGS

)

Definition at line 1476 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0),
               *a2 = PG_GETARG_INET_PP(1);
    int         commonbits;
 
    if (ip_family(a1) != ip_family(a2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot merge addresses from different families")));
 
    commonbits = bitncommon(ip_addr(a1), ip_addr(a2),
                            Min(ip_bits(a1), ip_bits(a2)));
 
    PG_RETURN_INET_P(cidr_set_masklen_internal(a1, commonbits));
}

References a1, a2, bitncommon(), cidr_set_masklen_internal(), ereport, errcode(), errmsg(), ERROR, ip_addr, ip_bits, ip_family, Min, PG_GETARG_INET_PP, and PG_RETURN_INET_P.

inet_out()

Datum inet_out

(

PG_FUNCTION_ARGS

)

Definition at line 165 of file network.c.

{
    inet       *src = PG_GETARG_INET_PP(0);
 
    PG_RETURN_CSTRING(network_out(src, false));
}

References network_out(), PG_GETARG_INET_PP, and PG_RETURN_CSTRING.

inet_recv()

Datum inet_recv

(

PG_FUNCTION_ARGS

)

Definition at line 250 of file network.c.

{
    StringInfo  buf = (StringInfo) PG_GETARG_POINTER(0);
 
    PG_RETURN_INET_P(network_recv(buf, false));
}

References buf, network_recv(), PG_GETARG_POINTER, and PG_RETURN_INET_P.

inet_same_family()

Datum inet_same_family

(

PG_FUNCTION_ARGS

)

Definition at line 1464 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(ip_family(a1) == ip_family(a2));
}

References a1, a2, ip_family, PG_GETARG_INET_PP, and PG_RETURN_BOOL.

inet_send()

Datum inet_send

(

PG_FUNCTION_ARGS

)

Definition at line 292 of file network.c.

{
    inet       *addr = PG_GETARG_INET_PP(0);
 
    PG_RETURN_BYTEA_P(network_send(addr, false));
}

References network_send(), PG_GETARG_INET_PP, and PG_RETURN_BYTEA_P.

inet_server_addr()

Datum inet_server_addr

(

PG_FUNCTION_ARGS

)

Definition at line 1788 of file network.c.

{
    Port       *port = MyProcPort;
    char        local_host[NI_MAXHOST];
    int         ret;
 
    if (port == NULL)
        PG_RETURN_NULL();
 
    switch (port->laddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        default:
            PG_RETURN_NULL();
    }
 
    local_host[0] = '\0';
 
    ret = pg_getnameinfo_all(&port->laddr.addr, port->laddr.salen,
                             local_host, sizeof(local_host),
                             NULL, 0,
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    clean_ipv6_addr(port->laddr.addr.ss_family, local_host);
 
    PG_RETURN_INET_P(network_in(local_host, false, NULL));
}

References clean_ipv6_addr(), MyProcPort, network_in(), pg_getnameinfo_all(), PG_RETURN_INET_P, PG_RETURN_NULL, and port.

inet_server_port()

Datum inet_server_port

(

PG_FUNCTION_ARGS

)

Definition at line 1825 of file network.c.

{
    Port       *port = MyProcPort;
    char        local_port[NI_MAXSERV];
    int         ret;
 
    if (port == NULL)
        PG_RETURN_NULL();
 
    switch (port->laddr.addr.ss_family)
    {
        case AF_INET:
        case AF_INET6:
            break;
        default:
            PG_RETURN_NULL();
    }
 
    local_port[0] = '\0';
 
    ret = pg_getnameinfo_all(&port->laddr.addr, port->laddr.salen,
                             NULL, 0,
                             local_port, sizeof(local_port),
                             NI_NUMERICHOST | NI_NUMERICSERV);
    if (ret != 0)
        PG_RETURN_NULL();
 
    PG_RETURN_DATUM(DirectFunctionCall1(int4in, CStringGetDatum(local_port)));
}

References CStringGetDatum(), DirectFunctionCall1, int4in(), MyProcPort, pg_getnameinfo_all(), PG_RETURN_DATUM, PG_RETURN_NULL, and port.

inet_set_masklen()

Datum inet_set_masklen

(

PG_FUNCTION_ARGS

)

Definition at line 324 of file network.c.

{
    inet       *src = PG_GETARG_INET_PP(0);
    int         bits = PG_GETARG_INT32(1);
    inet       *dst;
 
    if (bits == -1)
        bits = ip_maxbits(src);
 
    if ((bits < 0) || (bits > ip_maxbits(src)))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("invalid mask length: %d", bits)));
 
    /* clone the original data */
    dst = (inet *) palloc(VARSIZE_ANY(src));
    memcpy(dst, src, VARSIZE_ANY(src));
 
    ip_bits(dst) = bits;
 
    PG_RETURN_INET_P(dst);
}

References ereport, errcode(), errmsg(), ERROR, ip_bits, ip_maxbits, palloc(), PG_GETARG_INET_PP, PG_GETARG_INT32, PG_RETURN_INET_P, and VARSIZE_ANY.

Referenced by network_scan_last().

inet_to_cidr()

Datum inet_to_cidr

(

PG_FUNCTION_ARGS

)

Definition at line 309 of file network.c.

{
    inet       *src = PG_GETARG_INET_PP(0);
    int         bits;
 
    bits = ip_bits(src);
 
    /* safety check */
    if ((bits < 0) || (bits > ip_maxbits(src)))
        elog(ERROR, "invalid inet bit length: %d", bits);
 
    PG_RETURN_INET_P(cidr_set_masklen_internal(src, bits));
}

References cidr_set_masklen_internal(), elog(), ERROR, ip_bits, ip_maxbits, PG_GETARG_INET_PP, and PG_RETURN_INET_P.

inetand()

Datum inetand

(

PG_FUNCTION_ARGS

)

Definition at line 1882 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *ip2 = PG_GETARG_INET_PP(1);
    inet       *dst;
 
    dst = (inet *) palloc0(sizeof(inet));
 
    if (ip_family(ip) != ip_family(ip2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot AND inet values of different sizes")));
    else
    {
        int         nb = ip_addrsize(ip);
        unsigned char *pip = ip_addr(ip);
        unsigned char *pip2 = ip_addr(ip2);
        unsigned char *pdst = ip_addr(dst);
 
        while (--nb >= 0)
            pdst[nb] = pip[nb] & pip2[nb];
    }
    ip_bits(dst) = Max(ip_bits(ip), ip_bits(ip2));
 
    ip_family(dst) = ip_family(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References ereport, errcode(), errmsg(), ERROR, ip_addr, ip_addrsize, ip_bits, ip_family, Max, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

inetmi()

Datum inetmi

(

PG_FUNCTION_ARGS

)

Definition at line 2018 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *ip2 = PG_GETARG_INET_PP(1);
    int64       res = 0;
 
    if (ip_family(ip) != ip_family(ip2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot subtract inet values of different sizes")));
    else
    {
        /*
         * We form the difference using the traditional complement, increment,
         * and add rule, with the increment part being handled by starting the
         * carry off at 1.  If you don't think integer arithmetic is done in
         * two's complement, too bad.
         */
        int         nb = ip_addrsize(ip);
        int         byte = 0;
        unsigned char *pip = ip_addr(ip);
        unsigned char *pip2 = ip_addr(ip2);
        int         carry = 1;
 
        while (--nb >= 0)
        {
            int         lobyte;
 
            carry = pip[nb] + (~pip2[nb] & 0xFF) + carry;
            lobyte = carry & 0xFF;
            if (byte < sizeof(int64))
            {
                res |= ((int64) lobyte) << (byte * 8);
            }
            else
            {
                /*
                 * Input wider than int64: check for overflow.  All bytes to
                 * the left of what will fit should be 0 or 0xFF, depending on
                 * sign of the now-complete result.
                 */
                if ((res < 0) ? (lobyte != 0xFF) : (lobyte != 0))
                    ereport(ERROR,
                            (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                             errmsg("result is out of range")));
            }
            carry >>= 8;
            byte++;
        }
 
        /*
         * If input is narrower than int64, overflow is not possible, but we
         * have to do proper sign extension.
         */
        if (carry == 0 && byte < sizeof(int64))
            res |= ((uint64) (int64) -1) << (byte * 8);
    }
 
    PG_RETURN_INT64(res);
}

References ereport, errcode(), errmsg(), ERROR, ip_addr, ip_addrsize, ip_family, PG_GETARG_INET_PP, PG_RETURN_INT64, and res.

inetmi_int8()

Datum inetmi_int8

(

PG_FUNCTION_ARGS

)

Definition at line 2008 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    int64       addend = PG_GETARG_INT64(1);
 
    PG_RETURN_INET_P(internal_inetpl(ip, -addend));
}

References internal_inetpl(), PG_GETARG_INET_PP, PG_GETARG_INT64, and PG_RETURN_INET_P.

inetnot()

Datum inetnot

(

PG_FUNCTION_ARGS

)

Definition at line 1857 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *dst;
 
    dst = (inet *) palloc0(sizeof(inet));
 
    {
        int         nb = ip_addrsize(ip);
        unsigned char *pip = ip_addr(ip);
        unsigned char *pdst = ip_addr(dst);
 
        while (--nb >= 0)
            pdst[nb] = ~pip[nb];
    }
    ip_bits(dst) = ip_bits(ip);
 
    ip_family(dst) = ip_family(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References ip_addr, ip_addrsize, ip_bits, ip_family, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

inetor()

Datum inetor

(

PG_FUNCTION_ARGS

)

Definition at line 1914 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *ip2 = PG_GETARG_INET_PP(1);
    inet       *dst;
 
    dst = (inet *) palloc0(sizeof(inet));
 
    if (ip_family(ip) != ip_family(ip2))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                 errmsg("cannot OR inet values of different sizes")));
    else
    {
        int         nb = ip_addrsize(ip);
        unsigned char *pip = ip_addr(ip);
        unsigned char *pip2 = ip_addr(ip2);
        unsigned char *pdst = ip_addr(dst);
 
        while (--nb >= 0)
            pdst[nb] = pip[nb] | pip2[nb];
    }
    ip_bits(dst) = Max(ip_bits(ip), ip_bits(ip2));
 
    ip_family(dst) = ip_family(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References ereport, errcode(), errmsg(), ERROR, ip_addr, ip_addrsize, ip_bits, ip_family, Max, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

inetpl()

Datum inetpl

(

PG_FUNCTION_ARGS

)

Definition at line 1998 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    int64       addend = PG_GETARG_INT64(1);
 
    PG_RETURN_INET_P(internal_inetpl(ip, addend));
}

References internal_inetpl(), PG_GETARG_INET_PP, PG_GETARG_INT64, and PG_RETURN_INET_P.

internal_inetpl()

static inet * internal_inetpl ( inet *  ip, int64  addend  )

static

Definition at line 1946 of file network.c.

{
    inet       *dst;
 
    dst = (inet *) palloc0(sizeof(inet));
 
    {
        int         nb = ip_addrsize(ip);
        unsigned char *pip = ip_addr(ip);
        unsigned char *pdst = ip_addr(dst);
        int         carry = 0;
 
        while (--nb >= 0)
        {
            carry = pip[nb] + (int) (addend & 0xFF) + carry;
            pdst[nb] = (unsigned char) (carry & 0xFF);
            carry >>= 8;
 
            /*
             * We have to be careful about right-shifting addend because
             * right-shift isn't portable for negative values, while simply
             * dividing by 256 doesn't work (the standard rounding is in the
             * wrong direction, besides which there may be machines out there
             * that round the wrong way).  So, explicitly clear the low-order
             * byte to remove any doubt about the correct result of the
             * division, and then divide rather than shift.
             */
            addend &= ~((int64) 0xFF);
            addend /= 0x100;
        }
 
        /*
         * At this point we should have addend and carry both zero if original
         * addend was >= 0, or addend -1 and carry 1 if original addend was <
         * 0.  Anything else means overflow.
         */
        if (!((addend == 0 && carry == 0) ||
              (addend == -1 && carry == 1)))
            ereport(ERROR,
                    (errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
                     errmsg("result is out of range")));
    }
 
    ip_bits(dst) = ip_bits(ip);
    ip_family(dst) = ip_family(ip);
    SET_INET_VARSIZE(dst);
 
    return dst;
}

References ereport, errcode(), errmsg(), ERROR, ip_addr, ip_addrsize, ip_bits, ip_family, palloc0(), and SET_INET_VARSIZE.

Referenced by inetmi_int8(), and inetpl().

match_network_function()

static List * match_network_function ( Node *  leftop, Node *  rightop, int  indexarg, Oid  funcid, Oid  opfamily  )

static

Definition at line 1028 of file network.c.

{
    switch (funcid)
    {
        case F_NETWORK_SUB:
            /* indexkey must be on the left */
            if (indexarg != 0)
                return NIL;
            return match_network_subset(leftop, rightop, false, opfamily);
 
        case F_NETWORK_SUBEQ:
            /* indexkey must be on the left */
            if (indexarg != 0)
                return NIL;
            return match_network_subset(leftop, rightop, true, opfamily);
 
        case F_NETWORK_SUP:
            /* indexkey must be on the right */
            if (indexarg != 1)
                return NIL;
            return match_network_subset(rightop, leftop, false, opfamily);
 
        case F_NETWORK_SUPEQ:
            /* indexkey must be on the right */
            if (indexarg != 1)
                return NIL;
            return match_network_subset(rightop, leftop, true, opfamily);
 
        default:
 
            /*
             * We'd only get here if somebody attached this support function
             * to an unexpected function.  Maybe we should complain, but for
             * now, do nothing.
             */
            return NIL;
    }
}

References match_network_subset(), and NIL.

Referenced by network_subset_support().

match_network_subset()

static List * match_network_subset ( Node *  leftop, Node *  rightop, bool  is_eq, Oid  opfamily  )

static

Definition at line 1076 of file network.c.

{
    List       *result;
    Datum       rightopval;
    Oid         datatype = INETOID;
    Oid         opr1oid;
    Oid         opr2oid;
    Datum       opr1right;
    Datum       opr2right;
    Expr       *expr;
 
    /*
     * Can't do anything with a non-constant or NULL comparison value.
     *
     * Note that since we restrict ourselves to cases with a hard constant on
     * the RHS, it's a-fortiori a pseudoconstant, and we don't need to worry
     * about verifying that.
     */
    if (!IsA(rightop, Const) ||
        ((Const *) rightop)->constisnull)
        return NIL;
    rightopval = ((Const *) rightop)->constvalue;
 
    /*
     * Must check that index's opfamily supports the operators we will want to
     * apply.
     *
     * We insist on the opfamily being the specific one we expect, else we'd
     * do the wrong thing if someone were to make a reverse-sort opfamily with
     * the same operators.
     */
    if (opfamily != NETWORK_BTREE_FAM_OID)
        return NIL;
 
    /*
     * create clause "key >= network_scan_first( rightopval )", or ">" if the
     * operator disallows equality.
     *
     * Note: seeing that this function supports only fixed values for opfamily
     * and datatype, we could just hard-wire the operator OIDs instead of
     * looking them up.  But for now it seems better to be general.
     */
    if (is_eq)
    {
        opr1oid = get_opfamily_member(opfamily, datatype, datatype,
                                      BTGreaterEqualStrategyNumber);
        if (opr1oid == InvalidOid)
            elog(ERROR, "no >= operator for opfamily %u", opfamily);
    }
    else
    {
        opr1oid = get_opfamily_member(opfamily, datatype, datatype,
                                      BTGreaterStrategyNumber);
        if (opr1oid == InvalidOid)
            elog(ERROR, "no > operator for opfamily %u", opfamily);
    }
 
    opr1right = network_scan_first(rightopval);
 
    expr = make_opclause(opr1oid, BOOLOID, false,
                         (Expr *) leftop,
                         (Expr *) makeConst(datatype, -1,
                                            InvalidOid, /* not collatable */
                                            -1, opr1right,
                                            false, false),
                         InvalidOid, InvalidOid);
    result = list_make1(expr);
 
    /* create clause "key <= network_scan_last( rightopval )" */
 
    opr2oid = get_opfamily_member(opfamily, datatype, datatype,
                                  BTLessEqualStrategyNumber);
    if (opr2oid == InvalidOid)
        elog(ERROR, "no <= operator for opfamily %u", opfamily);
 
    opr2right = network_scan_last(rightopval);
 
    expr = make_opclause(opr2oid, BOOLOID, false,
                         (Expr *) leftop,
                         (Expr *) makeConst(datatype, -1,
                                            InvalidOid, /* not collatable */
                                            -1, opr2right,
                                            false, false),
                         InvalidOid, InvalidOid);
    result = lappend(result, expr);
 
    return result;
}

References BTGreaterEqualStrategyNumber, BTGreaterStrategyNumber, BTLessEqualStrategyNumber, elog(), ERROR, get_opfamily_member(), InvalidOid, IsA, lappend(), list_make1, make_opclause(), makeConst(), network_scan_first(), network_scan_last(), and NIL.

Referenced by match_network_function().

network_abbrev_abort()

static bool network_abbrev_abort ( int  memtupcount, SortSupport  ssup  )

static

Definition at line 488 of file network.c.

{
    network_sortsupport_state *uss = ssup->ssup_extra;
    double      abbr_card;
 
    if (memtupcount < 10000 || uss->input_count < 10000 || !uss->estimating)
        return false;
 
    abbr_card = estimateHyperLogLog(&uss->abbr_card);
 
    /*
     * If we have >100k distinct values, then even if we were sorting many
     * billion rows we'd likely still break even, and the penalty of undoing
     * that many rows of abbrevs would probably not be worth it. At this point
     * we stop counting because we know that we're now fully committed.
     */
    if (abbr_card > 100000.0)
    {
#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG,
                 "network_abbrev: estimation ends at cardinality %f"
                 " after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count, memtupcount);
#endif
        uss->estimating = false;
        return false;
    }
 
    /*
     * Target minimum cardinality is 1 per ~2k of non-null inputs. 0.5 row
     * fudge factor allows us to abort earlier on genuinely pathological data
     * where we've had exactly one abbreviated value in the first 2k
     * (non-null) rows.
     */
    if (abbr_card < uss->input_count / 2000.0 + 0.5)
    {
#ifdef TRACE_SORT
        if (trace_sort)
            elog(LOG,
                 "network_abbrev: aborting abbreviation at cardinality %f"
                 " below threshold %f after " INT64_FORMAT " values (%d rows)",
                 abbr_card, uss->input_count / 2000.0 + 0.5, uss->input_count,
                 memtupcount);
#endif
        return true;
    }
 
#ifdef TRACE_SORT
    if (trace_sort)
        elog(LOG,
             "network_abbrev: cardinality %f after " INT64_FORMAT
             " values (%d rows)", abbr_card, uss->input_count, memtupcount);
#endif
 
    return false;
}

References network_sortsupport_state::abbr_card, elog(), estimateHyperLogLog(), network_sortsupport_state::estimating, network_sortsupport_state::input_count, INT64_FORMAT, LOG, SortSupportData::ssup_extra, and trace_sort.

Referenced by network_sortsupport().

network_abbrev_convert()

static Datum network_abbrev_convert ( Datum  original, SortSupport  ssup  )

static

Definition at line 625 of file network.c.

{
    network_sortsupport_state *uss = ssup->ssup_extra;
    inet       *authoritative = DatumGetInetPP(original);
    Datum       res,
                ipaddr_datum,
                subnet_bitmask,
                network;
    int         subnet_size;
 
    Assert(ip_family(authoritative) == PGSQL_AF_INET ||
           ip_family(authoritative) == PGSQL_AF_INET6);
 
    /*
     * Get an unsigned integer representation of the IP address by taking its
     * first 4 or 8 bytes. Always take all 4 bytes of an IPv4 address. Take
     * the first 8 bytes of an IPv6 address with an 8 byte datum and 4 bytes
     * otherwise.
     *
     * We're consuming an array of unsigned char, so byteswap on little endian
     * systems (an inet's ipaddr field stores the most significant byte
     * first).
     */
    if (ip_family(authoritative) == PGSQL_AF_INET)
    {
        uint32      ipaddr_datum32;
 
        memcpy(&ipaddr_datum32, ip_addr(authoritative), sizeof(uint32));
 
        /* Must byteswap on little-endian machines */
#ifndef WORDS_BIGENDIAN
        ipaddr_datum = pg_bswap32(ipaddr_datum32);
#else
        ipaddr_datum = ipaddr_datum32;
#endif
 
        /* Initialize result without setting ipfamily bit */
        res = (Datum) 0;
    }
    else
    {
        memcpy(&ipaddr_datum, ip_addr(authoritative), sizeof(Datum));
 
        /* Must byteswap on little-endian machines */
        ipaddr_datum = DatumBigEndianToNative(ipaddr_datum);
 
        /* Initialize result with ipfamily (most significant) bit set */
        res = ((Datum) 1) << (SIZEOF_DATUM * BITS_PER_BYTE - 1);
    }
 
    /*
     * ipaddr_datum must be "split": high order bits go in "network" component
     * of abbreviated key (often with zeroed bits at the end due to masking),
     * while low order bits go in "subnet" component when there is space for
     * one. This is often accomplished by generating a temp datum subnet
     * bitmask, which we may reuse later when generating the subnet bits
     * themselves.  (Note that subnet bits are only used with IPv4 datums on
     * platforms where datum is 8 bytes.)
     *
     * The number of bits in subnet is used to generate a datum subnet
     * bitmask. For example, with a /24 IPv4 datum there are 8 subnet bits
     * (since 32 - 24 is 8), so the final subnet bitmask is B'1111 1111'. We
     * need explicit handling for cases where the ipaddr bits cannot all fit
     * in a datum, though (otherwise we'd incorrectly mask the network
     * component with IPv6 values).
     */
    subnet_size = ip_maxbits(authoritative) - ip_bits(authoritative);
    Assert(subnet_size >= 0);
    /* subnet size must work with prefix ipaddr cases */
    subnet_size %= SIZEOF_DATUM * BITS_PER_BYTE;
    if (ip_bits(authoritative) == 0)
    {
        /* Fit as many ipaddr bits as possible into subnet */
        subnet_bitmask = ((Datum) 0) - 1;
        network = 0;
    }
    else if (ip_bits(authoritative) < SIZEOF_DATUM * BITS_PER_BYTE)
    {
        /* Split ipaddr bits between network and subnet */
        subnet_bitmask = (((Datum) 1) << subnet_size) - 1;
        network = ipaddr_datum & ~subnet_bitmask;
    }
    else
    {
        /* Fit as many ipaddr bits as possible into network */
        subnet_bitmask = 0;
        network = ipaddr_datum;
    }
 
#if SIZEOF_DATUM == 8
    if (ip_family(authoritative) == PGSQL_AF_INET)
    {
        /*
         * IPv4 with 8 byte datums: keep all 32 netmasked bits, netmask size,
         * and most significant 25 subnet bits
         */
        Datum       netmask_size = (Datum) ip_bits(authoritative);
        Datum       subnet;
 
        /*
         * Shift left 31 bits: 6 bits netmask size + 25 subnet bits.
         *
         * We don't make any distinction between network bits that are zero
         * due to masking and "true"/non-masked zero bits.  An abbreviated
         * comparison that is resolved by comparing a non-masked and non-zero
         * bit to a masked/zeroed bit is effectively resolved based on
         * ip_bits(), even though the comparison won't reach the netmask_size
         * bits.
         */
        network <<= (ABBREV_BITS_INET4_NETMASK_SIZE +
                     ABBREV_BITS_INET4_SUBNET);
 
        /* Shift size to make room for subnet bits at the end */
        netmask_size <<= ABBREV_BITS_INET4_SUBNET;
 
        /* Extract subnet bits without shifting them */
        subnet = ipaddr_datum & subnet_bitmask;
 
        /*
         * If we have more than 25 subnet bits, we can't fit everything. Shift
         * subnet down to avoid clobbering bits that are only supposed to be
         * used for netmask_size.
         *
         * Discarding the least significant subnet bits like this is correct
         * because abbreviated comparisons that are resolved at the subnet
         * level must have had equal netmask_size/ip_bits() values in order to
         * get that far.
         */
        if (subnet_size > ABBREV_BITS_INET4_SUBNET)
            subnet >>= subnet_size - ABBREV_BITS_INET4_SUBNET;
 
        /*
         * Assemble the final abbreviated key without clobbering the ipfamily
         * bit that must remain a zero.
         */
        res |= network | netmask_size | subnet;
    }
    else
#endif
    {
        /*
         * 4 byte datums, or IPv6 with 8 byte datums: Use as many of the
         * netmasked bits as will fit in final abbreviated key. Avoid
         * clobbering the ipfamily bit that was set earlier.
         */
        res |= network >> 1;
    }
 
    uss->input_count += 1;
 
    /* Hash abbreviated key */
    if (uss->estimating)
    {
        uint32      tmp;
 
#if SIZEOF_DATUM == 8
        tmp = (uint32) res ^ (uint32) ((uint64) res >> 32);
#else                           /* SIZEOF_DATUM != 8 */
        tmp = (uint32) res;
#endif
 
        addHyperLogLog(&uss->abbr_card, DatumGetUInt32(hash_uint32(tmp)));
    }
 
    return res;
}

References network_sortsupport_state::abbr_card, ABBREV_BITS_INET4_NETMASK_SIZE, ABBREV_BITS_INET4_SUBNET, addHyperLogLog(), Assert(), BITS_PER_BYTE, DatumGetInetPP(), DatumGetUInt32(), network_sortsupport_state::estimating, hash_uint32(), network_sortsupport_state::input_count, ip_addr, ip_bits, ip_family, ip_maxbits, pg_bswap32(), PGSQL_AF_INET, PGSQL_AF_INET6, res, SIZEOF_DATUM, and SortSupportData::ssup_extra.

Referenced by network_sortsupport().

network_broadcast()

Datum network_broadcast

(

PG_FUNCTION_ARGS

)

Definition at line 1285 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *dst;
    int         byte;
    int         bits;
    int         maxbytes;
    unsigned char mask;
    unsigned char *a,
               *b;
 
    /* make sure any unused bits are zeroed */
    dst = (inet *) palloc0(sizeof(inet));
 
    maxbytes = ip_addrsize(ip);
    bits = ip_bits(ip);
    a = ip_addr(ip);
    b = ip_addr(dst);
 
    for (byte = 0; byte < maxbytes; byte++)
    {
        if (bits >= 8)
        {
            mask = 0x00;
            bits -= 8;
        }
        else if (bits == 0)
            mask = 0xff;
        else
        {
            mask = 0xff >> bits;
            bits = 0;
        }
 
        b[byte] = a[byte] | mask;
    }
 
    ip_family(dst) = ip_family(ip);
    ip_bits(dst) = ip_bits(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References a, b, ip_addr, ip_addrsize, ip_bits, ip_family, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

Referenced by network_scan_last().

network_cmp()

Datum network_cmp

(

PG_FUNCTION_ARGS

)

Definition at line 425 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_INT32(network_cmp_internal(a1, a2));
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_INT32.

network_cmp_internal()

static int32 network_cmp_internal ( inet *  a1, inet *  a2  )

static

Definition at line 405 of file network.c.

{
    if (ip_family(a1) == ip_family(a2))
    {
        int         order;
 
        order = bitncmp(ip_addr(a1), ip_addr(a2),
                        Min(ip_bits(a1), ip_bits(a2)));
        if (order != 0)
            return order;
        order = ((int) ip_bits(a1)) - ((int) ip_bits(a2));
        if (order != 0)
            return order;
        return bitncmp(ip_addr(a1), ip_addr(a2), ip_maxbits(a1));
    }
 
    return ip_family(a1) - ip_family(a2);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, ip_maxbits, and Min.

Referenced by network_cmp(), network_eq(), network_fast_cmp(), network_ge(), network_gt(), network_larger(), network_le(), network_lt(), network_ne(), and network_smaller().

network_eq()

Datum network_eq

(

PG_FUNCTION_ARGS

)

Definition at line 814 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) == 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_family()

Datum network_family

(

PG_FUNCTION_ARGS

)

Definition at line 1266 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(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;
    }
}

References ip_family, PG_GETARG_INET_PP, PG_RETURN_INT32, PGSQL_AF_INET, and PGSQL_AF_INET6.

network_fast_cmp()

static int network_fast_cmp ( Datum  x, Datum  y, SortSupport  ssup  )

static

Definition at line 473 of file network.c.

{
    inet       *arg1 = DatumGetInetPP(x);
    inet       *arg2 = DatumGetInetPP(y);
 
    return network_cmp_internal(arg1, arg2);
}

References DatumGetInetPP(), network_cmp_internal(), x, and y.

Referenced by network_sortsupport().

network_ge()

Datum network_ge

(

PG_FUNCTION_ARGS

)

Definition at line 823 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) >= 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_gt()

Datum network_gt

(

PG_FUNCTION_ARGS

)

Definition at line 832 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) > 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_host()

Datum network_host

(

PG_FUNCTION_ARGS

)

Definition at line 1173 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    char       *ptr;
    char        tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
 
    /* force display of max bits, regardless of masklen... */
    if (pg_inet_net_ntop(ip_family(ip), ip_addr(ip), ip_maxbits(ip),
                         tmp, sizeof(tmp)) == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("could not format inet value: %m")));
 
    /* Suppress /n if present (shouldn't happen now) */
    if ((ptr = strchr(tmp, '/')) != NULL)
        *ptr = '\0';
 
    PG_RETURN_TEXT_P(cstring_to_text(tmp));
}

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, ip_addr, ip_family, ip_maxbits, PG_GETARG_INET_PP, pg_inet_net_ntop(), and PG_RETURN_TEXT_P.

network_hostmask()

Datum network_hostmask

(

PG_FUNCTION_ARGS

)

Definition at line 1416 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *dst;
    int         byte;
    int         bits;
    int         maxbytes;
    unsigned char mask;
    unsigned char *b;
 
    /* make sure any unused bits are zeroed */
    dst = (inet *) palloc0(sizeof(inet));
 
    maxbytes = ip_addrsize(ip);
    bits = ip_maxbits(ip) - ip_bits(ip);
    b = ip_addr(dst);
 
    byte = maxbytes - 1;
 
    while (bits)
    {
        if (bits >= 8)
        {
            mask = 0xff;
            bits -= 8;
        }
        else
        {
            mask = 0xff >> (8 - bits);
            bits = 0;
        }
 
        b[byte] = mask;
        byte--;
    }
 
    ip_family(dst) = ip_family(ip);
    ip_bits(dst) = ip_maxbits(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References b, ip_addr, ip_addrsize, ip_bits, ip_family, ip_maxbits, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

network_in()

static inet* network_in ( char *  src, bool  is_cidr, Node *  escontext  )

static

Definition at line 75 of file network.c.

{
    int         bits;
    inet       *dst;
 
    dst = (inet *) palloc0(sizeof(inet));
 
    /*
     * 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.
     */
 
    if (strchr(src, ':') != NULL)
        ip_family(dst) = PGSQL_AF_INET6;
    else
        ip_family(dst) = PGSQL_AF_INET;
 
    bits = pg_inet_net_pton(ip_family(dst), src, ip_addr(dst),
                            is_cidr ? ip_addrsize(dst) : -1);
    if ((bits < 0) || (bits > ip_maxbits(dst)))
        ereturn(escontext, NULL,
                (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
        /* translator: first %s is inet or cidr */
                 errmsg("invalid input syntax for type %s: \"%s\"",
                        is_cidr ? "cidr" : "inet", src)));
 
    /*
     * Error check: CIDR values must not have any bits set beyond the masklen.
     */
    if (is_cidr)
    {
        if (!addressOK(ip_addr(dst), bits, ip_family(dst)))
            ereturn(escontext, NULL,
                    (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
                     errmsg("invalid cidr value: \"%s\"", src),
                     errdetail("Value has bits set to right of mask.")));
    }
 
    ip_bits(dst) = bits;
    SET_INET_VARSIZE(dst);
 
    return dst;
}

References addressOK(), ereturn, errcode(), errdetail(), errmsg(), ip_addr, ip_addrsize, ip_bits, ip_family, ip_maxbits, palloc0(), pg_inet_net_pton(), PGSQL_AF_INET, PGSQL_AF_INET6, and SET_INET_VARSIZE.

Referenced by cidr_in(), inet_client_addr(), inet_in(), and inet_server_addr().

network_larger()

Datum network_larger

(

PG_FUNCTION_ARGS

)

Definition at line 865 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (network_cmp_internal(a1, a2) > 0)
        PG_RETURN_INET_P(a1);
    else
        PG_RETURN_INET_P(a2);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_INET_P.

network_le()

Datum network_le

(

PG_FUNCTION_ARGS

)

Definition at line 805 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) <= 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_lt()

Datum network_lt

(

PG_FUNCTION_ARGS

)

Definition at line 796 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) < 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_masklen()

Datum network_masklen

(

PG_FUNCTION_ARGS

)

Definition at line 1258 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
 
    PG_RETURN_INT32(ip_bits(ip));
}

References ip_bits, PG_GETARG_INET_PP, and PG_RETURN_INT32.

network_ne()

Datum network_ne

(

PG_FUNCTION_ARGS

)

Definition at line 841 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    PG_RETURN_BOOL(network_cmp_internal(a1, a2) != 0);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_netmask()

Datum network_netmask

(

PG_FUNCTION_ARGS

)

Definition at line 1374 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *dst;
    int         byte;
    int         bits;
    unsigned char mask;
    unsigned char *b;
 
    /* make sure any unused bits are zeroed */
    dst = (inet *) palloc0(sizeof(inet));
 
    bits = ip_bits(ip);
    b = ip_addr(dst);
 
    byte = 0;
 
    while (bits)
    {
        if (bits >= 8)
        {
            mask = 0xff;
            bits -= 8;
        }
        else
        {
            mask = 0xff << (8 - bits);
            bits = 0;
        }
 
        b[byte] = mask;
        byte++;
    }
 
    ip_family(dst) = ip_family(ip);
    ip_bits(dst) = ip_maxbits(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References b, ip_addr, ip_bits, ip_family, ip_maxbits, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

network_network()

Datum network_network

(

PG_FUNCTION_ARGS

)

Definition at line 1330 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    inet       *dst;
    int         byte;
    int         bits;
    unsigned char mask;
    unsigned char *a,
               *b;
 
    /* make sure any unused bits are zeroed */
    dst = (inet *) palloc0(sizeof(inet));
 
    bits = ip_bits(ip);
    a = ip_addr(ip);
    b = ip_addr(dst);
 
    byte = 0;
 
    while (bits)
    {
        if (bits >= 8)
        {
            mask = 0xff;
            bits -= 8;
        }
        else
        {
            mask = 0xff << (8 - bits);
            bits = 0;
        }
 
        b[byte] = a[byte] & mask;
        byte++;
    }
 
    ip_family(dst) = ip_family(ip);
    ip_bits(dst) = ip_bits(ip);
    SET_INET_VARSIZE(dst);
 
    PG_RETURN_INET_P(dst);
}

References a, b, ip_addr, ip_bits, ip_family, palloc0(), PG_GETARG_INET_PP, PG_RETURN_INET_P, and SET_INET_VARSIZE.

Referenced by network_scan_first().

network_out()

static char* network_out ( inet *  src, bool  is_cidr  )

static

Definition at line 141 of file network.c.

{
    char        tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
    char       *dst;
    int         len;
 
    dst = pg_inet_net_ntop(ip_family(src), ip_addr(src), ip_bits(src),
                           tmp, sizeof(tmp));
    if (dst == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("could not format inet value: %m")));
 
    /* For CIDR, add /n if not present */
    if (is_cidr && strchr(tmp, '/') == NULL)
    {
        len = strlen(tmp);
        snprintf(tmp + len, sizeof(tmp) - len, "/%u", ip_bits(src));
    }
 
    return pstrdup(tmp);
}

References ereport, errcode(), errmsg(), ERROR, ip_addr, ip_bits, ip_family, len, pg_inet_net_ntop(), pstrdup(), and snprintf.

Referenced by cidr_out(), and inet_out().

network_overlap()

Datum network_overlap

(

PG_FUNCTION_ARGS

)

Definition at line 963 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (ip_family(a1) == ip_family(a2))
    {
        PG_RETURN_BOOL(bitncmp(ip_addr(a1), ip_addr(a2),
                               Min(ip_bits(a1), ip_bits(a2))) == 0);
    }
 
    PG_RETURN_BOOL(false);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, Min, PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_recv()

static inet* network_recv ( StringInfo  buf, bool  is_cidr  )

static

Definition at line 192 of file network.c.

{
    inet       *addr;
    char       *addrptr;
    int         bits;
    int         nb,
                i;
 
    /* make sure any unused bits in a CIDR value are zeroed */
    addr = (inet *) palloc0(sizeof(inet));
 
    ip_family(addr) = pq_getmsgbyte(buf);
    if (ip_family(addr) != PGSQL_AF_INET &&
        ip_family(addr) != PGSQL_AF_INET6)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
        /* translator: %s is inet or cidr */
                 errmsg("invalid address family in external \"%s\" value",
                        is_cidr ? "cidr" : "inet")));
    bits = pq_getmsgbyte(buf);
    if (bits < 0 || bits > ip_maxbits(addr))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
        /* translator: %s is inet or cidr */
                 errmsg("invalid bits in external \"%s\" value",
                        is_cidr ? "cidr" : "inet")));
    ip_bits(addr) = bits;
    i = pq_getmsgbyte(buf);     /* ignore is_cidr */
    nb = pq_getmsgbyte(buf);
    if (nb != ip_addrsize(addr))
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
        /* translator: %s is inet or cidr */
                 errmsg("invalid length in external \"%s\" value",
                        is_cidr ? "cidr" : "inet")));
 
    addrptr = (char *) ip_addr(addr);
    for (i = 0; i < nb; i++)
        addrptr[i] = pq_getmsgbyte(buf);
 
    /*
     * Error check: CIDR values must not have any bits set beyond the masklen.
     */
    if (is_cidr)
    {
        if (!addressOK(ip_addr(addr), bits, ip_family(addr)))
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                     errmsg("invalid external \"cidr\" value"),
                     errdetail("Value has bits set to right of mask.")));
    }
 
    SET_INET_VARSIZE(addr);
 
    return addr;
}

References addressOK(), buf, ereport, errcode(), errdetail(), errmsg(), ERROR, i, ip_addr, ip_addrsize, ip_bits, ip_family, ip_maxbits, palloc0(), PGSQL_AF_INET, PGSQL_AF_INET6, pq_getmsgbyte(), and SET_INET_VARSIZE.

Referenced by cidr_recv(), and inet_recv().

network_scan_first()

Datum network_scan_first

(

Datum

in

)

Definition at line 1690 of file network.c.

{
    return DirectFunctionCall1(network_network, in);
}

References DirectFunctionCall1, and network_network().

Referenced by match_network_subset().

network_scan_last()

Datum network_scan_last

(

Datum

in

)

Definition at line 1704 of file network.c.

{
    return DirectFunctionCall2(inet_set_masklen,
                               DirectFunctionCall1(network_broadcast, in),
                               Int32GetDatum(-1));
}

References DirectFunctionCall1, DirectFunctionCall2, inet_set_masklen(), Int32GetDatum(), and network_broadcast().

Referenced by match_network_subset().

network_send()

static bytea* network_send ( inet *  addr, bool  is_cidr  )

static

Definition at line 270 of file network.c.

{
    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, is_cidr);
    nb = ip_addrsize(addr);
    if (nb < 0)
        nb = 0;
    pq_sendbyte(&buf, nb);
    addrptr = (char *) ip_addr(addr);
    for (i = 0; i < nb; i++)
        pq_sendbyte(&buf, addrptr[i]);
    return pq_endtypsend(&buf);
}

References buf, i, ip_addr, ip_addrsize, ip_bits, ip_family, pq_begintypsend(), pq_endtypsend(), and pq_sendbyte().

Referenced by cidr_send(), and inet_send().

network_show()

Datum network_show

(

PG_FUNCTION_ARGS

)

Definition at line 1199 of file network.c.

{
    inet       *ip = PG_GETARG_INET_PP(0);
    int         len;
    char        tmp[sizeof("xxxx:xxxx:xxxx:xxxx:xxxx:xxxx:255.255.255.255/128")];
 
    if (pg_inet_net_ntop(ip_family(ip), ip_addr(ip), ip_maxbits(ip),
                         tmp, sizeof(tmp)) == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
                 errmsg("could not format inet value: %m")));
 
    /* Add /n if not present (which it won't be) */
    if (strchr(tmp, '/') == NULL)
    {
        len = strlen(tmp);
        snprintf(tmp + len, sizeof(tmp) - len, "/%u", ip_bits(ip));
    }
 
    PG_RETURN_TEXT_P(cstring_to_text(tmp));
}

References cstring_to_text(), ereport, errcode(), errmsg(), ERROR, ip_addr, ip_bits, ip_family, ip_maxbits, len, PG_GETARG_INET_PP, pg_inet_net_ntop(), PG_RETURN_TEXT_P, and snprintf.

network_smaller()

Datum network_smaller

(

PG_FUNCTION_ARGS

)

Definition at line 853 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (network_cmp_internal(a1, a2) < 0)
        PG_RETURN_INET_P(a1);
    else
        PG_RETURN_INET_P(a2);
}

References a1, a2, network_cmp_internal(), PG_GETARG_INET_PP, and PG_RETURN_INET_P.

network_sortsupport()

Datum network_sortsupport

(

PG_FUNCTION_ARGS

)

Definition at line 437 of file network.c.

{
    SortSupport ssup = (SortSupport) PG_GETARG_POINTER(0);
 
    ssup->comparator = network_fast_cmp;
    ssup->ssup_extra = NULL;
 
    if (ssup->abbreviate)
    {
        network_sortsupport_state *uss;
        MemoryContext oldcontext;
 
        oldcontext = MemoryContextSwitchTo(ssup->ssup_cxt);
 
        uss = palloc(sizeof(network_sortsupport_state));
        uss->input_count = 0;
        uss->estimating = true;
        initHyperLogLog(&uss->abbr_card, 10);
 
        ssup->ssup_extra = uss;
 
        ssup->comparator = ssup_datum_unsigned_cmp;
        ssup->abbrev_converter = network_abbrev_convert;
        ssup->abbrev_abort = network_abbrev_abort;
        ssup->abbrev_full_comparator = network_fast_cmp;
 
        MemoryContextSwitchTo(oldcontext);
    }
 
    PG_RETURN_VOID();
}

References network_sortsupport_state::abbr_card, SortSupportData::abbrev_abort, SortSupportData::abbrev_converter, SortSupportData::abbrev_full_comparator, SortSupportData::abbreviate, SortSupportData::comparator, network_sortsupport_state::estimating, initHyperLogLog(), network_sortsupport_state::input_count, MemoryContextSwitchTo(), network_abbrev_abort(), network_abbrev_convert(), network_fast_cmp(), palloc(), PG_GETARG_POINTER, PG_RETURN_VOID, SortSupportData::ssup_cxt, ssup_datum_unsigned_cmp(), and SortSupportData::ssup_extra.

network_sub()

Datum network_sub

(

PG_FUNCTION_ARGS

)

Definition at line 903 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (ip_family(a1) == ip_family(a2))
    {
        PG_RETURN_BOOL(ip_bits(a1) > ip_bits(a2) &&
                       bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a2)) == 0);
    }
 
    PG_RETURN_BOOL(false);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_subeq()

Datum network_subeq

(

PG_FUNCTION_ARGS

)

Definition at line 918 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (ip_family(a1) == ip_family(a2))
    {
        PG_RETURN_BOOL(ip_bits(a1) >= ip_bits(a2) &&
                       bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a2)) == 0);
    }
 
    PG_RETURN_BOOL(false);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_subset_support()

Datum network_subset_support

(

PG_FUNCTION_ARGS

)

Definition at line 981 of file network.c.

{
    Node       *rawreq = (Node *) PG_GETARG_POINTER(0);
    Node       *ret = NULL;
 
    if (IsA(rawreq, SupportRequestIndexCondition))
    {
        /* Try to convert operator/function call to index conditions */
        SupportRequestIndexCondition *req = (SupportRequestIndexCondition *) rawreq;
 
        if (is_opclause(req->node))
        {
            OpExpr     *clause = (OpExpr *) req->node;
 
            Assert(list_length(clause->args) == 2);
            ret = (Node *)
                match_network_function((Node *) linitial(clause->args),
                                       (Node *) lsecond(clause->args),
                                       req->indexarg,
                                       req->funcid,
                                       req->opfamily);
        }
        else if (is_funcclause(req->node))  /* be paranoid */
        {
            FuncExpr   *clause = (FuncExpr *) req->node;
 
            Assert(list_length(clause->args) == 2);
            ret = (Node *)
                match_network_function((Node *) linitial(clause->args),
                                       (Node *) lsecond(clause->args),
                                       req->indexarg,
                                       req->funcid,
                                       req->opfamily);
        }
    }
 
    PG_RETURN_POINTER(ret);
}

References FuncExpr::args, OpExpr::args, Assert(), SupportRequestIndexCondition::funcid, SupportRequestIndexCondition::indexarg, is_funcclause(), is_opclause(), IsA, linitial, list_length(), lsecond, match_network_function(), SupportRequestIndexCondition::node, SupportRequestIndexCondition::opfamily, PG_GETARG_POINTER, and PG_RETURN_POINTER.

network_sup()

Datum network_sup

(

PG_FUNCTION_ARGS

)

Definition at line 933 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (ip_family(a1) == ip_family(a2))
    {
        PG_RETURN_BOOL(ip_bits(a1) < ip_bits(a2) &&
                       bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a1)) == 0);
    }
 
    PG_RETURN_BOOL(false);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, and PG_RETURN_BOOL.

network_supeq()

Datum network_supeq

(

PG_FUNCTION_ARGS

)

Definition at line 948 of file network.c.

{
    inet       *a1 = PG_GETARG_INET_PP(0);
    inet       *a2 = PG_GETARG_INET_PP(1);
 
    if (ip_family(a1) == ip_family(a2))
    {
        PG_RETURN_BOOL(ip_bits(a1) <= ip_bits(a2) &&
                       bitncmp(ip_addr(a1), ip_addr(a2), ip_bits(a1)) == 0);
    }
 
    PG_RETURN_BOOL(false);
}

References a1, a2, bitncmp(), ip_addr, ip_bits, ip_family, PG_GETARG_INET_PP, and PG_RETURN_BOOL.