Defend against nulls-in-arrays in contrib/intarray. I may have put in

more tests than strictly necessary, but did not feel like tracing call
paths in detail ...

diff --git a/contrib/intarray/_int.h b/contrib/intarray/_int.h
index 702dfaade538cbd9578a3f27134f74f33a14e094..ec09b149733a877fa48bc4f0d5074f64153f0723 100644 (file)
--- a/contrib/intarray/_int.h
+++ b/contrib/intarray/_int.h
@@ -19,13 +19,24 @@
 
 /* useful macros for accessing int4 arrays */
 #define ARRPTR(x)  ( (int4 *) ARR_DATA_PTR(x) )
-#define ARRNELEMS(x)  ArrayGetNItems( ARR_NDIM(x), ARR_DIMS(x))
+#define ARRNELEMS(x)  ArrayGetNItems(ARR_NDIM(x), ARR_DIMS(x))
 
-#define ARRISVOID(x) ( (x) ? ( ( ARR_NDIM(x) == NDIM ) ? ( ( ARRNELEMS( x ) ) ? 0 : 1 ) : ( ( ARR_NDIM(x) ) ? ( \
-       ereport(ERROR, \
-                       (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), \
-                        errmsg("array must be one-dimensional, not %d dimensions", ARRNELEMS( x )))) \
-       ,1) : 0 )  ) : 0 )
+/* reject arrays we can't handle; but allow a NULL or empty array */
+#define CHECKARRVALID(x) \
+       do { \
+               if (x) { \
+                       if (ARR_NDIM(x) != NDIM && ARR_NDIM(x) != 0) \
+                               ereport(ERROR, \
+                                               (errcode(ERRCODE_ARRAY_SUBSCRIPT_ERROR), \
+                                                errmsg("array must be one-dimensional"))); \
+                       if (ARR_HASNULL(x)) \
+                               ereport(ERROR, \
+                                               (errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED), \
+                                                errmsg("array must not contain nulls"))); \
+               } \
+       } while(0)
+
+#define ARRISVOID(x)  ((x) == NULL || ARRNELEMS(x) == 0)
 
 #define SORT(x) \
        do { \
@@ -52,9 +63,6 @@
 typedef char BITVEC[SIGLEN];
 typedef char *BITVECP;
 
-#define SIGPTR(x)  ( (BITVECP) ARR_DATA_PTR(x) )
-
-
 #define LOOPBYTE(a) \
                for(i=0;i<SIGLEN;i++) {\
                                a;\

diff --git a/contrib/intarray/_int_bool.c b/contrib/intarray/_int_bool.c
index 824dc5b677569018d8a5f64465fb988b946df95e..8e0b913c0137e458fbd76fe6d13dfa237e08130d 100644 (file)
--- a/contrib/intarray/_int_bool.c
+++ b/contrib/intarray/_int_bool.c
@@ -309,6 +309,7 @@ execconsistent(QUERYTYPE * query, ArrayType *array, bool calcnot)
 {
        CHKVAL          chkval;
 
+       CHECKARRVALID(array);
        chkval.arrb = ARRPTR(array);
        chkval.arre = chkval.arrb + ARRNELEMS(array);
        return execute(
@@ -339,6 +340,7 @@ boolop(PG_FUNCTION_ARGS)
        CHKVAL          chkval;
        bool            result;
 
+       CHECKARRVALID(val);
        if (ARRISVOID(val))
        {
                pfree(val);

diff --git a/contrib/intarray/_int_gist.c b/contrib/intarray/_int_gist.c
index c5f8818aa3d3eaf4574e7f49fde865e66ba521c3..1e26bcef284fc9a123297690ae7177e74e9ea66e 100644 (file)
--- a/contrib/intarray/_int_gist.c
+++ b/contrib/intarray/_int_gist.c
@@ -44,6 +44,7 @@ g_int_consistent(PG_FUNCTION_ARGS)
        /* XXX are we sure it's safe to scribble on the query object here? */
        /* XXX what about toasted input? */
        /* sort query for fast search, key is already sorted */
+       CHECKARRVALID(query);
        if (ARRISVOID(query))
                PG_RETURN_BOOL(false);
        PREPAREARR(query);
@@ -89,21 +90,30 @@ g_int_union(PG_FUNCTION_ARGS)
 {
        GistEntryVector *entryvec = (GistEntryVector *) PG_GETARG_POINTER(0);
        int                *size = (int *) PG_GETARG_POINTER(1);
-       int4            i;
-       ArrayType  *res;
-       int                     totlen = 0,
+       int4            i,
                           *ptr;
+       ArrayType  *res;
+       int                     totlen = 0;
 
        for (i = 0; i < entryvec->n; i++)
-               totlen += ARRNELEMS(GETENTRY(entryvec, i));
+       {
+               ArrayType *ent = GETENTRY(entryvec, i);
+
+               CHECKARRVALID(ent);
+               totlen += ARRNELEMS(ent);
+       }
 
        res = new_intArrayType(totlen);
        ptr = ARRPTR(res);
 
        for (i = 0; i < entryvec->n; i++)
        {
-               memcpy(ptr, ARRPTR(GETENTRY(entryvec, i)), ARRNELEMS(GETENTRY(entryvec, i)) * sizeof(int4));
-               ptr += ARRNELEMS(GETENTRY(entryvec, i));
+               ArrayType *ent = GETENTRY(entryvec, i);
+               int nel;
+
+               nel = ARRNELEMS(ent);
+               memcpy(ptr, ARRPTR(ent), nel * sizeof(int4));
+               ptr += nel;
        }
 
        QSORT(res, 1);
@@ -130,6 +140,7 @@ g_int_compress(PG_FUNCTION_ARGS)
        if (entry->leafkey)
        {
                r = (ArrayType *) PG_DETOAST_DATUM_COPY(entry->key);
+               CHECKARRVALID(r);
                PREPAREARR(r);
 
                if (ARRNELEMS(r)>= 2 * MAXNUMRANGE)
@@ -147,6 +158,7 @@ g_int_compress(PG_FUNCTION_ARGS)
            so now we work only with internal keys  */
 
        r = (ArrayType *) PG_DETOAST_DATUM(entry->key);
+       CHECKARRVALID(r);
        if (ARRISVOID(r)) 
        {
                if (r != (ArrayType *) DatumGetPointer(entry->key))
@@ -207,6 +219,7 @@ g_int_decompress(PG_FUNCTION_ARGS)
 
        in = (ArrayType *) PG_DETOAST_DATUM(entry->key);
 
+       CHECKARRVALID(in);
        if (ARRISVOID(in))
                PG_RETURN_POINTER(entry);
 
@@ -280,6 +293,9 @@ g_int_same(PG_FUNCTION_ARGS)
        int4       *da,
                           *db;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (n != ARRNELEMS(b))
        {
                *result = false;

diff --git a/contrib/intarray/_int_op.c b/contrib/intarray/_int_op.c
index 70951bfd47a7506394270f8ae959ae3eb2b762a8..7a2065bc214e8ebcd7c2011cd70d712eba1db9d0 100644 (file)
--- a/contrib/intarray/_int_op.c
+++ b/contrib/intarray/_int_op.c
@@ -37,6 +37,8 @@ _int_contains(PG_FUNCTION_ARGS)
        ArrayType  *b = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
        bool            res;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
        if (ARRISVOID(a) || ARRISVOID(b))
                return FALSE;
 
@@ -71,9 +73,13 @@ _int_same(PG_FUNCTION_ARGS)
        int                *da,
                           *db;
        bool            result;
-       bool            avoid = ARRISVOID(a);
-       bool            bvoid = ARRISVOID(b);
+       bool            avoid;
+       bool            bvoid;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+       avoid = ARRISVOID(a);
+       bvoid = ARRISVOID(b);
        if (avoid || bvoid)
                return (avoid && bvoid) ? TRUE : FALSE;
 
@@ -112,6 +118,8 @@ _int_overlap(PG_FUNCTION_ARGS)
        ArrayType  *b = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
        bool            result;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
        if (ARRISVOID(a) || ARRISVOID(b))
                return FALSE;
 
@@ -133,6 +141,9 @@ _int_union(PG_FUNCTION_ARGS)
        ArrayType  *b = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
        ArrayType  *result;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (!ARRISVOID(a))
                SORT(a);
        if (!ARRISVOID(b))
@@ -155,6 +166,8 @@ _int_inter(PG_FUNCTION_ARGS)
        ArrayType  *b = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
        ArrayType  *result;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
        if (ARRISVOID(a) || ARRISVOID(b))
                PG_RETURN_POINTER(new_intArrayType(0));
 
@@ -197,12 +210,6 @@ Datum              intarray_del_elem(PG_FUNCTION_ARGS);
 Datum          intset_union_elem(PG_FUNCTION_ARGS);
 Datum          intset_subtract(PG_FUNCTION_ARGS);
 
-#define QSORT(a, direction)                                            \
-if (ARRNELEMS(a) > 1)                                          \
-       qsort((void*)ARRPTR(a), ARRNELEMS(a),sizeof(int4),      \
-               (direction) ? compASC : compDESC )
-
-
 Datum
 intset(PG_FUNCTION_ARGS)
 {
@@ -213,7 +220,7 @@ Datum
 icount(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
-       int32           count = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
+       int32           count = ARRNELEMS(a);
 
        PG_FREE_IF_COPY(a, 0);
        PG_RETURN_INT32(count);
@@ -228,6 +235,7 @@ sort(PG_FUNCTION_ARGS)
        char       *d = (dirstr) ? VARDATA(dirstr) : NULL;
        int                     dir = -1;
 
+       CHECKARRVALID(a);
        if (ARRISVOID(a) || ARRNELEMS(a) < 2)
                PG_RETURN_POINTER(a);
 
@@ -255,6 +263,7 @@ sort_asc(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));
 
+       CHECKARRVALID(a);
        if (ARRISVOID(a))
                PG_RETURN_POINTER(a);
        QSORT(a, 1);
@@ -266,6 +275,7 @@ sort_desc(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));
 
+       CHECKARRVALID(a);
        if (ARRISVOID(a))
                PG_RETURN_POINTER(a);
        QSORT(a, 0);
@@ -277,6 +287,7 @@ uniq(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));
 
+       CHECKARRVALID(a);
        if (ARRISVOID(a) || ARRNELEMS(a) < 2)
                PG_RETURN_POINTER(a);
        a = _int_unique(a);
@@ -287,8 +298,10 @@ Datum
 idx(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM(PG_GETARG_DATUM(0)));
-       int32           result = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
+       int32           result;
 
+       CHECKARRVALID(a);
+       result = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
        if (result)
                result = intarray_match_first(a, PG_GETARG_INT32(1));
        PG_FREE_IF_COPY(a, 0);
@@ -305,6 +318,7 @@ subarray(PG_FUNCTION_ARGS)
        int32           end = 0;
        int32           c;
 
+       CHECKARRVALID(a);
        if (ARRISVOID(a))
        {
                PG_FREE_IF_COPY(a, 0);
@@ -371,22 +385,29 @@ Datum
 intarray_del_elem(PG_FUNCTION_ARGS)
 {
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));
-       int32           c = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
-       int32      *aa = ARRPTR(a);
+       int32           elem = PG_GETARG_INT32(1);
+       int32           c;
+       int32      *aa;
        int32           n = 0,
                                i;
-       int32           elem = PG_GETARG_INT32(1);
 
-       for (i = 0; i < c; i++)
-               if (aa[i] != elem)
+       CHECKARRVALID(a);
+       if (!ARRISVOID(a))
+       {
+               c = ARRNELEMS(a);
+               aa = ARRPTR(a);
+               for (i = 0; i < c; i++)
                {
-                       if (i > n)
-                               aa[n++] = aa[i];
-                       else
-                               n++;
+                       if (aa[i] != elem)
+                       {
+                               if (i > n)
+                                       aa[n++] = aa[i];
+                               else
+                                       n++;
+                       }
                }
-       if (c > 0)
                a = resize_intArrayType(a, n);
+       }
        PG_RETURN_POINTER(a);
 }
 
@@ -408,8 +429,8 @@ intset_subtract(PG_FUNCTION_ARGS)
        ArrayType  *a = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(0)));
        ArrayType  *b = (ArrayType *) DatumGetPointer(PG_DETOAST_DATUM_COPY(PG_GETARG_DATUM(1)));
        ArrayType  *result;
-       int32           ca = ARRISVOID(a);
-       int32           cb = ARRISVOID(b);
+       int32           ca;
+       int32           cb;
        int32      *aa,
                           *bb,
                           *r;
@@ -417,6 +438,9 @@ intset_subtract(PG_FUNCTION_ARGS)
                                i = 0,
                                k = 0;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        QSORT(a, 1);
        a = _int_unique(a);
        ca = ARRNELEMS(a);

diff --git a/contrib/intarray/_int_tool.c b/contrib/intarray/_int_tool.c
index 13c5d1e9e243950c12baa88a5f75b2ca49f9a8bb..480e16ed9fe57eebe1a08cb372ea5db64f9a8ca9 100644 (file)
--- a/contrib/intarray/_int_tool.c
+++ b/contrib/intarray/_int_tool.c
@@ -12,6 +12,9 @@ inner_int_contains(ArrayType *a, ArrayType *b)
        int                *da,
                           *db;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (ARRISVOID(a) || ARRISVOID(b))
                return FALSE;
 
@@ -46,6 +49,9 @@ inner_int_overlap(ArrayType *a, ArrayType *b)
        int                *da,
                           *db;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (ARRISVOID(a) || ARRISVOID(b))
                return FALSE;
 
@@ -78,6 +84,9 @@ inner_int_union(ArrayType *a, ArrayType *b)
        int                     i,
                                j;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (ARRISVOID(a) && ARRISVOID(b))
                return new_intArrayType(0);
        if (ARRISVOID(a))
@@ -130,6 +139,9 @@ inner_int_inter(ArrayType *a, ArrayType *b)
        int                     i,
                                j;
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
+
        if (ARRISVOID(a) || ARRISVOID(b))
                return new_intArrayType(0);
 
@@ -243,7 +255,7 @@ copy_intArrayType(ArrayType *a)
        ArrayType  *r;
 
        r = new_intArrayType(ARRNELEMS(a));
-       memmove(r, a, VARSIZE(a));
+       memmove(r, a, VARSIZE(r));
        return r;
 }
 
@@ -270,6 +282,8 @@ _int_unique(ArrayType *r)
                           *data;
        int                     num = ARRNELEMS(r);
 
+       CHECKARRVALID(r);
+
        if (num < 2)
                return r;
 
@@ -302,7 +316,10 @@ intarray_match_first(ArrayType *a, int32 elem)
                                c,
                                i;
 
-       c = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
+       CHECKARRVALID(a);
+       if (ARRISVOID(a))
+               return 0;
+       c = ARRNELEMS(a);
        aa = ARRPTR(a);
        for (i = 0; i < c; i++)
                if (aa[i] == elem)
@@ -315,8 +332,10 @@ intarray_add_elem(ArrayType *a, int32 elem)
 {
        ArrayType  *result;
        int32      *r;
-       int32           c = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
+       int32           c;
 
+       CHECKARRVALID(a);
+       c = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
        result = new_intArrayType(c + 1);
        r = ARRPTR(result);
        if (c > 0)
@@ -332,6 +351,8 @@ intarray_concat_arrays(ArrayType *a, ArrayType *b)
        int32           ac = (ARRISVOID(a)) ? 0 : ARRNELEMS(a);
        int32           bc = (ARRISVOID(b)) ? 0 : ARRNELEMS(b);
 
+       CHECKARRVALID(a);
+       CHECKARRVALID(b);
        result = new_intArrayType(ac + bc);
        if (ac)
                memcpy(ARRPTR(result), ARRPTR(a), ac * sizeof(int32));

diff --git a/contrib/intarray/_intbig_gist.c b/contrib/intarray/_intbig_gist.c
index 237281aec5b61dba3aa2b4db555c9ed893265916..0064e450ddb9145241cb46d2284656cfe92d9d15 100644 (file)
--- a/contrib/intarray/_intbig_gist.c
+++ b/contrib/intarray/_intbig_gist.c
@@ -66,6 +66,8 @@ _intbig_overlap(GISTTYPE * a, ArrayType *b)
        int                     num = ARRNELEMS(b);
        int4       *ptr = ARRPTR(b);
 
+       CHECKARRVALID(b);
+
        while (num--)
        {
                if (GETBIT(GETSIGN(a), HASHVAL(*ptr)))
@@ -82,6 +84,8 @@ _intbig_contains(GISTTYPE * a, ArrayType *b)
        int                     num = ARRNELEMS(b);
        int4       *ptr = ARRPTR(b);
 
+       CHECKARRVALID(b);
+
        while (num--)
        {
                if (!GETBIT(GETSIGN(a), HASHVAL(*ptr)))
@@ -136,10 +140,17 @@ g_intbig_compress(PG_FUNCTION_ARGS)
                int                     num;
                GISTTYPE   *res = (GISTTYPE *) palloc(CALCGTSIZE(0));
 
-               ARRISVOID(in);
-
-               ptr = ARRPTR(in);
-               num = ARRNELEMS(in);
+               CHECKARRVALID(in);
+               if (ARRISVOID(in))
+               {
+                       ptr = NULL;
+                       num = 0;
+               }
+               else
+               {
+                       ptr = ARRPTR(in);
+                       num = ARRNELEMS(in);
+               }
                memset(res, 0, CALCGTSIZE(0));
                res->len = CALCGTSIZE(0);
 
@@ -492,6 +503,7 @@ g_intbig_consistent(PG_FUNCTION_ARGS)
        }
 
        /* XXX what about toasted input? */
+       CHECKARRVALID(query);
        if (ARRISVOID(query))
                return FALSE;
 
@@ -510,6 +522,8 @@ g_intbig_consistent(PG_FUNCTION_ARGS)
                                BITVECP         dq,
                                                        de;
 
+                               CHECKARRVALID(query);
+
                                memset(qp, 0, sizeof(BITVEC));
 
                                while (num--)
@@ -546,6 +560,8 @@ g_intbig_consistent(PG_FUNCTION_ARGS)
                                BITVECP         dq,
                                                        de;
 
+                               CHECKARRVALID(query);
+
                                memset(qp, 0, sizeof(BITVEC));
 
                                while (num--)